Added macros OBJECT_IMPLEMENTATION and FINAL_OBJECT_IMPLEMENTATION

vm/bigint_operations.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 
 #include "vm/bigint_operations.h"
 
 #include "platform/utils.h"
 
 #include "vm/double_internals.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/zone.h"
@@ skipping 166 matching lines @@
   // Then multiply the temporary result by 10^kDigitsPerIteration and add
   // 'increment' to the new result.
   const Bigint& increment = Bigint::Handle(Bigint::Allocate(1));
   while (str_pos < str_length - 1) {
     Chunk digit = 0;
     for (intptr_t i = 0; i < kDigitsPerIteration; i++) {
       char c = str[str_pos++];
       ASSERT(('0' <= c) && (c <= '9'));
       digit = digit * 10 + c - '0';
     }
-    result |= MultiplyWithDigit(result, kTenMultiplier);
+    result = MultiplyWithDigit(result, kTenMultiplier);
     if (digit != 0) {
       increment.SetChunkAt(0, digit);
-      result |= Add(result, increment);
+      result = Add(result, increment);
     }
   }
   Clamp(result);
   if ((space == Heap::kOld) && !result.IsOld()) {
-    result |= Object::Clone(result, Heap::kOld);
+    result ^= Object::Clone(result, Heap::kOld);
   }
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::NewFromDouble(double d, Heap::Space space) {
   if ((-1.0 < d) && (d < 1.0)) {
     // Shortcut for small numbers. Also makes the right-shift below
     // well specified.
     Smi& zero = Smi::Handle(Smi::New(0));
@@ skipping 1267 matching lines @@
     const Bigint& a, const Bigint& b, Bigint* quotient, Bigint* remainder) {
   // TODO(floitsch): This function is very memory-intensive since all
   // intermediate bigint results are allocated in new memory. It would be
   // much more efficient to reuse the space of temporary intermediate variables.
   ASSERT(IsClamped(a));
   ASSERT(IsClamped(b));
   ASSERT(!b.IsZero());
 
   int comp = UnsignedCompare(a, b);
   if (comp < 0) {
-    (*quotient) |= Zero();
-    (*remainder) |= Copy(a);  // TODO(floitsch): can we reuse the input?
+    (*quotient) = Zero();
+    (*remainder) = Copy(a);  // TODO(floitsch): can we reuse the input?
     return;
   } else if (comp == 0) {
-    (*quotient) |= One();
+    (*quotient) = One();
     quotient->SetSign(a.IsNegative() != b.IsNegative());
-    (*remainder) |= Zero();
+    (*remainder) = Zero();
     return;
   }
 
   // High level description:
   // The algorithm is basically the algorithm that is taught in school:
   // Let a the dividend and b the divisor. We are looking for
   // the quotient q = truncate(a / b), and
   // the remainder r = a - q * b.
   // School algorithm:
   // q = 0
@@ skipping 14 matching lines @@
   Bigint& dividend = Bigint::Handle(ShiftLeft(a, normalization_shift));
   const Bigint& divisor = Bigint::Handle(ShiftLeft(b, normalization_shift));
   dividend.SetSign(false);
   divisor.SetSign(false);
 
   intptr_t dividend_length = dividend.Length();
   intptr_t divisor_length = b_length;
   ASSERT(divisor_length == divisor.Length());
 
   intptr_t quotient_length = dividend_length - divisor_length + 1;
-  *quotient |= Bigint::Allocate(quotient_length);
+  *quotient = Bigint::Allocate(quotient_length);
   quotient->SetSign(a.IsNegative() != b.IsNegative());
 
   intptr_t quotient_pos = dividend_length - divisor_length;
   // Find the first quotient-digit.
   // The first digit must be computed separately from the other digits because
   // the preconditions for the loop are not yet satisfied.
   // For simplicity use a shifted divisor, so that the comparison and
   // subtraction are easier.
   int divisor_shift_amount = dividend_length - divisor_length;
   Bigint& shifted_divisor =
       Bigint::Handle(DigitsShiftLeft(divisor, divisor_shift_amount));
   Chunk first_quotient_digit = 0;
   while (UnsignedCompare(dividend, shifted_divisor) >= 0) {
     first_quotient_digit++;
-    dividend |= Subtract(dividend, shifted_divisor);
+    dividend = Subtract(dividend, shifted_divisor);
   }
   quotient->SetChunkAt(quotient_pos--, first_quotient_digit);
 
   // Find the remainder of the digits.
 
   Chunk first_divisor_digit = divisor.GetChunkAt(divisor_length - 1);
   // The short divisor only represents the first two digits of the divisor.
   // If the divisor has only one digit, then the second part is zeroed out.
   Bigint& short_divisor = Bigint::Handle(Bigint::Allocate(2));
   if (divisor_length > 1) {
@@ skipping 52 matching lines @@
     }
 
     // Refine estimation.
     quotient_digit++;  // The following loop will start by decrementing.
     Bigint& estimation_product = Bigint::Handle();
     target.SetChunkAt(0, ((i - 2) < 0) ? 0 : dividend.GetChunkAt(i - 2));
     target.SetChunkAt(1, ((i - 1) < 0) ? 0 : dividend.GetChunkAt(i - 1));
     target.SetChunkAt(2, dividend_digit);
     do {
       quotient_digit = (quotient_digit - 1) & kDigitMask;
-      estimation_product |= MultiplyWithDigit(short_divisor, quotient_digit);
+      estimation_product = MultiplyWithDigit(short_divisor, quotient_digit);
     } while (UnsignedCompareNonClamped(estimation_product, target) > 0);
     // At this point the quotient_digit is fairly accurate.
     // At the worst it is off by one.
     // Remove a multiple of the divisor. If the estimate is incorrect we will
     // subtract the divisor another time.
     // Let t = i - divisor_length.
     // dividend -= (quotient_digit * divisor) << (t * kDigitBitSize);
-    shifted_divisor |= MultiplyWithDigit(divisor, quotient_digit);
-    shifted_divisor |= DigitsShiftLeft(shifted_divisor, i - divisor_length);
+    shifted_divisor = MultiplyWithDigit(divisor, quotient_digit);
+    shifted_divisor = DigitsShiftLeft(shifted_divisor, i - divisor_length);
     dividend = Subtract(dividend, shifted_divisor);
     if (dividend.IsNegative()) {
       // The estimation was still too big.
       quotient_digit--;
       // TODO(floitsch): allocate space for the shifted_divisor once and reuse
       // it at every iteration.
-      shifted_divisor |= DigitsShiftLeft(divisor, i - divisor_length);
+      shifted_divisor = DigitsShiftLeft(divisor, i - divisor_length);
       // TODO(floitsch): reuse the space of the previous dividend.
       dividend = Add(dividend, shifted_divisor);
     }
     quotient->SetChunkAt(quotient_pos--, quotient_digit);
   }
   ASSERT(quotient_pos == -1);
   Clamp(*quotient);
-  *remainder |= ShiftRight(dividend, normalization_shift);
+  *remainder = ShiftRight(dividend, normalization_shift);
   remainder->SetSign(a.IsNegative());
 }
 
 
 void BigintOperations::Clamp(const Bigint& bigint) {
   intptr_t length = bigint.Length();
   while (length > 0 && (bigint.GetChunkAt(length - 1) == 0)) {
     length--;
   }
   // TODO(floitsch): We change the size of bigint-objects here.
@@ skipping 15 matching lines @@
 int BigintOperations::CountBits(Chunk digit) {
   int result = 0;
   while (digit != 0) {
     digit >>= 1;
     result++;
   }
   return result;
 }
 
 }  // namespace dart