First part of inspecting local variables

runtime/vm/object.cc

 // Copyright (c) 2011, 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 "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 50 matching lines @@
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::field_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::token_stream_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::script_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_prefix_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::code_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::pc_descriptors_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::var_descriptors_class_ =
+    reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::exception_handlers_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_scope_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::api_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 #undef RAW_NULL
 
 int Object::GetSingletonClassIndex(const RawClass* raw_class) {
   ASSERT(raw_class->IsHeapObject());
   if (raw_class == class_class()) {
@@ skipping 29 matching lines @@
   } else if (raw_class == library_class()) {
     return kLibraryClass;
   } else if (raw_class == library_prefix_class()) {
     return kLibraryPrefixClass;
   } else if (raw_class == code_class()) {
     return kCodeClass;
   } else if (raw_class == instructions_class()) {
     return kInstructionsClass;
   } else if (raw_class == pc_descriptors_class()) {
     return kPcDescriptorsClass;
+  } else if (raw_class == var_descriptors_class()) {
+    return kLocalVarDescriptorsClass;
   } else if (raw_class == exception_handlers_class()) {
     return kExceptionHandlersClass;
   } else if (raw_class == context_class()) {
     return kContextClass;
   } else if (raw_class == context_scope_class()) {
     return kContextScopeClass;
   } else if (raw_class == api_error_class()) {
     return kApiErrorClass;
   }
   return kInvalidIndex;
@@ skipping 16 matching lines @@
         return instantiated_type_arguments_class();
     case kFunctionClass: return function_class();
     case kFieldClass: return field_class();
     case kTokenStreamClass: return token_stream_class();
     case kScriptClass: return script_class();
     case kLibraryClass: return library_class();
     case kLibraryPrefixClass: return library_prefix_class();
     case kCodeClass: return code_class();
     case kInstructionsClass: return instructions_class();
     case kPcDescriptorsClass: return pc_descriptors_class();
+    case kLocalVarDescriptorsClass: return var_descriptors_class();
     case kExceptionHandlersClass: return exception_handlers_class();
     case kContextClass: return context_class();
     case kContextScopeClass: return context_scope_class();
     case kApiErrorClass: return api_error_class();
     default: break;
   }
   UNREACHABLE();
   return reinterpret_cast<RawClass*>(kHeapObjectTag);  // return RAW_NULL.
 }
 
@@ skipping 13 matching lines @@
     case kInstantiatedTypeArgumentsClass: return "InstantiatedTypeArguments";
     case kFunctionClass: return "Function";
     case kFieldClass: return "Field";
     case kTokenStreamClass: return "TokenStream";
     case kScriptClass: return "Script";
     case kLibraryClass: return "Library";
     case kLibraryPrefixClass: return "LibraryPrefix";
     case kCodeClass: return "Code";
     case kInstructionsClass: return "Instructions";
     case kPcDescriptorsClass: return "PcDescriptors";
+    case kLocalVarDescriptorsClass: return "LocalVarDescriptors";
     case kExceptionHandlersClass: return "ExceptionHandlers";
     case kContextClass: return "Context";
     case kContextScopeClass: return "ContextScope";
     case kApiErrorClass: return "ApiError";
     default: break;
   }
   UNREACHABLE();
   return NULL;
 }
 
@@ skipping 114 matching lines @@
 
   cls = Class::New<Code>();
   code_class_ = cls.raw();
 
   cls = Class::New<Instructions>();
   instructions_class_ = cls.raw();
 
   cls = Class::New<PcDescriptors>();
   pc_descriptors_class_ = cls.raw();
 
+  cls = Class::New<LocalVarDescriptors>();
+  var_descriptors_class_ = cls.raw();
+
   cls = Class::New<ExceptionHandlers>();
   exception_handlers_class_ = cls.raw();
 
   cls = Class::New<Context>();
   context_class_ = cls.raw();
 
   cls = Class::New<ContextScope>();
   context_scope_class_ = cls.raw();
 
   cls = Class::New<ApiError>();
@@ skipping 4238 matching lines @@
   // Layout the fields in the buffer.
   intptr_t index = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     index += OS::SNPrint((buffer + index), (len - index), kFormat,
         PC(i), KindAsStr(i), NodeId(i), TryIndex(i), TokenIndex(i));
   }
   return buffer;
 }
 
 
+RawString* LocalVarDescriptors::GetName(intptr_t var_index) const {
+  ASSERT(var_index < Length());
+  const Array& names = Array::Handle(raw_ptr()->names_);
+  ASSERT(Length() == names.Length());
+  const String& name = String::CheckedHandle(names.At(var_index));
+  return name.raw();
+}
+
+
+void LocalVarDescriptors::GetRange(intptr_t var_index,
+                                   intptr_t* begin_token_pos,
+                                   intptr_t* end_token_pos) const {
+  ASSERT(var_index < Length());
+  RawLocalVarDescriptors::VarInfo *info = &raw_ptr()->data_[var_index];
+  *begin_token_pos = info->begin_pos;
+  *end_token_pos = info->end_pos;
+}
+
+
+void LocalVarDescriptors::SetVar(intptr_t var_index,
+                                const String& name,
+                                intptr_t stack_slot,
+                                intptr_t begin_pos,
+                                intptr_t end_pos) const {
+  ASSERT(var_index < Length());
+  const Array& names = Array::Handle(raw_ptr()->names_);
+  ASSERT(Length() == names.Length());
+  names.SetAt(var_index, name);
+  RawLocalVarDescriptors::VarInfo *info = &raw_ptr()->data_[var_index];
+  info->index = stack_slot;
+  info->begin_pos = begin_pos;
+  info->end_pos = end_pos;
+}
+
+
+const char* LocalVarDescriptors::ToCString() const {
+  UNIMPLEMENTED();
+  return "";
+}
+
+
+RawLocalVarDescriptors* LocalVarDescriptors::New(intptr_t num_variables) {
+  const Class& cls = Class::Handle(Object::var_descriptors_class());
+  LocalVarDescriptors& result = LocalVarDescriptors::Handle();
+  {
+    uword size = LocalVarDescriptors::InstanceSize(num_variables);
+    RawObject* raw = Object::Allocate(cls, size, Heap::kOld);
+    NoGCScope no_gc;
+    result ^= raw;
+    result.raw_ptr()->length_ = num_variables;
+  }
+  const Array& names = Array::Handle(Array::New(num_variables, Heap::kOld));
+  result.raw_ptr()->names_ = names.raw();
+  return result.raw();
+}
+
+
+intptr_t LocalVarDescriptors::Length() const {
+  return raw_ptr()->length_;
+}
+
+
 intptr_t ExceptionHandlers::Length() const {
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 void ExceptionHandlers::SetLength(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   raw_ptr()->length_ = Smi::New(value);
 }
@@ skipping 2821 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