Replace intptr_t with TokenDescriptor

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 80 matching lines @@
 // the definitive source location yet. The requested source location may
 // 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,
+                     TokenDescriptor token_pos,
+                     TokenDescriptor end_token_pos,
                      intptr_t requested_line_number,
                      intptr_t requested_column_number);
   // Create a new latent breakpoint.
   BreakpointLocation(const String& url,
                      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_; }
+  TokenDescriptor token_pos() const { return token_pos_; }
+  TokenDescriptor 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) const;
+                       TokenDescriptor* 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; }
+  bool IsLatent() const { return !token_pos_.IsReal(); }
 
  private:
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
-  void SetResolved(const Function& func, intptr_t token_pos);
+  void SetResolved(const Function& func, TokenDescriptor 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_;
+  TokenDescriptor token_pos_;
+  TokenDescriptor 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 {
  public:
   CodeBreakpoint(const Code& code,
-                 intptr_t token_pos,
+                 TokenDescriptor token_pos,
                  uword pc,
                  RawPcDescriptors::Kind kind);
   ~CodeBreakpoint();
 
   RawFunction* function() const;
   uword pc() const { return pc_; }
-  intptr_t token_pos() const { return token_pos_; }
+  TokenDescriptor token_pos() const { return token_pos_; }
   bool IsInternal() const { return bpt_location_ == NULL; }
 
   RawScript* SourceCode();
   RawString* SourceUrl();
   intptr_t LineNumber();
 
   void Enable();
   void Disable();
   bool IsEnabled() const { return is_enabled_; }
 
   RawCode* OrigStubAddress() const;
 
  private:
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   BreakpointLocation* bpt_location() const { return bpt_location_; }
   void set_bpt_location(BreakpointLocation* value) { bpt_location_ = value; }
 
   void set_next(CodeBreakpoint* value) { next_ = value; }
   CodeBreakpoint* next() const { return this->next_; }
 
   void PatchCode();
   void RestoreCode();
 
   RawCode* code_;
-  intptr_t token_pos_;
+  TokenDescriptor token_pos_;
   uword pc_;
   intptr_t line_number_;
   bool is_enabled_;
 
   BreakpointLocation* bpt_location_;
   CodeBreakpoint* next_;
 
   RawPcDescriptors::Kind breakpoint_kind_;
   RawCode* saved_value_;
 
@@ skipping 18 matching lines @@
   }
   const Code& code() const {
     ASSERT(!code_.IsNull());
     return code_;
   }
 
   RawString* QualifiedFunctionName();
   RawString* SourceUrl();
   RawScript* SourceScript();
   RawLibrary* Library();
-  intptr_t TokenPos();
+  TokenDescriptor TokenPos();
   intptr_t LineNumber();
   intptr_t ColumnNumber();
 
   // Returns true if this frame is for a function that is visible
   // to the user and can be debugged.
   bool IsDebuggable() const;
 
   // The context level of a frame is the context level at the
   // PC/token index of the frame. It determines the depth of the context
   // chain that belongs to the function of this activation frame.
   intptr_t ContextLevel();
 
   const char* ToCString();
 
   intptr_t NumLocalVariables();
 
   void VariableAt(intptr_t i,
                   String* name,
-                  intptr_t* token_pos,
-                  intptr_t* end_pos,
+                  TokenDescriptor* token_pos,
+                  TokenDescriptor* end_pos,
                   Object* value);
 
   RawArray* GetLocalVariables();
   RawObject* GetParameter(intptr_t index);
   RawObject* GetClosure();
   RawObject* GetReceiver();
 
   const Context& GetSavedCurrentContext();
   RawObject* GetAsyncOperation();
 
@@ skipping 19 matching lines @@
 
   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_;
-  intptr_t token_pos_;
+  TokenDescriptor token_pos_;
   intptr_t try_index_;
 
   intptr_t line_number_;
   intptr_t column_number_;
   intptr_t context_level_;
 
   // Some frames are deoptimized into a side array in order to inspect them.
   const Array& deopt_frame_;
   const intptr_t deopt_frame_offset_;
 
@@ skipping 263 matching lines @@
     kStepOver,
     kStepOut,
     kSingleStep
   };
 
   static bool HasAnyEventHandler();
   static bool HasDebugEventHandler();
   void InvokeEventHandler(DebuggerEvent* event);
 
   void FindCompiledFunctions(const Script& script,
-                             intptr_t start_pos,
-                             intptr_t end_pos,
+                             TokenDescriptor start_pos,
+                             TokenDescriptor end_pos,
                              GrowableObjectArray* function_list);
-  RawFunction* FindBestFit(const Script& script, intptr_t token_pos);
+  RawFunction* FindBestFit(const Script& script, TokenDescriptor 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 requested_column);
+                                    TokenDescriptor token_pos);
+  TokenDescriptor ResolveBreakpointPos(const Function& func,
+                                       TokenDescriptor requested_token_pos,
+                                       TokenDescriptor last_token_pos,
+                                       intptr_t requested_column);
   void DeoptimizeWorld();
   BreakpointLocation* SetBreakpoint(const Script& script,
-                                    intptr_t token_pos,
-                                    intptr_t last_token_pos,
+                                    TokenDescriptor token_pos,
+                                    TokenDescriptor 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,
                                           intptr_t column);
   void RegisterBreakpointLocation(BreakpointLocation* bpt);
   void RegisterCodeBreakpoint(CodeBreakpoint* bpt);
   BreakpointLocation* GetBreakpointLocation(const Script& script,
-                                            intptr_t token_pos,
+                                            TokenDescriptor 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,
@@ skipping 75 matching lines @@
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DEBUGGER_H_