Async-step, first cut.

runtime/vm/debugger.h

 // Copyright (c) 2012, 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 "include/dart_tools_api.h"
 
 #include "vm/object.h"
@@ skipping 243 matching lines @@
                   intptr_t* token_pos,
                   intptr_t* end_pos,
                   Object* value);
 
   RawArray* GetLocalVariables();
   RawObject* GetParameter(intptr_t index);
   RawObject* GetClosure();
   RawObject* GetReceiver();
 
   const Context& GetSavedCurrentContext();
+  RawObject* GetAsyncOperation();
 
   RawObject* Evaluate(const String& expr);
 
   // Print the activation frame into |jsobj|. if |full| is false, script
   // and local variable objects are only references. if |full| is true,
   // the complete script, function, and, local variable objects are included.
   void PrintToJSONObject(JSONObject* jsobj, bool full = false);
 
  private:
-  void PrintContextMismatchError(const String& var_name,
-                                 intptr_t ctx_slot,
+  void PrintContextMismatchError(intptr_t ctx_slot,
                                  intptr_t frame_ctx_level,
                                  intptr_t var_ctx_level);
 
   intptr_t TryIndex();
   void GetPcDescriptors();
   void GetVarDescriptors();
   void GetDescIndices();
 
-  RawObject* GetLocalVar(intptr_t slot_index);
-  RawInstance* GetLocalInstanceVar(intptr_t slot_index);
+  RawObject* GetStackVar(intptr_t slot_index);
+  RawObject* GetContextVar(intptr_t ctxt_level, intptr_t slot_index);
 
   uword pc_;
   uword fp_;
   uword sp_;
 
   // The anchor of the context chain for this function.
   Context& ctx_;
   const Code& code_;
   const Function& function_;
   bool token_pos_initialized_;
@@ skipping 51 matching lines @@
     kIsolateCreated = 4,
     kIsolateShutdown = 5,
     kIsolateInterrupted = 6,
   };
 
   explicit DebuggerEvent(Isolate* isolate, EventType event_type)
       : isolate_(isolate),
         type_(event_type),
         top_frame_(NULL),
         breakpoint_(NULL),
-        exception_(NULL) {}
+        exception_(NULL),
+        async_continuation_(NULL) {}
 
   Isolate* isolate() const { return isolate_; }
 
   EventType type() const { return type_; }
 
   bool IsPauseEvent() const {
     return (type_ == kBreakpointReached ||
             type_ == kIsolateInterrupted ||
             type_ == kExceptionThrown);
   }
@@ skipping 18 matching lines @@
 
   const Object* exception() const {
     ASSERT(type_ == kExceptionThrown);
     return exception_;
   }
   void set_exception(const Object* exception) {
     ASSERT(type_ == kExceptionThrown);
     exception_ = exception;
   }
 
+  const Object* async_continuation() const {
+    ASSERT(type_ == kBreakpointReached);
+    return async_continuation_;
+  }
+  void set_async_continuation(const Object* closure) {
+    ASSERT(type_ == kBreakpointReached);
+    async_continuation_ = closure;
+  }
+
   Dart_Port isolate_id() const {
     return isolate_->main_port();
   }
 
  private:
   Isolate* isolate_;
   EventType type_;
   ActivationFrame* top_frame_;
   Breakpoint* breakpoint_;
   const Object* exception_;
+  const Object* async_continuation_;
 };
 
 
 class Debugger {
  public:
   typedef void EventHandler(DebuggerEvent* event);
 
   Debugger();
   ~Debugger();
 
@@ skipping 218 matching lines @@
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DEBUGGER_H_