Make the parser agnostic to the TokenStream implementation. This is the first step towards compacti…

vm/debugger.cc

 // 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.
 
 #include "vm/debugger.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 23 matching lines @@
 
  private:
   GrowableObjectArray* objs_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteObjectCache);
 };
 
 
 SourceBreakpoint::SourceBreakpoint(intptr_t id,
                                    const Function& func,
-                                   intptr_t token_index)
+                                   intptr_t token_pos)
     : id_(id),
       function_(func.raw()),
-      token_index_(token_index),
+      token_pos_(token_pos),
       line_number_(-1),
       is_enabled_(false),
       next_(NULL) {
   ASSERT(!func.IsNull());
-  ASSERT((func.token_index() <= token_index_) &&
-         (token_index_ < func.end_token_index()));
+  ASSERT((func.token_pos() <= token_pos_) &&
+         (token_pos_ < func.end_token_pos()));
 }
 
 
 void SourceBreakpoint::Enable() {
   is_enabled_ = true;
   Isolate::Current()->debugger()->SyncBreakpoint(this);
 }
 
 
 void SourceBreakpoint::Disable() {
@@ skipping 13 matching lines @@
   const Script& script = Script::Handle(SourceCode());
   return script.url();
 }
 
 
 intptr_t SourceBreakpoint::LineNumber() {
   // Compute line number lazily since it causes scanning of the script.
   if (line_number_ < 0) {
     const Script& script = Script::Handle(SourceCode());
     intptr_t ignore_column;
-    script.GetTokenLocation(token_index_, &line_number_, &ignore_column);
+    script.GetTokenLocation(token_pos_, &line_number_, &ignore_column);
   }
   return line_number_;
 }
 
 
 void SourceBreakpoint::set_function(const Function& func) {
   function_ = func.raw();
 }
 
 
 void SourceBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 }
 
 
 
 void CodeBreakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&function_));
 }
 
 
 ActivationFrame::ActivationFrame(uword pc, uword fp, uword sp,
                                  const Context& ctx)
     : pc_(pc), fp_(fp), sp_(sp),
       ctx_(Context::ZoneHandle(ctx.raw())),
       function_(Function::ZoneHandle()),
-      token_index_(-1),
+      token_pos_(-1),
       pc_desc_index_(-1),
       line_number_(-1),
       context_level_(-1),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {
 }
 
 
@@ skipping 53 matching lines @@
     const Function& func = DartFunction();
     ASSERT(!func.HasOptimizedCode());
     Code& code = Code::Handle(func.unoptimized_code());
     ASSERT(!code.IsNull());
     pc_desc_ = code.pc_descriptors();
     ASSERT(!pc_desc_.IsNull());
   }
 }
 
 
-// Compute token_index_ and pc_desc_index_.
+// Compute token_pos_ and pc_desc_index_.
 intptr_t ActivationFrame::TokenIndex() {
-  if (token_index_ < 0) {
+  if (token_pos_ < 0) {
     GetPcDescriptors();
     for (int i = 0; i < pc_desc_.Length(); i++) {
       if (pc_desc_.PC(i) == pc_) {
         pc_desc_index_ = i;
-        token_index_ = pc_desc_.TokenIndex(i);
+        token_pos_ = pc_desc_.TokenIndex(i);
         break;
       }
     }
-    ASSERT(token_index_ >= 0);
+    ASSERT(token_pos_ >= 0);
   }
-  return token_index_;
+  return token_pos_;
 }
 
 
 intptr_t ActivationFrame::PcDescIndex() {
   if (pc_desc_index_ < 0) {
     TokenIndex();
     ASSERT(pc_desc_index_ >= 0);
   }
   return pc_desc_index_;
 }
@@ skipping 236 matching lines @@
       pc_(0),
       line_number_(-1),
       is_enabled_(false),
       src_bpt_(NULL),
       next_(NULL) {
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());  // Function must be compiled.
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   ASSERT(pc_desc_index < desc.Length());
-  token_index_ = desc.TokenIndex(pc_desc_index);
-  ASSERT(token_index_ >= 0);
+  token_pos_ = desc.TokenIndex(pc_desc_index);
+  ASSERT(token_pos_ >= 0);
   pc_ = desc.PC(pc_desc_index);
   ASSERT(pc_ != 0);
   breakpoint_kind_ = desc.DescriptorKind(pc_desc_index);
   ASSERT((breakpoint_kind_ == PcDescriptors::kIcCall) ||
          (breakpoint_kind_ == PcDescriptors::kFuncCall) ||
          (breakpoint_kind_ == PcDescriptors::kReturn));
 }
 
 
 CodeBreakpoint::~CodeBreakpoint() {
@@ skipping 21 matching lines @@
   const Script& script = Script::Handle(SourceCode());
   return script.url();
 }
 
 
 intptr_t CodeBreakpoint::LineNumber() {
   // Compute line number lazily since it causes scanning of the script.
   if (line_number_ < 0) {
     const Script& script = Script::Handle(SourceCode());
     intptr_t ignore_column;
-    script.GetTokenLocation(token_index_, &line_number_, &ignore_column);
+    script.GetTokenLocation(token_pos_, &line_number_, &ignore_column);
   }
   return line_number_;
 }
 
 
 void CodeBreakpoint::PatchCode() {
   ASSERT(!is_enabled_);
   switch (breakpoint_kind_) {
     case PcDescriptors::kIcCall: {
       int num_args, num_named_args;
@@ skipping 295 matching lines @@
   event.type = kExceptionThrown;
   event.exception = &exc;
   ASSERT(event_handler_ != NULL);
   (*event_handler_)(&event);
   stack_trace_ = NULL;
   obj_cache_ = NULL;  // Remote object cache is zone allocated.
 }
 
 
 CodeBreakpoint* Debugger::MakeCodeBreakpoint(const Function& func,
-                                             intptr_t token_index) {
+                                             intptr_t token_pos) {
   ASSERT(func.HasCode());
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   intptr_t best_fit_index = -1;
   intptr_t best_fit = INT_MAX;
   for (int i = 0; i < desc.Length(); i++) {
-    intptr_t desc_token_index = desc.TokenIndex(i);
-    if (desc_token_index < token_index) {
+    intptr_t desc_token_pos = desc.TokenIndex(i);
+    if (desc_token_pos < token_pos) {
       continue;
     }
     PcDescriptors::Kind kind = desc.DescriptorKind(i);
     if ((kind == PcDescriptors::kIcCall) ||
         (kind == PcDescriptors::kFuncCall) ||
         (kind == PcDescriptors::kReturn)) {
-      if ((desc_token_index - token_index) < best_fit) {
-        best_fit = desc_token_index - token_index;
+      if ((desc_token_pos - token_pos) < best_fit) {
+        best_fit = desc_token_pos - token_pos;
         ASSERT(best_fit >= 0);
         best_fit_index = i;
       }
     }
   }
   if (best_fit_index >= 0) {
     CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(best_fit_index));
     // We should only ever have one code breakpoint at the same address.
     // If we find an existing breakpoint, it must be an internal one which
     // is used for stepping.
@@ skipping 11 matching lines @@
                 bpt->pc());
     }
     RegisterCodeBreakpoint(bpt);
     return bpt;
   }
   return NULL;
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpoint(const Function& target_function,
-                                          intptr_t token_index) {
-  if ((token_index < target_function.token_index()) ||
-      (target_function.end_token_index() <= token_index)) {
+                                          intptr_t token_pos) {
+  if ((token_pos < target_function.token_pos()) ||
+      (target_function.end_token_pos() <= token_pos)) {
     // The given token position is not within the target function.
     return NULL;
   }
   EnsureFunctionIsDeoptimized(target_function);
-  SourceBreakpoint* bpt = GetSourceBreakpoint(target_function, token_index);
+  SourceBreakpoint* bpt = GetSourceBreakpoint(target_function, token_pos);
   if (bpt != NULL) {
     // A breakpoint for this location already exists, return it.
     return bpt;
   }
-  bpt = new SourceBreakpoint(nextId(), target_function, token_index);
+  bpt = new SourceBreakpoint(nextId(), target_function, token_pos);
   RegisterSourceBreakpoint(bpt);
   if (verbose && !target_function.HasCode()) {
     OS::Print("Registering breakpoint for uncompiled function '%s'"
               " (%s:%d)\n",
               String::Handle(target_function.name()).ToCString(),
               String::Handle(bpt->SourceUrl()).ToCString(),
               bpt->LineNumber());
   }
 
   if (target_function.HasCode()) {
-    CodeBreakpoint* cbpt = MakeCodeBreakpoint(target_function, token_index);
+    CodeBreakpoint* cbpt = MakeCodeBreakpoint(target_function, token_pos);
     if (cbpt != NULL) {
       ASSERT(cbpt->src_bpt() == NULL);
       cbpt->set_src_bpt(bpt);
       SignalBpResolved(bpt);
     } else {
       if (verbose) {
         OS::Print("Failed to set breakpoint at '%s' line %d\n",
                   String::Handle(bpt->SourceUrl()).ToCString(),
                   bpt->LineNumber());
       }
@@ skipping 17 matching lines @@
       }
     }
     cbpt = cbpt->next();
   }
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpointAtEntry(
       const Function& target_function) {
   ASSERT(!target_function.IsNull());
-  return SetBreakpoint(target_function, target_function.token_index());
+  return SetBreakpoint(target_function, target_function.token_pos());
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpointAtLine(const String& script_url,
                                           intptr_t line_number) {
   Library& lib = Library::Handle();
   Script& script = Script::Handle();
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate_->object_store()->libraries());
   for (int i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     script = lib.LookupScript(script_url);
     if (!script.IsNull()) {
       break;
     }
   }
   if (script.IsNull()) {
     if (verbose) {
       OS::Print("Failed to find script with url '%s'\n",
                 script_url.ToCString());
     }
     return NULL;
   }
-  intptr_t token_index_at_line = script.TokenIndexAtLine(line_number);
-  if (token_index_at_line < 0) {
+  intptr_t token_pos_at_line = script.TokenIndexAtLine(line_number);
+  if (token_pos_at_line < 0) {
     // Script does not contain the given line number.
     if (verbose) {
       OS::Print("Script '%s' does not contain line number %d\n",
                 script_url.ToCString(), line_number);
     }
     return NULL;
   }
   const Function& func =
-      Function::Handle(lib.LookupFunctionInScript(script, token_index_at_line));
+      Function::Handle(lib.LookupFunctionInScript(script, token_pos_at_line));
   if (func.IsNull()) {
     if (verbose) {
       OS::Print("No executable code at line %d in '%s'\n",
                 line_number, script_url.ToCString());
     }
     return NULL;
   }
-  return SetBreakpoint(func, token_index_at_line);
+  return SetBreakpoint(func, token_pos_at_line);
 }
 
 
 intptr_t Debugger::CacheObject(const Object& obj) {
   ASSERT(obj_cache_ != NULL);
   return obj_cache_->AddObject(obj);
 }
 
 
 bool Debugger::IsValidObjectId(intptr_t obj_id) {
@@ skipping 346 matching lines @@
     lookup_function = func.parent_function();
     ASSERT(!lookup_function.IsNull());
   }
   SourceBreakpoint* bpt = src_breakpoints_;
   while (bpt != NULL) {
     if (lookup_function.raw() == bpt->function()) {
       // Check if the breakpoint is inside a closure or local function
       // within the newly compiled function.
       Class& owner = Class::Handle(lookup_function.owner());
       Function& closure =
-          Function::Handle(owner.LookupClosureFunction(bpt->token_index()));
+          Function::Handle(owner.LookupClosureFunction(bpt->token_pos()));
       if (!closure.IsNull() && (closure.raw() != lookup_function.raw())) {
         if (verbose) {
           OS::Print("Resetting pending breakpoint to function %s\n",
                     String::Handle(closure.name()).ToCString());
         }
         bpt->set_function(closure);
       } else {
         if (verbose) {
           OS::Print("Enable pending breakpoint for function '%s'\n",
                     String::Handle(lookup_function.name()).ToCString());
         }
         // Set breakpoint in newly compiled code of function func.
-        CodeBreakpoint* cbpt = MakeCodeBreakpoint(func, bpt->token_index());
+        CodeBreakpoint* cbpt = MakeCodeBreakpoint(func, bpt->token_pos());
         if (cbpt != NULL) {
           cbpt->set_src_bpt(bpt);
           SignalBpResolved(bpt);
         }
       }
       bpt->Enable();  // Enables the code breakpoint as well.
     }
     bpt = bpt->next();
   }
 }
@@ skipping 72 matching lines @@
       delete temp_bpt;
     } else {
       prev_bpt = curr_bpt;
       curr_bpt = curr_bpt->next();
     }
   }
 }
 
 
 SourceBreakpoint* Debugger::GetSourceBreakpoint(const Function& func,
-                                                intptr_t token_index) {
+                                                intptr_t token_pos) {
   SourceBreakpoint* bpt = src_breakpoints_;
   while (bpt != NULL) {
     if ((bpt->function() == func.raw()) &&
-        (bpt->token_index() == token_index)) {
+        (bpt->token_pos() == token_pos)) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
 
 SourceBreakpoint* Debugger::GetBreakpointById(intptr_t id) {
   SourceBreakpoint* bpt = src_breakpoints_;
@@ skipping 14 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart