Added macros OBJECT_IMPLEMENTATION and FINAL_OBJECT_IMPLEMENTATION

vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 344 matching lines @@
 
 Token::Kind Parser::LookaheadToken(int num_tokens) {
   CompilerStats::num_tokens_lookahead++;
   CompilerStats::num_token_checks++;
   return tokens_iterator_.LookaheadTokenKind(num_tokens);
 }
 
 
 String* Parser::CurrentLiteral() const {
   String& result = String::ZoneHandle();
-  result |= tokens_iterator_.CurrentLiteral();
+  result = tokens_iterator_.CurrentLiteral();
   return &result;
 }
 
 
 RawDouble* Parser::CurrentDoubleLiteral() const {
   LiteralToken& token = LiteralToken::Handle();
-  token |= tokens_iterator_.CurrentToken();
+  token ^= tokens_iterator_.CurrentToken();
   ASSERT(token.kind() == Token::kDOUBLE);
   return reinterpret_cast<RawDouble*>(token.value());
 }
 
 
 RawInteger* Parser::CurrentIntegerLiteral() const {
   LiteralToken& token = LiteralToken::Handle();
-  token |= tokens_iterator_.CurrentToken();
+  token ^= tokens_iterator_.CurrentToken();
   ASSERT(token.kind() == Token::kINTEGER);
   return reinterpret_cast<RawInteger*>(token.value());
 }
 
 
 // A QualIdent is an optionally qualified identifier.
 struct QualIdent {
   QualIdent() {
     Clear();
   }
@@ skipping 226 matching lines @@
     return clazz_.raw();
   }
 
   const String& class_name() const {
     return class_name_;
   }
 
   bool has_constructor() const {
     Function& func = Function::Handle();
     for (int i = 0; i < functions_.Length(); i++) {
-      func |= functions_.At(i);
+      func ^= functions_.At(i);
       if (func.kind() == RawFunction::kConstructor) {
         return true;
       }
     }
     return false;
   }
 
   intptr_t token_pos() const {
     return token_pos_;
   }
@@ skipping 13 matching lines @@
       }
     }
     return NULL;
   }
 
  private:
   Field* LookupField(const String& name) const {
     String& test_name = String::Handle();
     Field& field = Field::Handle();
     for (int i = 0; i < fields_.Length(); i++) {
-      field |= fields_.At(i);
+      field ^= fields_.At(i);
       test_name = field.name();
       if (name.Equals(test_name)) {
         return &field;
       }
     }
     return NULL;
   }
 
   bool FieldExists(const String& name) const {
     return LookupField(name) != NULL;
   }
 
   Function* LookupFunction(const String& name) const {
     String& test_name = String::Handle();
     Function& func = Function::Handle();
     for (int i = 0; i < functions_.Length(); i++) {
-      func |= functions_.At(i);
+      func ^= functions_.At(i);
       test_name = func.name();
       if (name.Equals(test_name)) {
         return &func;
       }
     }
     return NULL;
   }
 
   bool FunctionExists(const String& name) const {
     return LookupFunction(name) != NULL;
@@ skipping 1071 matching lines @@
   AstNode* instance = new LoadLocalNode(field_pos, receiver);
   return new StoreInstanceFieldNode(field_pos, instance, field, init_expr);
 }
 
 
 void Parser::CheckConstFieldsInitialized(const Class& cls) {
   const Array& fields = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   SequenceNode* initializers = current_block_->statements;
   for (int field_num = 0; field_num < fields.Length(); field_num++) {
-    field |= fields.At(field_num);
+    field ^= fields.At(field_num);
     if (field.is_static() || !field.is_final()) {
       continue;
     }
     bool found = false;
     for (int i = 0; i < initializers->length(); i++) {
       found = false;
       if (initializers->NodeAt(i)->IsStoreInstanceFieldNode()) {
         StoreInstanceFieldNode* initializer =
             initializers->NodeAt(i)->AsStoreInstanceFieldNode();
         if (initializer->field().raw() == field.raw()) {
@@ skipping 11 matching lines @@
 
 
 void Parser::ParseInitializedInstanceFields(const Class& cls,
                  LocalVariable* receiver,
                  GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializedInstanceFields");
   const Array& fields = Array::Handle(cls.fields());
   Field& f = Field::Handle();
   const intptr_t saved_pos = TokenPos();
   for (int i = 0; i < fields.Length(); i++) {
-    f |= fields.At(i);
+    f ^= fields.At(i);
     if (!f.is_static() && f.has_initializer()) {
       Field& field = Field::ZoneHandle();
-      field |= fields.At(i);
+      field ^= fields.At(i);
       if (field.is_final()) {
         // Final fields with initializer expression may not be initialized
         // again by constructors. Remember that this field is already
         // initialized.
         initialized_fields->Add(&field);
       }
       intptr_t field_pos = field.token_pos();
       SetPosition(field_pos);
       ASSERT(IsIdentifier());
       ConsumeToken();
@@ skipping 1316 matching lines @@
       ErrorMsg(classname_pos, "missing class '%s' cannot be patched",
                class_name.ToCString());
     }
     cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(classname_pos, "'%s' is already defined",
                class_name.ToCString());
     }
-    cls |= obj.raw();
+    cls ^= obj.raw();
     if (is_patch) {
       String& patch = String::Handle(
           String::Concat(Symbols::PatchSpace(), class_name));
       patch = Symbols::New(patch);
       cls = Class::New(patch, script_, classname_pos);
       cls.set_library(library_);
     } else {
       // Not patching a class, but it has been found. This must be one of the
       // pre-registered classes from object.cc or a duplicate definition.
       if (cls.functions() != Object::empty_array().raw()) {
@@ skipping 3954 matching lines @@
       ASSERT((CurrentToken() == Token::kLPAREN) ||
              (CurrentToken() == Token::kCOMMA));
       ConsumeToken();
       if (IsIdentifier() && (LookaheadToken(1) == Token::kCOLON)) {
         named_argument_seen = true;
         // The canonicalization of the arguments descriptor array built in
         // the code generator requires that the names are symbols, i.e.
         // canonicalized strings.
         ASSERT(CurrentLiteral()->IsSymbol());
         for (int i = 0; i < names.Length(); i++) {
-          arg_name |= names.At(i);
+          arg_name ^= names.At(i);
           if (CurrentLiteral()->Equals(arg_name)) {
             ErrorMsg("duplicate named argument");
           }
         }
         names.Add(*CurrentLiteral());
         ConsumeToken();  // ident.
         ConsumeToken();  // colon.
       } else if (named_argument_seen) {
         ErrorMsg("named argument expected");
       }
@@ skipping 268 matching lines @@
           selector = ParseInstanceCall(left, *ident);
         }
       } else {
         // Field access.
         Class& cls = Class::Handle();
         if (left->IsPrimaryNode()) {
           PrimaryNode* primary_node = left->AsPrimaryNode();
           if (primary_node->primary().IsClass()) {
             // If the primary node referred to a class we are loading a
             // qualified static field.
-            cls |= primary_node->primary().raw();
+            cls ^= primary_node->primary().raw();
           }
         }
         if (cls.IsNull()) {
           // Instance field access.
           selector = CallGetter(ident_pos, left, *ident);
         } else {
           // Static field access.
           selector =
               ParseStaticFieldAccess(cls, *ident, ident_pos, !is_cascade);
         }
@@ skipping 712 matching lines @@
   TRACE_PARSER("ResolveNameInCurrentLibraryScope");
   Object& obj = Object::Handle(LookupNameInLibrary(library_, name));
   if (obj.IsNull()) {
     // Name is not found in current library. Check scope of all
     // imported libraries.
     String& first_lib_url = String::Handle();
     Namespace& import = Namespace::Handle();
     intptr_t num_imports = library_.num_imports();
     Object& imported_obj = Object::Handle();
     for (int i = 0; i < num_imports; i++) {
-      import |= library_.ImportAt(i);
+      import = library_.ImportAt(i);
       imported_obj = LookupNameInImport(import, name);
       if (!imported_obj.IsNull()) {
         const Library& lib = Library::Handle(import.library());
         if (!first_lib_url.IsNull()) {
           // Found duplicate definition.
           Error& ambiguous_ref_error = Error::Handle();
           if (first_lib_url.raw() == lib.url()) {
             ambiguous_ref_error = FormatErrorMsg(
                 script_, ident_pos, "Error",
                 "ambiguous reference: "
@@ skipping 82 matching lines @@
                                             const LibraryPrefix& prefix,
                                             const String& name,
                                             Error* error) {
   TRACE_PARSER("ResolveNameInPrefixScope");
   Namespace& import = Namespace::Handle();
   String& first_lib_url = String::Handle();
   Object& obj = Object::Handle();
   Object& resolved_obj = Object::Handle();
   const Array& imports = Array::Handle(prefix.imports());
   for (intptr_t i = 0; i < prefix.num_imports(); i++) {
-    import |= imports.At(i);
+    import ^= imports.At(i);
     resolved_obj = LookupNameInImport(import, name);
     if (!resolved_obj.IsNull()) {
       obj = resolved_obj.raw();
       const Library& lib = Library::Handle(import.library());
       if (first_lib_url.IsNull()) {
         first_lib_url = lib.url();
       } else {
         // Found duplicate definition.
         Error& ambiguous_ref_error = Error::Handle();
         if (first_lib_url.raw() == lib.url()) {
@@ skipping 866 matching lines @@
     ASSERT(values->ElementAt(i)->IsLiteralNode());
     value_arr.SetAt(i, values->ElementAt(i)->AsLiteralNode()->literal());
   }
 
   // Build argument array to pass to the interpolation function.
   const Array& interpolate_arg = Array::Handle(Array::New(1));
   interpolate_arg.SetAt(0, value_arr);
 
   // Call interpolation function.
   String& concatenated = String::ZoneHandle();
-  concatenated |= DartEntry::InvokeStatic(func, interpolate_arg);
+  concatenated ^= DartEntry::InvokeStatic(func, interpolate_arg);
   if (concatenated.IsUnhandledException()) {
     ErrorMsg("Exception thrown in Parser::Interpolate");
   }
   concatenated = Symbols::New(concatenated);
   return concatenated;
 }
 
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
@@ skipping 557 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart