Support column-based breakpoints in the VM and Observatory.

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 81 matching lines @@
 // change when the underlying code gets compiled.
 // A latent breakpoint represents a breakpoint location in Dart source
 // that is not loaded in the VM when the breakpoint is requested.
 // When a script with matching url is loaded, a latent breakpoint
 // becomes an unresolved breakpoint.
 class BreakpointLocation {
  public:
   // Create a new unresolved breakpoint.
   BreakpointLocation(const Script& script,
                      intptr_t token_pos,
-                     intptr_t end_token_pos);
+                     intptr_t end_token_pos,
+                     intptr_t requested_line_number,
+                     intptr_t requested_column_number);
   // Create a new latent breakpoint.
   BreakpointLocation(const String& url,
-                     intptr_t line_number);
+                     intptr_t requested_line_number,
+                     intptr_t requested_column_number);
 
   ~BreakpointLocation();
 
   RawFunction* function() const { return function_; }
   intptr_t token_pos() const { return token_pos_; }
   intptr_t end_token_pos() const { return end_token_pos_; }
 
   RawScript* script() const { return script_; }
   RawString* url() const { return url_; }
+
+  intptr_t requested_line_number() const { return requested_line_number_; }
+  intptr_t requested_column_number() const { return requested_column_number_; }
+
   intptr_t LineNumber();
+  intptr_t ColumnNumber();
 
-  void GetCodeLocation(Library* lib, Script* script, intptr_t* token_pos);
+  void GetCodeLocation(Library* lib,
+                       Script* script,
+                       intptr_t* token_pos) const;
 
   Breakpoint* AddRepeated(Debugger* dbg);
   Breakpoint* AddSingleShot(Debugger* dbg);
   Breakpoint* AddPerClosure(Debugger* dbg, const Instance& closure);
 
   bool AnyEnabled() const;
   bool IsResolved() const { return is_resolved_; }
   bool IsLatent() const { return token_pos_ < 0; }
 
  private:
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   void SetResolved(const Function& func, intptr_t token_pos);
 
   BreakpointLocation* next() const { return this->next_; }
   void set_next(BreakpointLocation* value) { next_ = value; }
 
   void AddBreakpoint(Breakpoint* bpt, Debugger* dbg);
 
   Breakpoint* breakpoints() const { return this->conditions_; }
   void set_breakpoints(Breakpoint* head) { this->conditions_ = head; }
 
   RawScript* script_;
   RawString* url_;
   intptr_t token_pos_;
   intptr_t end_token_pos_;
   bool is_resolved_;
   BreakpointLocation* next_;
   Breakpoint* conditions_;
+  intptr_t requested_line_number_;
+  intptr_t requested_column_number_;
 
   // Valid for resolved breakpoints:
   RawFunction* function_;
   intptr_t line_number_;
+  intptr_t column_number_;
 
   friend class Debugger;
   DISALLOW_COPY_AND_ASSIGN(BreakpointLocation);
 };
 
 
 // CodeBreakpoint represents a location in compiled code. There may be
 // more than one CodeBreakpoint for one BreakpointLocation, e.g. when a
 // function gets compiled as a regular function and as a closure.
 class CodeBreakpoint {
@@ skipping 292 matching lines @@
 
   // Set breakpoint at closest location to function entry.
   Breakpoint* SetBreakpointAtEntry(const Function& target_function,
                                    bool single_shot);
   Breakpoint* SetBreakpointAtActivation(const Instance& closure);
   Breakpoint* BreakpointAtActivation(const Instance& closure);
 
   // TODO(turnidge): script_url may no longer be specific enough.
   Breakpoint* SetBreakpointAtLine(const String& script_url,
                                   intptr_t line_number);
+  Breakpoint* SetBreakpointAtLineCol(const String& script_url,
+                                     intptr_t line_number,
+                                     intptr_t column_number);
   RawError* OneTimeBreakAtEntry(const Function& target_function);
 
-  BreakpointLocation* BreakpointLocationAtLine(const String& script_url,
-                                               intptr_t line_number);
+  BreakpointLocation* BreakpointLocationAtLineCol(const String& script_url,
+                                                  intptr_t line_number,
+                                                  intptr_t column_number);
 
 
   void RemoveBreakpoint(intptr_t bp_id);
   Breakpoint* GetBreakpointById(intptr_t id);
 
   void SetStepOver();
   void SetSingleStep();
   void SetStepOut();
   bool IsStepping() const { return resume_action_ != kContinue; }
 
@@ skipping 91 matching lines @@
 
   void FindCompiledFunctions(const Script& script,
                              intptr_t start_pos,
                              intptr_t end_pos,
                              GrowableObjectArray* function_list);
   RawFunction* FindBestFit(const Script& script, intptr_t token_pos);
   RawFunction* FindInnermostClosure(const Function& function,
                                     intptr_t token_pos);
   intptr_t ResolveBreakpointPos(const Function& func,
                                 intptr_t requested_token_pos,
-                                intptr_t last_token_pos);
+                                intptr_t last_token_pos,
+                                intptr_t requested_column);
   void DeoptimizeWorld();
   BreakpointLocation* SetBreakpoint(const Script& script,
                                     intptr_t token_pos,
-                                    intptr_t last_token_pos);
+                                    intptr_t last_token_pos,
+                                    intptr_t requested_line,
+                                    intptr_t requested_column);
   void RemoveInternalBreakpoints();
   void UnlinkCodeBreakpoints(BreakpointLocation* bpt_location);
-  BreakpointLocation* GetLatentBreakpoint(const String& url, intptr_t line);
+  BreakpointLocation* GetLatentBreakpoint(const String& url,
+                                          intptr_t line,
+                                          intptr_t column);
   void RegisterBreakpointLocation(BreakpointLocation* bpt);
   void RegisterCodeBreakpoint(CodeBreakpoint* bpt);
   BreakpointLocation* GetBreakpointLocation(const Script& script,
-                                            intptr_t token_pos);
+                                            intptr_t token_pos,
+                                            intptr_t requested_column);
   void MakeCodeBreakpointAt(const Function& func,
                             BreakpointLocation* bpt);
   // Returns NULL if no breakpoint exists for the given address.
   CodeBreakpoint* GetCodeBreakpoint(uword breakpoint_address);
 
   void SyncBreakpointLocation(BreakpointLocation* loc);
 
   ActivationFrame* TopDartFrame() const;
   static ActivationFrame* CollectDartFrame(Isolate* isolate,
                                            uword pc,
@@ skipping 67 matching lines @@
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DEBUGGER_H_