First part of inspecting local variables

runtime/vm/debugger.h

 // 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.
 
 #ifndef VM_DEBUGGER_H_
 #define VM_DEBUGGER_H_
 
 #include "vm/object.h"
 
 namespace dart {
 
 class Breakpoint;
 class Isolate;
 class ObjectPointerVisitor;
+class ActiveVariables;
 
 
 // Breakpoint represents a location in Dart source and the corresponding
 // address in compiled code.
 class Breakpoint {
  public:
   Breakpoint(const Function& func, intptr_t pc_desc_index);
 
   RawFunction* function() const { return function_; }
   uword pc() const { return pc_; }
@@ skipping 29 matching lines @@
   uword pc() const { return pc_; }
 
   RawFunction* DartFunction();
   RawString* QualifiedFunctionName();
   RawString* SourceUrl();
   RawScript* SourceScript();
   intptr_t TokenIndex();
   intptr_t LineNumber();
   const char* ToCString();
 
-  // Returns an array of String values containing variable names
-  // in this activation frame.
-  RawArray* Variables();
+  ActiveVariables* LocalVariables();
 
   // Returns the value of the given variable in the context of the
   // activation frame.
   RawInstance* Value(const String& variable_name);
 
  private:
   uword pc_;
   RawFunction* function_;

[siva, 2011/12/20 19:11:26]

How is this object pointer traversed during GC?

[hausner, 2011/12/20 21:43:55]

Good point. Changed it into a handle.

   intptr_t token_index_;
   intptr_t line_number_;
+  ActiveVariables* locals_;
 
   DISALLOW_COPY_AND_ASSIGN(ActivationFrame);
 };
 
 
 // Array of function activations on the call stack.
 class StackTrace : public ZoneAllocated {
  public:
   explicit StackTrace(int capacity) : trace_(capacity) { }
 
   intptr_t Length() const { return trace_.length(); }
 
   ActivationFrame* ActivationFrameAt(int i) const {
     ASSERT(i < trace_.length());
     return trace_[i];
   }
  private:
   void AddActivation(ActivationFrame* frame);
   ZoneGrowableArray<ActivationFrame*> trace_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(StackTrace);
 };
 
 
+class ActiveVariables : public ZoneAllocated {
+ public:
+  ActiveVariables(const Function& function, intptr_t token_pos);
+
+  intptr_t Length() const { return desc_indices_.length(); }
+
+  void VariableAt(intptr_t i,
+                  String* name,
+                  intptr_t* token_pos,
+                  intptr_t* end_pos,
+                  Instance* value) const;
+ private:
+  LocalVarDescriptors* descriptors_;
+  ZoneGrowableArray<intptr_t> desc_indices_;
+  DISALLOW_COPY_AND_ASSIGN(ActiveVariables);
+};
+
+
 typedef void BreakpointHandler(Breakpoint* bpt, StackTrace* stack);
 
 
 class Debugger {
  public:
   Debugger();
 
   void Initialize(Isolate* isolate);
   bool IsActive();
 
@@ skipping 23 matching lines @@
   bool initialized_;
   BreakpointHandler* bp_handler_;
   Breakpoint* breakpoints_;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DEBUGGER_H_