public override TargetObject GetField(Thread thread,
TargetStructObject instance,
TargetFieldInfo field)
{
if (field.HasConstValue)
{
return(SymbolFile.MonoLanguage.CreateInstance(thread, field.ConstValue));
}
if (field.IsStatic)
{
return(GetStaticField(thread, field));
}
else
{
if (instance == null)
{
throw new InvalidOperationException();
}
return((TargetObject)thread.ThreadServant.DoTargetAccess(
delegate(TargetMemoryAccess target) {
return GetInstanceField(target, instance, field);
}));
}
}
TargetClassObject CheckTypeProxy(TargetStructObject obj)
{
if (obj.Type.DebuggerTypeProxyAttribute == null)
{
return(null);
}
string proxy_name = obj.Type.DebuggerTypeProxyAttribute.ProxyTypeName;
string original_name = proxy_name;
proxy_name = proxy_name.Replace('+', '/');
Expression expression;
try {
expression = new TypeProxyExpression(proxy_name, obj);
expression = expression.Resolve(this);
if (expression == null)
{
return(null);
}
return((TargetClassObject)expression.EvaluateObject(this));
} catch {
return(null);
}
}
internal TargetObject GetInstanceField(TargetMemoryAccess target,
TargetStructObject instance,
TargetFieldInfo field)
{
GetFields(target);
int offset = field_offsets [field.Position];
TargetType type = field_types [field.Position];
if (!Type.IsByRef)
{
offset -= 2 * target.TargetMemoryInfo.TargetAddressSize;
}
TargetLocation field_loc = instance.Location.GetLocationAtOffset(offset);
TargetAddress orig_addr = field_loc.GetAddress(target);
if (type.IsByRef)
{
field_loc = field_loc.GetDereferencedLocation();
}
TargetAddress addr = field_loc.GetAddress(target);
if (field_loc.HasAddress && field_loc.GetAddress(target).IsNull)
{
return(new TargetNullObject(type));
}
return(type.GetObject(target, field_loc));
}
public override void SetField(Thread thread, TargetStructObject instance,
TargetFieldInfo field, TargetObject value)
{
if (field.IsStatic)
{
if (instance != null)
{
throw new InvalidOperationException();
}
SetStaticField(thread, field, value);
}
else
{
if (instance == null)
{
throw new InvalidOperationException();
}
thread.ThreadServant.DoTargetAccess(
delegate(TargetMemoryAccess target) {
SetInstanceField(target, instance, field, value);
return(null);
});
}
}
public static EE.EvaluationResult HandleDebuggerDisplay(Interpreter interpreter,
Thread thread,
TargetStructObject instance,
DebuggerDisplayAttribute attr,
int timeout, out string name,
out string type)
{
ScriptingContext expr_context = new ScriptingContext(interpreter);
expr_context.CurrentThread = thread;
expr_context.CurrentLanguage = instance.Type.Language;
expr_context.ImplicitInstance = instance;
EE.EvaluationResult result = expr_context.HandleDebuggerDisplay(
thread, instance, attr.Value, timeout, out name);
if (result != EE.EvaluationResult.Ok)
{
type = null;
return(result);
}
if (String.IsNullOrEmpty(attr.Type))
{
type = null;
return(EE.EvaluationResult.Ok);
}
return(expr_context.HandleDebuggerDisplay(
thread, instance, attr.Type, timeout, out type));
}
public static TargetStructObject ToStructObject(MdbEvaluationContext ctx, TargetObject obj)
{
TargetStructObject sobj = obj as TargetStructObject;
if (sobj != null)
{
return(sobj);
}
TargetObjectObject oobj = obj as TargetObjectObject;
if (oobj != null)
{
return(oobj.GetClassObject(ctx.Thread));
}
TargetArrayObject aobj = obj as TargetArrayObject;
if ((aobj != null) && aobj.HasClassObject)
{
return(aobj.GetClassObject(ctx.Thread));
}
return(null);
}
public RuntimeInvokeResult RuntimeInvoke(Thread thread,
TargetFunctionType function,
TargetStructObject object_argument,
TargetObject[] param_objects,
RuntimeInvokeFlags flags)
{
IInterruptionHandler interruption = InterruptionHandler ?? Interpreter;
if (interruption.CheckInterruption())
{
throw new EvaluationTimeoutException();
}
RuntimeInvokeResult result = thread.RuntimeInvoke(
function, object_argument, param_objects, flags);
WaitHandle[] handles = new WaitHandle [2];
handles [0] = interruption.InterruptionEvent;
handles [1] = result.CompletedEvent;
int ret = WaitHandle.WaitAny(handles);
if (ret == 0)
{
result.Abort();
throw new EvaluationTimeoutException();
}
return(result);
}
public PropertyReference(EvaluationContext ctx, TargetPropertyInfo prop, TargetStructObject thisobj) : base(ctx)
{
this.prop = prop;
if (!prop.IsStatic)
{
this.thisobj = thisobj;
}
}
public override void RuntimeInvoke(TargetFunctionType function,
TargetStructObject object_argument,
TargetObject[] param_objects,
RuntimeInvokeFlags flags,
RuntimeInvokeResult result)
{
throw new InvalidOperationException();
}
public FieldReference(EvaluationContext ctx, TargetStructObject thisobj, TargetType type, TargetFieldInfo field) : base(ctx)
{
this.type = type;
this.field = field;
if (!field.IsStatic)
{
this.thisobj = thisobj;
}
}
static TargetStructObject TryCurrentCast(MdbEvaluationContext ctx, TargetClassObject source, TargetClassType target_type)
{
TargetStructObject current = source.GetCurrentObject(ctx.Thread);
if (current == null)
{
return(null);
}
return(TryParentCast(ctx, current, current.Type, target_type));
}
public override TargetObject GetField(Thread thread,
TargetStructObject instance,
TargetFieldInfo field)
{
if (field.HasConstValue)
return type.Language.CreateInstance (thread, field.ConstValue);
return (TargetObject) thread.ThreadServant.DoTargetAccess (
delegate (TargetMemoryAccess target) {
return GetField (target, instance, field);
});
}
public RuntimeInvokeResult RuntimeInvoke(TargetFunctionType function,
TargetStructObject object_argument,
TargetObject[] param_objects,
RuntimeInvokeFlags flags)
{
lock (this) {
check_alive();
RuntimeInvokeResult result = new RuntimeInvokeResult(this);
servant.RuntimeInvoke(
function, object_argument, param_objects,
flags, result);
return(result);
}
}
public override TargetObject GetField(Thread thread,
TargetStructObject instance,
TargetFieldInfo field)
{
if (field.HasConstValue)
{
return(type.Language.CreateInstance(thread, field.ConstValue));
}
return((TargetObject)thread.ThreadServant.DoTargetAccess(
delegate(TargetMemoryAccess target) {
return GetField(target, instance, field);
}));
}
public static ValueReference CreateIndexerValueReference(MdbEvaluationContext ctx, TargetObject target, TargetObject[] index)
{
TargetFundamentalObject mstr = target as TargetFundamentalObject;
if (mstr != null && mstr.TypeName == "string")
{
// Special case for strings
string name = "[" + ctx.Evaluator.TargetObjectToExpression(ctx, index[0]) + "]";
string val = (string)mstr.GetObject(ctx.Thread);
object oo = ctx.Adapter.TargetObjectToObject(ctx, index[0]);
int idx = (int)Convert.ChangeType(oo, typeof(int));
return(LiteralValueReference.CreateObjectLiteral(ctx, name, val [idx]));
}
TargetStructObject sob = target as TargetStructObject;
if (sob == null)
{
return(null);
}
TargetPropertyInfo indexerProp = null;
foreach (MemberReference mem in ObjectUtil.GetTypeMembers(ctx, target.Type, false, true, true, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static))
{
if (mem.Member.IsStatic)
{
continue;
}
if (mem.Member is TargetPropertyInfo)
{
TargetPropertyInfo prop = (TargetPropertyInfo)mem.Member;
if (prop.CanRead && prop.Getter.ParameterTypes.Length == 1)
{
indexerProp = prop;
break;
}
}
}
if (indexerProp != null)
{
return(new IndexerValueReference(ctx, sob, index, indexerProp));
}
else
{
return(null);
}
}
public static TargetClassObject CheckTypeProxy(Interpreter interpreter, Thread thread,
TargetStructObject obj)
{
if (obj.Type.DebuggerTypeProxyAttribute == null)
{
return(null);
}
ScriptingContext expr_context = new ScriptingContext(interpreter);
expr_context.CurrentThread = thread;
expr_context.CurrentLanguage = obj.Type.Language;
expr_context.ImplicitInstance = obj;
return(expr_context.CheckTypeProxy(obj));
}
public override void SetField(Thread thread, TargetStructObject instance,
TargetFieldInfo field, TargetObject value)
{
TargetLocation field_loc = instance.Location.GetLocationAtOffset (field.Offset);
if (field.Type.IsByRef)
field_loc = field_loc.GetDereferencedLocation ();
NativeFieldInfo nfield = (NativeFieldInfo) field;
if (!field.Type.IsByRef && nfield.IsBitfield)
field_loc = new BitfieldTargetLocation (
field_loc, nfield.BitOffset, nfield.BitSize);
// field.Type.SetObject (field_loc, value);
throw new NotImplementedException ();
}
public RuntimeInvokeResult RuntimeInvoke(TargetFunctionType function,
TargetStructObject object_argument,
TargetObject[] param_objects,
bool is_virtual, bool debug)
{
RuntimeInvokeFlags flags = RuntimeInvokeFlags.None;
if (is_virtual)
{
flags |= RuntimeInvokeFlags.VirtualMethod;
}
if (debug)
{
flags |= RuntimeInvokeFlags.BreakOnEntry;
}
return(RuntimeInvoke(function, object_argument, param_objects, flags));
}
internal TargetObject GetField(TargetMemoryAccess target,
TargetStructObject instance,
TargetFieldInfo field)
{
TargetLocation field_loc = instance.Location.GetLocationAtOffset(field.Offset);
if (field.Type.IsByRef)
{
field_loc = field_loc.GetDereferencedLocation();
}
NativeFieldInfo nfield = (NativeFieldInfo)field;
if (!field.Type.IsByRef && nfield.IsBitfield)
{
field_loc = new BitfieldTargetLocation(
field_loc, nfield.BitOffset, nfield.BitSize);
}
return(field.Type.GetObject(target, field_loc));
}
public override void SetField(Thread thread, TargetStructObject instance,
TargetFieldInfo field, TargetObject value)
{
TargetLocation field_loc = instance.Location.GetLocationAtOffset(field.Offset);
if (field.Type.IsByRef)
{
field_loc = field_loc.GetDereferencedLocation();
}
NativeFieldInfo nfield = (NativeFieldInfo)field;
if (!field.Type.IsByRef && nfield.IsBitfield)
{
field_loc = new BitfieldTargetLocation(
field_loc, nfield.BitOffset, nfield.BitSize);
}
// field.Type.SetObject (field_loc, value);
throw new NotImplementedException();
}
static TargetStructObject TryParentCast(MdbEvaluationContext ctx, TargetStructObject source, TargetStructType source_type, TargetStructType target_type)
{
if (source_type == target_type)
{
return(source);
}
if (!source_type.HasParent)
{
return(null);
}
TargetStructType parent_type = source_type.GetParentType(ctx.Thread);
source = TryParentCast(ctx, source, parent_type, target_type);
if (source == null)
{
return(null);
}
return(source.GetParentObject(ctx.Thread) as TargetClassObject);
}
internal void SetInstanceField(TargetMemoryAccess target,
TargetStructObject instance,
TargetFieldInfo field, TargetObject obj)
{
GetFields(target);
int offset = field_offsets [field.Position];
TargetType type = field_types [field.Position];
if (!Type.IsByRef)
{
offset -= 2 * target.TargetMemoryInfo.TargetAddressSize;
}
TargetLocation field_loc = instance.Location.GetLocationAtOffset(offset);
if (type.IsByRef)
{
field_loc = field_loc.GetDereferencedLocation();
}
type.SetObject(target, field_loc, obj);
}
public static TargetObject TryCast(MdbEvaluationContext ctx, TargetObject source, TargetClassType target_type)
{
if (source.Type == target_type)
{
return(source);
}
TargetClassObject sobj = ToClassObject(ctx, source);
if (sobj == null)
{
return(null);
}
TargetStructObject result = TryParentCast(ctx, sobj, sobj.Type, target_type);
if (result != null)
{
return(result);
}
return(TryCurrentCast(ctx, sobj, target_type));
}
public abstract void RuntimeInvoke(TargetFunctionType function,
TargetStructObject object_argument,
TargetObject[] param_objects,
RuntimeInvokeFlags flags,
RuntimeInvokeResult result);
internal TargetObject GetField(TargetMemoryAccess target,
TargetStructObject instance,
TargetFieldInfo field)
{
TargetLocation field_loc = instance.Location.GetLocationAtOffset (field.Offset);
if (field.Type.IsByRef)
field_loc = field_loc.GetDereferencedLocation ();
NativeFieldInfo nfield = (NativeFieldInfo) field;
if (!field.Type.IsByRef && nfield.IsBitfield)
field_loc = new BitfieldTargetLocation (
field_loc, nfield.BitOffset, nfield.BitSize);
return field.Type.GetObject (target, field_loc);
}
public IndexerValueReference(EvaluationContext ctx, TargetStructObject target, TargetObject[] index, TargetPropertyInfo indexerProp) : base(ctx)
{
this.indexer = indexerProp;
this.target = target;
this.index = index;
}
internal void SetInstanceField(TargetMemoryAccess target,
TargetStructObject instance,
TargetFieldInfo field, TargetObject obj)
{
GetFields (target);
int offset = field_offsets [field.Position];
TargetType type = field_types [field.Position];
if (!Type.IsByRef)
offset -= 2 * target.TargetMemoryInfo.TargetAddressSize;
TargetLocation field_loc = instance.Location.GetLocationAtOffset (offset);
if (type.IsByRef)
field_loc = field_loc.GetDereferencedLocation ();
type.SetObject (target, field_loc, obj);
}
internal TargetObject GetInstanceField(TargetMemoryAccess target,
TargetStructObject instance,
TargetFieldInfo field)
{
GetFields (target);
int offset = field_offsets [field.Position];
TargetType type = field_types [field.Position];
if (!Type.IsByRef)
offset -= 2 * target.TargetMemoryInfo.TargetAddressSize;
TargetLocation field_loc = instance.Location.GetLocationAtOffset (offset);
TargetAddress orig_addr = field_loc.GetAddress (target);
if (type.IsByRef)
field_loc = field_loc.GetDereferencedLocation ();
TargetAddress addr = field_loc.GetAddress (target);
if (field_loc.HasAddress && field_loc.GetAddress (target).IsNull)
return new TargetNullObject (type);
return type.GetObject (target, field_loc);
}
public static EvaluationResult MonoObjectToString(Thread thread, TargetStructObject obj,
EvaluationFlags flags, int timeout,
out string result)
{
result = null;
if (!obj.Type.Language.IsManaged)
{
return(EvaluationResult.MethodNotFound);
}
again:
TargetStructType ctype = obj.Type;
if ((ctype.Name == "System.Object") || (ctype.Name == "System.ValueType"))
{
return(EvaluationResult.MethodNotFound);
}
TargetClass klass = ctype.GetClass(thread);
if (klass == null)
{
return(EvaluationResult.NotInitialized);
}
TargetMethodInfo[] methods = klass.GetMethods(thread);
if (methods == null)
{
return(EvaluationResult.MethodNotFound);
}
foreach (TargetMethodInfo minfo in methods)
{
if (minfo.Name != "ToString")
{
continue;
}
TargetFunctionType ftype = minfo.Type;
if (ftype.ParameterTypes.Length != 0)
{
continue;
}
if (ftype.ReturnType != ftype.Language.StringType)
{
continue;
}
RuntimeInvokeResult rti;
try {
RuntimeInvokeFlags rti_flags = RuntimeInvokeFlags.VirtualMethod;
if ((flags & EvaluationFlags.NestedBreakStates) != 0)
{
rti_flags |= RuntimeInvokeFlags.NestedBreakStates;
}
rti = thread.RuntimeInvoke(
ftype, obj, new TargetObject [0], rti_flags);
if (!rti.CompletedEvent.WaitOne(timeout, false))
{
rti.Abort();
return(EvaluationResult.Timeout);
}
if ((rti.TargetException != null) &&
(rti.TargetException.Type == TargetError.ClassNotInitialized))
{
result = null;
return(EvaluationResult.NotInitialized);
}
if (rti.Result is Exception)
{
result = ((Exception)rti.Result).Message;
return(EvaluationResult.UnknownError);
}
if (rti.ExceptionMessage != null)
{
result = rti.ExceptionMessage;
return(EvaluationResult.Exception);
}
else if (rti.ReturnObject == null)
{
rti.Abort();
return(EvaluationResult.UnknownError);
}
} catch (TargetException ex) {
result = ex.ToString();
return(EvaluationResult.UnknownError);
}
TargetObject retval = (TargetObject)rti.ReturnObject;
result = (string)((TargetFundamentalObject)retval).GetObject(thread);
return(EvaluationResult.Ok);
}
if (obj.Type.HasParent)
{
obj = obj.GetParentObject(thread) as TargetClassObject;
if (obj != null)
{
goto again;
}
}
return(EvaluationResult.MethodNotFound);
}
public EE.EvaluationResult GetProperty(Thread thread, TargetPropertyInfo property,
TargetStructObject instance, EE.EvaluationFlags flags,
int timeout, out string error, out TargetObject value)
{
return(EE.GetProperty(thread, property, instance, flags, timeout, out error, out value));
}
public EE.EvaluationResult MonoObjectToString(Thread thread, TargetStructObject obj,
EE.EvaluationFlags flags, int timeout,
out string text)
{
return(EE.MonoObjectToString(thread, obj, flags, timeout, out text));
}
public override void SetField(Thread thread, TargetStructObject instance,
TargetFieldInfo field, TargetObject value)
{
if (field.IsStatic) {
if (instance != null)
throw new InvalidOperationException ();
SetStaticField (thread, field, value);
} else {
if (instance == null)
throw new InvalidOperationException ();
thread.ThreadServant.DoTargetAccess (
delegate (TargetMemoryAccess target) {
SetInstanceField (target, instance, field, value);
return null;
});
}
}
EE.EvaluationResult HandleDebuggerDisplay(Thread thread, TargetStructObject instance,
string attr_value, int timeout,
out string result)
{
result = null;
StringBuilder sb = new StringBuilder();
int pos = 0;
while (pos < attr_value.Length)
{
if (attr_value [pos] == '\\')
{
if (pos == attr_value.Length)
{
break;
}
else
{
sb.Append(attr_value [++pos]);
pos++;
continue;
}
}
if (attr_value [pos] == '}')
{
result = null;
return(EE.EvaluationResult.InvalidExpression);
}
if (attr_value [pos] != '{')
{
sb.Append(attr_value [pos++]);
continue;
}
pos++;
StringBuilder expr_text = new StringBuilder();
while (pos < attr_value.Length)
{
if (attr_value [pos] == '\\')
{
if (pos == attr_value.Length)
{
break;
}
else
{
expr_text.Append(attr_value [++pos]);
pos++;
continue;
}
}
else if (attr_value [pos] == '{')
{
result = null;
return(EE.EvaluationResult.InvalidExpression);
}
else if (attr_value [pos] == '}')
{
pos++;
break;
}
expr_text.Append(attr_value [pos++]);
}
Expression expr;
try {
expr = Interpreter.ExpressionParser.ParseInternal(expr_text.ToString());
} catch (ExpressionParsingException ex) {
result = ex.Message;
return(EE.EvaluationResult.InvalidExpression);
} catch {
return(EE.EvaluationResult.InvalidExpression);
}
try {
expr = expr.Resolve(this);
} catch (ScriptingException ex) {
result = ex.Message;
return(EE.EvaluationResult.InvalidExpression);
} catch {
return(EE.EvaluationResult.InvalidExpression);
}
string text;
try {
object retval = expr.Evaluate(this);
if (retval is TargetObject)
{
text = DoFormatObject(
(TargetObject)retval, DisplayFormat.Object);
}
else
{
text = interpreter.Style.FormatObject(
CurrentThread, retval, DisplayFormat.Object);
}
} catch (ScriptingException ex) {
result = ex.Message;
return(EE.EvaluationResult.InvalidExpression);
} catch {
return(EE.EvaluationResult.InvalidExpression);
}
sb.Append(text);
}
result = sb.ToString();
return(EE.EvaluationResult.Ok);
}
public static EvaluationResult GetProperty(Thread thread, TargetPropertyInfo property,
TargetStructObject instance, EvaluationFlags flags,
int timeout, out string error, out TargetObject result)
{
error = null;
RuntimeInvokeResult rti;
try {
RuntimeInvokeFlags rti_flags = RuntimeInvokeFlags.VirtualMethod;
if ((flags & EvaluationFlags.NestedBreakStates) != 0)
{
rti_flags |= RuntimeInvokeFlags.NestedBreakStates;
}
rti = thread.RuntimeInvoke(
property.Getter, instance, new TargetObject [0], rti_flags);
if (!rti.CompletedEvent.WaitOne(timeout, false))
{
rti.Abort();
result = null;
return(EvaluationResult.Timeout);
}
if ((rti.TargetException != null) &&
(rti.TargetException.Type == TargetError.ClassNotInitialized))
{
result = null;
error = rti.ExceptionMessage;
return(EvaluationResult.NotInitialized);
}
if (rti.Result is Exception)
{
result = null;
error = ((Exception)rti.Result).Message;
return(EvaluationResult.UnknownError);
}
result = (TargetObject)rti.ReturnObject;
if (rti.ExceptionMessage != null)
{
error = rti.ExceptionMessage;
return(EvaluationResult.Exception);
}
else if (rti.ReturnObject == null)
{
rti.Abort();
return(EvaluationResult.UnknownError);
}
return(EvaluationResult.Ok);
} catch (TargetException ex) {
result = null;
error = ex.ToString();
return(EvaluationResult.UnknownError);
}
}
public override TargetObject GetField(Thread thread,
TargetStructObject instance,
TargetFieldInfo field)
{
if (field.HasConstValue)
return SymbolFile.MonoLanguage.CreateInstance (thread, field.ConstValue);
if (field.IsStatic) {
return GetStaticField (thread, field);
} else {
if (instance == null)
throw new InvalidOperationException ();
return (TargetObject) thread.ThreadServant.DoTargetAccess (
delegate (TargetMemoryAccess target) {
return GetInstanceField (target, instance, field);
});
}
}
