Added macros OBJECT_IMPLEMENTATION and FINAL_OBJECT_IMPLEMENTATION

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 "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 490 matching lines @@
 
 void ActivationFrame::VariableAt(intptr_t i,
                                  String* name,
                                  intptr_t* token_pos,
                                  intptr_t* end_pos,
                                  Instance* value) {
   GetDescIndices();
   ASSERT(i < desc_indices_.length());
   intptr_t desc_index = desc_indices_[i];
   ASSERT(name != NULL);
-  *name |= var_descriptors_.GetName(desc_index);
+  *name ^= var_descriptors_.GetName(desc_index);
   RawLocalVarDescriptors::VarInfo var_info;
   var_descriptors_.GetInfo(desc_index, &var_info);
   ASSERT(token_pos != NULL);
   *token_pos = var_info.begin_pos;
   ASSERT(end_pos != NULL);
   *end_pos = var_info.end_pos;
   ASSERT(value != NULL);
   if (var_info.kind == RawLocalVarDescriptors::kStackVar) {
     *value = GetLocalVarValue(var_info.index);
   } else {
@@ skipping 295 matching lines @@
   Class& cls = Class::Handle();
   Array& functions = Array::Handle();
   Function& function = Function::Handle();
   intptr_t num_classes = class_table.NumCids();
   for (intptr_t i = 1; i < num_classes; i++) {
     if (class_table.HasValidClassAt(i)) {
       cls = class_table.At(i);
       functions = cls.functions();
       intptr_t num_functions = functions.IsNull() ? 0 : functions.Length();
       for (intptr_t f = 0; f < num_functions; f++) {
-        function |= functions.At(f);
+        function ^= functions.At(f);
         ASSERT(!function.IsNull());
         if (function.HasOptimizedCode()) {
           function.SwitchToUnoptimizedCode();
         }
       }
     }
   }
 }
 
 
@@ skipping 302 matching lines @@
 }
 
 
 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);
+    lib ^= libs.At(i);
     script = lib.LookupScript(script_url);
     if (!script.IsNull()) {
       break;
     }
   }
   if (script.IsNull()) {
     if (FLAG_verbose_debug) {
       OS::Print("Failed to find script with url '%s'\n",
                 script_url.ToCString());
     }
@@ skipping 114 matching lines @@
   Array& fields = Array::Handle();
   Field& field = Field::Handle();
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
   String& field_name = String::Handle();
   Object& field_value = Object::Handle();
   // Iterate over fields in class hierarchy to count all instance fields.
   while (!cls.IsNull()) {
     fields = cls.fields();
     for (int i = 0; i < fields.Length(); i++) {
-      field |= fields.At(i);
+      field ^= fields.At(i);
       if (!field.is_static()) {
         field_name = field.name();
         field_list.Add(field_name);
         field_value = GetInstanceField(cls, field_name, obj);
         field_list.Add(field_value);
       }
     }
     cls = cls.SuperClass();
   }
   return Array::MakeArray(field_list);
 }
 
 
 RawArray* Debugger::GetStaticFields(const Class& cls) {
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
   Array& fields = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   String& field_name = String::Handle();
   Object& field_value = Object::Handle();
   for (int i = 0; i < fields.Length(); i++) {
-    field |= fields.At(i);
+    field ^= fields.At(i);
     if (field.is_static()) {
       field_name = field.name();
       field_value = GetStaticField(cls, field_name);
       field_list.Add(field_name);
       field_list.Add(field_value);
     }
   }
   return Array::MakeArray(field_list);
 }
 
 
 void Debugger::CollectLibraryFields(const GrowableObjectArray& field_list,
                                     const Library& lib,
                                     const String& prefix,
                                     bool include_private_fields) {
   DictionaryIterator it(lib);
   Object& entry = Object::Handle(isolate_);
   Field& field = Field::Handle(isolate_);
   Class& cls = Class::Handle(isolate_);
   String& field_name = String::Handle(isolate_);
   Object& field_value = Object::Handle(isolate_);
   while (it.HasNext()) {
     entry = it.GetNext();
     if (entry.IsField()) {
-      field |= entry.raw();
+      field ^= entry.raw();
       cls = field.owner();
       ASSERT(field.is_static());
       field_name = field.name();
       if ((field_name.CharAt(0) == '_') && !include_private_fields) {
         // Skip library-private field.
         continue;
       }
       field_value = GetStaticField(cls, field_name);
       if (!prefix.IsNull()) {
         field_name = String::Concat(prefix, field_name);
@@ skipping 385 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart