Add a weak property type to the virtual machine.

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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 606 matching lines @@
   RegisterClass(cls, name, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
   // Super type set below, after Object is allocated.
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
   name = Symbols::JSSyntaxRegExp();
   RegisterClass(cls, name, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
+  cls = Class::New<WeakProperty>();
+  object_store->set_weak_property_class(cls);
+  RegisterClass(cls, "WeakProperty", impl_script, core_impl_lib);
+  pending_classes.Add(cls, Heap::kOld);
+
   // Initialize the base interfaces used by the core VM classes.
   const Script& script = Script::Handle(Bootstrap::LoadCoreScript(false));
 
   // Allocate and initialize the Object class and type.  The Object
   // class and ByteArray subclasses are the only pre-allocated,
   // non-interface classes in the core library.
   cls = Class::New<Instance>();
   object_store->set_object_class(cls);
   name = Symbols::Object();
   cls.set_name(name);
@@ skipping 380 matching lines @@
 
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
 
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
 
+  cls = Class::New<WeakProperty>();
+  object_store->set_weak_property_class(cls);
+
   // Allocate pre-initialized values.
   Bool& bool_value = Bool::Handle();
   bool_value = Bool::New(true);
   object_store->set_true_value(bool_value);
   bool_value = Bool::New(false);
   object_store->set_false_value(bool_value);
 }
 
 
 void Object::Print() const {
@@ skipping 714 matching lines @@
   const Type& signature_type = Type::Handle(result.SignatureType());
   ASSERT(!signature_type.IsFinalized());
   const Array& new_canonical_types = Array::Handle(Array::New(1, Heap::kOld));
   new_canonical_types.SetAt(0, signature_type);
   result.set_canonical_types(new_canonical_types);
   return result.raw();
 }
 
 
 RawClass* Class::GetClass(intptr_t class_id, bool is_signature_class) {
-  if (class_id >= kIntegerCid && class_id <= kJSRegExpCid) {
+  if (class_id >= kIntegerCid && class_id <= kWeakPropertyCid) {
     return Isolate::Current()->class_table()->At(class_id);
   }
   if (class_id >= kNumPredefinedCids) {
     if (is_signature_class) {
       return Class::New<Closure>();
     }
     return Class::New<Instance>();
   }
   OS::Print("Class::GetClass id unknown: %d\n", class_id);
   UNREACHABLE();
@@ skipping 9532 matching lines @@
 
 const char* JSRegExp::ToCString() const {
   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 = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
+
+RawWeakProperty* WeakProperty::New(Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->weak_property_class()
+         != Class::null());
+  WeakProperty& result = WeakProperty::Handle();
+  {
+    RawObject* raw = Object::Allocate(WeakProperty::kClassId,
+                                      WeakProperty::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  return result.raw();
+}
+
+
+const char* WeakProperty::ToCString() const {
+  return "WeakProperty";
+}
+
 }  // namespace dart