Implement BigintOperations::MultiplyWithDigit

runtime/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 1482 matching lines @@
     ASSERT((borrow == 0) || (borrow == 1));
   }
   ASSERT(borrow == 0);
   Clamp(result);
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::MultiplyWithDigit(
     const Bigint& bigint, Chunk digit) {
-  // TODO(floitsch): implement MultiplyWithDigit.
   ASSERT(digit <= kDigitMaxValue);
   if (digit == 0) return Zero();
+  if (bigint.IsZero()) return Zero();
 
-  Bigint& tmp = Bigint::Handle(Bigint::Allocate(1));
-  tmp.SetChunkAt(0, digit);
-  return Multiply(bigint, tmp);
+  intptr_t length = bigint.Length();
+  intptr_t result_length = length + 1;
+  const Bigint& result = Bigint::Handle(Bigint::Allocate(result_length));
+
+  Chunk carry = 0;
+  for (intptr_t i = 0; i < length; i++) {
+    Chunk chunk = bigint.GetChunkAt(i);
+    DoubleChunk product = (static_cast<DoubleChunk>(chunk) * digit) + carry;
+    result.SetChunkAt(i, static_cast<Chunk>(product & kDigitMask));
+    carry = static_cast<Chunk>(product >> kDigitBitSize);
+  }
+  result.SetChunkAt(length, carry);
+
+  result.SetSign(bigint.IsNegative());
+  Clamp(result);
+  return result.raw();
 }
 
 
 void BigintOperations::DivideRemainder(
     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));
@@ skipping 187 matching lines @@
 int BigintOperations::CountBits(Chunk digit) {
   int result = 0;
   while (digit != 0) {
     digit >>= 1;
     result++;
   }
   return result;
 }
 
 }  // namespace dart