Added macros OBJECT_IMPLEMENTATION and FINAL_OBJECT_IMPLEMENTATION

vm/resolver.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/resolver.h"
 
 #include "vm/flags.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 108 matching lines @@
   Class& cls = Class::Handle(receiver_class.raw());
   if (FLAG_trace_resolving) {
     OS::Print("ResolveDynamic '%s' for class %s\n",
               function_name.ToCString(),
               String::Handle(cls.Name()).ToCString());
   }
 
   const bool is_getter = Field::IsGetterName(function_name);
   String& field_name = String::Handle();
   if (is_getter) {
-    field_name |= Field::NameFromGetter(function_name);
+    field_name ^= Field::NameFromGetter(function_name);
   }
 
   // Now look for an instance function whose name matches function_name
   // in the class.
   Function& function = Function::Handle();
   while (function.IsNull() && !cls.IsNull()) {
-    function |= cls.LookupDynamicFunction(function_name);
+    function ^= cls.LookupDynamicFunction(function_name);
 
     // Getter invocation might actually be a method extraction.
     if (is_getter && function.IsNull()) {
-      function |= cls.LookupDynamicFunction(field_name);
+      function ^= cls.LookupDynamicFunction(field_name);
       if (!function.IsNull()) {
         // We were looking for the getter but found a method with the same name.
         // Create a method extractor and return it.
-        function |= CreateMethodExtractor(function_name, function);
+        function ^= CreateMethodExtractor(function_name, function);
       }
     }
 
     cls = cls.SuperClass();
   }
   return function.raw();
 }
 
 
 RawFunction* Resolver::ResolveStatic(const Library& library,
                                      const String& class_name,
                                      const String& function_name,
                                      int num_arguments,
                                      const Array& argument_names,
                                      StaticResolveType resolve_type) {
   ASSERT(!library.IsNull());
   Function& function = Function::Handle();
   if (class_name.IsNull() || (class_name.Length() == 0)) {
     // Check if we are referring to a top level function.
     const Object& object = Object::Handle(library.LookupObject(function_name));
     if (!object.IsNull() && object.IsFunction()) {
-      function |= object.raw();
+      function ^= object.raw();
       if (!function.AreValidArguments(num_arguments, argument_names, NULL)) {
         if (FLAG_trace_resolving) {
           String& error_message = String::Handle();
           // Obtain more detailed error message.
           function.AreValidArguments(num_arguments,
                                      argument_names,
                                      &error_message);
           OS::Print("ResolveStatic error '%s': %s.\n",
                     function_name.ToCString(),
                     error_message.ToCString());
@@ skipping 73 matching lines @@
       OS::Print("ResolveStatic error '%s': %s.\n",
                 function_name.ToCString(),
                 error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
 }  // namespace dart