Expose the content of Maps and WeakMaps through MapMirror.

src/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 #include <limits>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 1688 matching lines @@
       || kind == JSMapIterator::kKindValues
       || kind == JSMapIterator::kKindEntries);
   Handle<OrderedHashMap> table(OrderedHashMap::cast(map->table()));
   holder->set_table(*table);
   holder->set_index(Smi::FromInt(0));
   holder->set_kind(Smi::FromInt(kind));
   return isolate->heap()->undefined_value();
 }
 
 
+RUNTIME_FUNCTION(Runtime_GetMapEntries) {

[rossberg, 2014/07/16 09:51:07]

Is this necessary? You can easily get the array of entries of an ordinary map
through its public JS interface, so we shouldn't need to add an extra runtime
function for that.

[Alexandra Mikhaylova, 2014/07/16 10:21:13]

Thanks, I'll use the map iterator to get entries then.

+  HandleScope scope(isolate);
+  ASSERT(args.length() == 1);
+  CONVERT_ARG_HANDLE_CHECKED(JSMap, holder, 0);
+  Handle<OrderedHashMap> table(OrderedHashMap::cast(holder->table()));
+  Handle<FixedArray> entries = isolate->factory()->NewFixedArray(
+      table->NumberOfElements() * 2);
+  int number_of_non_hole_elements = 0;
+  { DisallowHeapAllocation no_gc;
+    for (int i = 0; i < table->UsedCapacity(); i++) {
+        Handle<Object> key(table->KeyAt(i), isolate);
+        if (!key->IsTheHole()) {
+            entries->set(number_of_non_hole_elements * 2, *key);
+            entries->set(number_of_non_hole_elements * 2 + 1,
+                         table->ValueAt(i));
+            number_of_non_hole_elements++;
+        }
+    }
+  }
+  return *isolate->factory()->NewJSArrayWithElements(entries);
+}
+
+
+RUNTIME_FUNCTION(Runtime_GetWeakMapEntries) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 1);
+  CONVERT_ARG_HANDLE_CHECKED(JSWeakCollection, holder, 0);
+  Handle<ObjectHashTable> table(ObjectHashTable::cast(holder->table()));
+  Handle<FixedArray> entries = isolate->factory()->NewFixedArray(
+      table->NumberOfElements() * 2);
+  int number_of_non_hole_elements = 0;
+  { DisallowHeapAllocation no_gc;
+    for (int i = 0; i < table->Capacity(); i++) {
+        Handle<Object> key(table->KeyAt(i), isolate);

[Yang, 2014/07/16 12:10:58]

Indentation size is weird. We use 4 spaces for line break and 2 spaces for
scopes. You could also use "git cl format" to have it formatted for you.

[Alexandra Mikhaylova, 2014/07/16 17:00:37]

Done.

+        if (table->IsKey(*key)) {
+            entries->set(number_of_non_hole_elements * 2, *key);
+            entries->set(number_of_non_hole_elements * 2 + 1,
+                         table->Lookup(key));
+            number_of_non_hole_elements++;
+        }
+    }
+  }
+  return *isolate->factory()->NewJSArrayWithElements(entries);
+}
+
+
 RUNTIME_FUNCTION(Runtime_MapIteratorNext) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 2);
   CONVERT_ARG_CHECKED(JSMapIterator, holder, 0);
   CONVERT_ARG_CHECKED(JSArray, value_array, 1);
   return holder->Next(value_array);
 }
 
 
 static Handle<JSWeakCollection> WeakCollectionInitialize(
@@ skipping 13237 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 } }  // namespace v8::internal