class/Mono.Debugger.Soft/Mono.Debugger.Soft/ObjectMirror.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Runtime.Remoting.Messaging;
   4 using System.Threading;
   5
   6 namespace Mono.Debugger.Soft
   7 {
   8         public class ObjectMirror : Value {
   9
  10                 internal ObjectMirror (VirtualMachine vm, long id) : base (vm, id) {
  11                 }
  12
  13                 public TypeMirror Type {
  14                         get {
  15                                 return vm.GetType (vm.conn.Object_GetType (id));
  16                         }
  17                 }
  18
  19                 public AppDomainMirror Domain {
  20                         get {
  21                                 return vm.GetDomain (vm.conn.Object_GetDomain (id));
  22                         }
  23                 }
  24
  25                 public bool IsCollected {
  26                         get {
  27                                 return vm.conn.Object_IsCollected (id);
  28                         }
  29                 }
  30
  31                 public Value GetValue (FieldInfoMirror field) {
  32                         return GetValues (new FieldInfoMirror [] { field }) [0];
  33                 }
  34
  35                 public Value[] GetValues (IList<FieldInfoMirror> fields) {
  36                         if (fields == null)
  37                                 throw new ArgumentNullException ("fields");
  38                         foreach (FieldInfoMirror f in fields) {
  39                                 if (f == null)
  40                                         throw new ArgumentNullException ("field");
  41                                 CheckMirror (f);
  42                         }
  43                         long[] ids = new long [fields.Count];
  44                         for (int i = 0; i < fields.Count; ++i)
  45                                 ids [i] = fields [i].Id;
  46                         try {
  47                                 return vm.DecodeValues (vm.conn.Object_GetValues (id, ids));
  48                         } catch (CommandException ex) {
  49                                 if (ex.ErrorCode == ErrorCode.INVALID_FIELDID)
  50                                         throw new ArgumentException ("One of the fields is not valid for this type.", "fields");
  51                                 else
  52                                         throw;
  53                         }
  54                 }
  55
  56                 public void SetValues (IList<FieldInfoMirror> fields, Value[] values) {
  57                         if (fields == null)
  58                                 throw new ArgumentNullException ("fields");
  59                         if (values == null)
  60                                 throw new ArgumentNullException ("values");
  61                         foreach (FieldInfoMirror f in fields) {
  62                                 if (f == null)
  63                                         throw new ArgumentNullException ("field");
  64                                 CheckMirror (f);
  65                         }
  66                         foreach (Value v in values) {
  67                                 if (v == null)
  68                                         throw new ArgumentNullException ("values");
  69                                 CheckMirror (v);
  70                         }
  71                         long[] ids = new long [fields.Count];
  72                         for (int i = 0; i < fields.Count; ++i)
  73                                 ids [i] = fields [i].Id;
  74                         try {
  75                                 vm.conn.Object_SetValues (id, ids, vm.EncodeValues (values));
  76                         } catch (CommandException ex) {
  77                                 if (ex.ErrorCode == ErrorCode.INVALID_FIELDID)
  78                                         throw new ArgumentException ("One of the fields is not valid for this type.", "fields");
  79                                 else if (ex.ErrorCode == ErrorCode.INVALID_ARGUMENT)
  80                                         throw new ArgumentException ("One of the values is not valid for its field.", "values");
  81                                 else
  82                                         throw;
  83                         }
  84                 }
  85
  86                 public void SetValue (FieldInfoMirror field, Value value) {
  87                         SetValues (new FieldInfoMirror [] { field }, new Value [] { value });
  88                 }
  89
  90                 /*
  91                  * The current address of the object. It can change during garbage
  92                  * collections. Use a long since the debuggee might have a different
  93                  * pointer size.
  94                  */
  95                 public long Address {
  96                         get {
  97                                 return vm.conn.Object_GetAddress (id);
  98                         }
  99                 }
 100
 101                 public Value InvokeMethod (ThreadMirror thread, MethodMirror method, IList<Value> arguments) {
 102                         return InvokeMethod (vm, thread, method, this, arguments, InvokeOptions.None);
 103                 }
 104
 105                 public Value InvokeMethod (ThreadMirror thread, MethodMirror method, IList<Value> arguments, InvokeOptions options) {
 106                         return InvokeMethod (vm, thread, method, this, arguments, options);
 107                 }
 108
 109                 [Obsolete ("Use the overload without the 'vm' argument")]
 110                 public IAsyncResult BeginInvokeMethod (VirtualMachine vm, ThreadMirror thread, MethodMirror method, IList<Value> arguments, InvokeOptions options, AsyncCallback callback, object state) {
 111                         return BeginInvokeMethod (vm, thread, method, this, arguments, options, callback, state);
 112                 }
 113
 114                 public IAsyncResult BeginInvokeMethod (ThreadMirror thread, MethodMirror method, IList<Value> arguments, InvokeOptions options, AsyncCallback callback, object state) {
 115                         return BeginInvokeMethod (vm, thread, method, this, arguments, options, callback, state);
 116                 }
 117
 118                 public Value EndInvokeMethod (IAsyncResult asyncResult) {
 119                         return EndInvokeMethodInternal (asyncResult);
 120                 }
 121
 122                 /*
 123                  * Common implementation for invokes
 124                  */
 125
 126                 class InvokeAsyncResult : IInvokeAsyncResult {
 127
 128                         public object AsyncState {
 129                                 get; set;
 130                         }
 131
 132                         public WaitHandle AsyncWaitHandle {
 133                                 get; set;
 134                         }
 135
 136                         public bool CompletedSynchronously {
 137                                 get {
 138                                         return false;
 139                                 }
 140                         }
 141
 142                         public bool IsCompleted {
 143                                 get; set;
 144                         }
 145
 146                         public AsyncCallback Callback {
 147                                 get; set;
 148                         }
 149
 150                         public ErrorCode ErrorCode {
 151                                 get; set;
 152                         }
 153
 154                         public VirtualMachine VM {
 155                                 get; set;
 156                         }
 157
 158                         public ThreadMirror Thread {
 159                                 get; set;
 160                         }
 161
 162                         public ValueImpl Value {
 163                                 get; set;
 164                         }
 165
 166                         public ValueImpl Exception {
 167                                 get; set;
 168                         }
 169
 170                         public int ID {
 171                                 get; set;
 172                         }
 173
 174                         public void Abort ()
 175                         {
 176                                 if (ID == 0) // Ooops
 177                                         return;
 178
 179                                 ObjectMirror.AbortInvoke (VM, Thread, ID);
 180                         }
 181                 }
 182
 183                 internal static IInvokeAsyncResult BeginInvokeMethod (VirtualMachine vm, ThreadMirror thread, MethodMirror method, Value this_obj, IList<Value> arguments, InvokeOptions options, AsyncCallback callback, object state) {
 184                         if (thread == null)
 185                                 throw new ArgumentNullException ("thread");
 186                         if (method == null)
 187                                 throw new ArgumentNullException ("method");
 188                         if (arguments == null)
 189                                 arguments = new Value [0];
 190
 191                         InvokeFlags f = InvokeFlags.NONE;
 192
 193                         if ((options & InvokeOptions.DisableBreakpoints) != 0)
 194                                 f |= InvokeFlags.DISABLE_BREAKPOINTS;
 195                         if ((options & InvokeOptions.SingleThreaded) != 0)
 196                                 f |= InvokeFlags.SINGLE_THREADED;
 197
 198                         InvokeAsyncResult r = new InvokeAsyncResult { AsyncState = state, AsyncWaitHandle = new ManualResetEvent (false), VM = vm, Thread = thread, Callback = callback };
 199
 200                         r.ID = vm.conn.VM_BeginInvokeMethod (thread.Id, method.Id, this_obj != null ? vm.EncodeValue (this_obj) : vm.EncodeValue (vm.CreateValue (null)), vm.EncodeValues (arguments), f, InvokeCB, r);
 201
 202                         return r;
 203                 }
 204
 205                 // This is called when the result of an invoke is received
 206                 static void InvokeCB (ValueImpl v, ValueImpl exc, ErrorCode error, object state) {
 207                         InvokeAsyncResult r = (InvokeAsyncResult)state;
 208
 209                         if (error != 0) {
 210                                 r.ErrorCode = error;
 211                         } else {
 212                                 r.Value = v;
 213                                 r.Exception = exc;
 214                         }
 215
 216                         r.IsCompleted = true;
 217                         ((ManualResetEvent)r.AsyncWaitHandle).Set ();
 218
 219                         if (r.Callback != null)
 220                                 r.Callback.BeginInvoke (r, null, null);
 221                 }
 222
 223             internal static Value EndInvokeMethodInternal (IAsyncResult asyncResult) {
 224                         if (asyncResult == null)
 225                                 throw new ArgumentNullException ("asyncResult");
 226
 227                         InvokeAsyncResult r = (InvokeAsyncResult)asyncResult;
 228
 229                         if (!r.IsCompleted)
 230                                 r.AsyncWaitHandle.WaitOne ();
 231
 232                         if (r.ErrorCode != 0) {
 233                                 try {
 234                                         r.VM.ErrorHandler (null, new ErrorHandlerEventArgs () { ErrorCode = r.ErrorCode });
 235                                 } catch (CommandException ex) {
 236                                         if (ex.ErrorCode == ErrorCode.INVALID_ARGUMENT)
 237                                                 throw new ArgumentException ("Incorrect number or types of arguments", "arguments");
 238                                         else
 239                                                 throw;
 240                                 }
 241                                 throw new NotImplementedException ();
 242                         } else {
 243                                 if (r.Exception != null)
 244                                         throw new InvocationException ((ObjectMirror)r.VM.DecodeValue (r.Exception));
 245                                 else
 246                                         return r.VM.DecodeValue (r.Value);
 247                         }
 248                 }
 249
 250                 internal static Value InvokeMethod (VirtualMachine vm, ThreadMirror thread, MethodMirror method, Value this_obj, IList<Value> arguments, InvokeOptions options) {
 251                         return EndInvokeMethodInternal (BeginInvokeMethod (vm, thread, method, this_obj, arguments, options, null, null));
 252                 }
 253
 254                 internal static void AbortInvoke (VirtualMachine vm, ThreadMirror thread, int id)
 255                 {
 256                         vm.conn.VM_AbortInvoke (thread.Id, id);
 257                 }
 258         }
 259 }