Add debugger functions to inspect objects and classes

runtime/vm/debugger.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/debugger.h"
 
 #include "vm/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
+#include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/visitor.h"
 
 
@@ skipping 380 matching lines @@
   }
   const Function& func =
       Function::Handle(lib.LookupFunctionInScript(script, token_index_at_line));
   if (func.IsNull()) {
     return NULL;
   }
   return SetBreakpoint(func, token_index_at_line);
 }
 
 
+static RawArray* MakeNameValueList(const GrowableArray<Object*>& pairs) {
+  int pairs_len = pairs.length();
+  ASSERT(pairs_len % 2 == 0);
+  const Array& list = Array::Handle(Array::New(pairs_len));
+  for (int i = 0; i < pairs_len; i++) {
+    list.SetAt(i, *pairs[i]);
+  }
+  return list.raw();
+}
+
+
+RawInstance* Debugger::GetInstanceField(const Class& cls,
+                                        const String& field_name,
+                                        const Instance& object) {
+  const Function& getter_func =
+      Function::Handle(cls.LookupGetterFunction(field_name));
+  ASSERT(!getter_func.IsNull());
+  GrowableArray<const Object*> noArguments;
+  const Array& noArgumentNames = Array::Handle();
+  return DartEntry::InvokeDynamic(object, getter_func,
+                                  noArguments, noArgumentNames);

[siva, 2012/01/26 21:34:08]

Until Todd implements his change of capturing all errors and propagating them
without the need for setjmp/longjmp wouldn't we need a setjmp/longjmp around
this (in case the getter method was never executed and hence never compiled)

[hausner, 2012/01/27 17:19:30]

Good point. The compilation part is taken care of in DartEntry, but there could
be compile or runtime errors to catch.

I initially thought of using the Dart_InvokeXXX functions but didn't want to
deal with the Dart_Handle stuff.

Fixed by allowing the result array of field names and values to contain Error
objects. This way, the debugger can display the error object instead of the
value for that particular field.

+}
+
+
+RawInstance* Debugger::GetStaticField(const Class& cls,
+                                      const String& field_name) {
+  const Function& getter_func =
+      Function::Handle(cls.LookupGetterFunction(field_name));
+  ASSERT(!getter_func.IsNull());
+  GrowableArray<const Object*> noArguments;
+  const Array& noArgumentNames = Array::Handle();
+  return DartEntry::InvokeStatic(getter_func, noArguments, noArgumentNames);

[siva, 2012/01/26 21:34:08]

Ditto comment about setjmp/longjmp.

[hausner, 2012/01/27 17:19:30]

Done.

+}
+
+
+RawArray* Debugger::GetInstanceFields(const Instance& obj) {
+  Class& cls = Class::Handle(obj.clazz());
+  Array& fields = Array::Handle();
+  Field& field = Field::Handle();
+  GrowableArray<Object*> field_list(8);
+  // Iterate over fields in class hierarchy to count all instance fields.
+  int num_fields = 0;
+  while (!cls.IsNull()) {
+    fields = cls.fields();
+    for (int i = 0; i < fields.Length(); i++) {
+      field ^= fields.At(i);
+      if (!field.is_static()) {
+        String& field_name = String::Handle(field.name());
+        field_list.Add(&field_name);
+        Instance& field_value = Instance::Handle();
+        field_value = GetInstanceField(cls, field_name, obj);
+        field_list.Add(&field_value);
+      }
+    }
+    cls = cls.SuperClass();
+  }
+  return MakeNameValueList(field_list);
+}
+
+
+RawArray* Debugger::GetStaticFields(const Class& cls) {
+  GrowableArray<Object*> field_list(8);
+  Array& fields = Array::Handle(cls.fields());
+  Field& field = Field::Handle();
+  for (int i = 0; i < fields.Length(); i++) {
+    field ^= fields.At(i);
+    if (field.is_static()) {
+      String& field_name = String::Handle(field.name());
+      Instance& field_value = Instance::Handle(GetStaticField(cls, field_name));
+      field_list.Add(&field_name);
+      field_list.Add(&field_value);
+    }
+  }
+  return MakeNameValueList(field_list);
+}
+
+
 void Debugger::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   ASSERT(visitor != NULL);
   Breakpoint* bpt = this->breakpoints_;
   while (bpt != NULL) {
     bpt->VisitObjectPointers(visitor);
     bpt = bpt->next();
   }
 }
 
 
@@ skipping 110 matching lines @@
 
 
 void Debugger::RegisterBreakpoint(Breakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(this->breakpoints_);
   this->breakpoints_ = bpt;
 }
 
 
 }  // namespace dart