Set breakpoint at url, line number

runtime/vm/object.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/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 1567 matching lines @@
     if (function_name.Equals(name) || MatchesPrivateName(function_name, name)) {
       return function.raw();
     }
   }
 
   // No function found.
   return Function::null();
 }
 
 
+RawFunction* Class::LookupFunctionAtToken(intptr_t token_index) const {
+  // TODO(hausner): we can shortcut the negative case if we knew the
+  // beginning and end token position of the class.
+  Array& funcs = Array::Handle(functions());
+  Function& func = Function::Handle();
+  intptr_t len = funcs.Length();
+  for (intptr_t i = 0; i < len; i++) {
+    func ^= funcs.At(i);
+    if ((func.token_index() <= token_index) &&
+        (token_index < func.end_token_index())) {
+      return func.raw();
+    }
+  }
+
+  // No function found.
+  return Function::null();
+}
+
+
 RawField* Class::LookupInstanceField(const String& name) const {
   ASSERT(is_finalized());
   const Field& field = Field::Handle(LookupField(name));
   if (!field.IsNull()) {
     if (field.is_static()) {
       // Name matches but it is not of the correct kind, return NULL.
       return Field::null();
     }
     return field.raw();
   }
@@ skipping 1636 matching lines @@
                            bool is_const,
                            intptr_t token_index) {
   const Function& result = Function::Handle(Function::New());
   result.set_parameter_types(Array::Handle(Array::Empty()));
   result.set_parameter_names(Array::Handle(Array::Empty()));
   result.set_name(name);
   result.set_kind(kind);
   result.set_is_static(is_static);
   result.set_is_const(is_const);
   result.set_token_index(token_index);
+  result.set_end_token_index(token_index);
   result.set_num_fixed_parameters(0);
   result.set_num_optional_parameters(0);
   result.set_invocation_counter(0);
   result.set_deoptimization_counter(0);
   result.set_is_optimizable(true);
   return result.raw();
 }
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
@@ skipping 442 matching lines @@
                               intptr_t* column) const {
   const String& src = String::Handle(source());
   const String& dummy_key = String::Handle(String::New(""));
   Scanner scanner(src, dummy_key);
   scanner.ScanTo(token_index);
   *line = scanner.CurrentPosition().line;
   *column = scanner.CurrentPosition().column;
 }
 
 
+intptr_t Script::TokenIndexAtLine(intptr_t line_number) const {
+  const String& src = String::Handle(source());
+  const String& dummy_key = String::Handle(String::New(""));
+  Scanner scanner(src, dummy_key);
+  return scanner.TokenIndexAtLine(line_number);
+}
+
+
 RawString* Script::GetLine(intptr_t line_number) const {
   const String& src = String::Handle(source());
   intptr_t current_line = 1;
   intptr_t line_start = -1;
   intptr_t last_char = -1;
   for (intptr_t ix = 0;
        (ix < src.Length()) && (current_line <= line_number);
        ix++) {
     if ((current_line == line_number) && (line_start < 0)) {
       line_start = ix;
@@ skipping 259 matching lines @@
 }
 
 
 void Library::AddClass(const Class& cls) const {
   AddObject(cls, String::Handle(cls.Name()));
   // Link class to this library.
   cls.set_library(*this);
 }
 
 
+// TODO(hausner): we might want to add a script dictionary to the
+// library class to make this lookup less cumbersome.
+RawScript* Library::LookupScript(const String& url) const {
+  Object& entry = Object::Handle();
+  Class& cls = Class::Handle();
+  Function& func = Function::Handle();
+  Field& field = Field::Handle();
+  Script& owner_script = Script::Handle();
+  String& owner_url = String::Handle();
+
+  DictionaryIterator it(*this);
+  while (it.HasNext()) {
+    entry = it.GetNext();
+    if (entry.IsClass()) {
+      cls ^= entry.raw();
+    } else if (entry.IsFunction()) {
+      func ^= entry.raw();
+      cls = func.owner();
+    } else if (entry.IsField()) {
+      field ^= entry.raw();
+      cls = field.owner();
+    } else {
+      continue;
+    }
+    owner_script = cls.script();
+    if (owner_script.IsNull()) {
+      continue;
+    }
+    owner_url = owner_script.url();
+    if (owner_url.Equals(url)) {
+      return owner_script.raw();
+    }
+  }
+  return Script::null();
+}
+
+
+RawFunction* Library::LookupFunctionInSource(const String& script_url,
+                                             intptr_t line_number) const {
+  Script& script = Script::Handle(LookupScript(script_url));
+  if (script.IsNull()) {
+    // The given script url is not loaded into this library.
+    return Function::null();
+  }
+
+  // Determine token position at given line number.
+  intptr_t token_index_at_line = script.TokenIndexAtLine(line_number);
+  if (token_index_at_line < 0) {
+    // Script does not contain the given line number.
+    return Function::null();
+  }
+
+  return LookupFunctionInScript(script, token_index_at_line);
+}
+
+
+RawFunction* Library::LookupFunctionInScript(const Script& script,
+                                             intptr_t token_index) const {
+  Object& entry = Object::Handle();
+  Class& cls = Class::Handle();
+  Function& func = Function::Handle();
+  DictionaryIterator it(*this);
+  while (it.HasNext()) {
+    entry = it.GetNext();
+    if (entry.IsFunction()) {
+      func ^= entry.raw();
+      cls = func.owner();
+      if (script.raw() == cls.script()) {
+        if ((func.token_index() <= token_index) &&
+            (token_index < func.end_token_index())) {
+          return func.raw();
+        }
+      }
+    } else if (entry.IsClass()) {
+      cls ^= entry.raw();
+      if (script.raw() == cls.script()) {
+        func = cls.LookupFunctionAtToken(token_index);
+        if (!func.IsNull()) {
+          return func.raw();
+        }
+      }
+    }
+  }
+  return Function::null();
+}
+
+
 RawObject* Library::LookupLocalObject(const String& name) const {
   Isolate* isolate = Isolate::Current();
   const Array& dict = Array::Handle(isolate, dictionary());
   intptr_t dict_size = dict.Length() - 1;
   intptr_t index = name.Hash() % dict_size;
 
   Object& entry = Object::Handle(isolate, Object::null());
   Class& cls = Class::Handle(isolate, Class::null());
   Function& func = Function::Handle(isolate, Function::null());
   Field& field = Field::Handle(isolate, Field::null());
@@ skipping 3628 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart