Handle 0 in BigintOperations::ToDecimalCString.

runtime/vm/bigint_operations.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 
 #include "vm/bigint_operations.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 
 #include "vm/double_internals.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
@@ skipping 347 matching lines @@
     // into dart code or allocating any code.
     const Instance& exception =
         Instance::Handle(isolate->object_store()->out_of_memory());
     Exceptions::Throw(exception);
     UNREACHABLE();
   }
 
   // Approximate the size of the resulting string. We prefer overestimating
   // to not allocating enough.
   int64_t bit_length = length * kDigitBitSize;
-  ASSERT(bit_length > length);
+  ASSERT(bit_length > length || length == 0);
   int64_t decimal_length = (bit_length * kLog2Dividend / kLog2Divisor) + 1;
   // Add one byte for the trailing \0 character.
   int64_t required_size = decimal_length + 1;
   if (bigint.IsNegative()) {
     required_size++;
   }
   ASSERT(required_size == static_cast<intptr_t>(required_size));
   // We will fill the result in the inverse order and then exchange at the end.
   char* result =
       reinterpret_cast<char*>(allocator(static_cast<intptr_t>(required_size)));
@@ skipping 13 matching lines @@
   const Bigint& rest = Bigint::Handle(Copy(bigint));
   while (!rest.IsZero()) {
     Chunk remainder = InplaceUnsignedDivideRemainderDigit(rest, divisor);
     intptr_t part = static_cast<intptr_t>(remainder);
     for (int i = 0; i < kChunkDigits; i++) {
       result[result_pos++] = '0' + (part % 10);
       part /= 10;
     }
     ASSERT(part == 0);
   }
-  // Move the resulting position back until we don't have any zeroes anymore.
-  // This is done so that we can remove all leading zeroes.
+  // Add a leading zero, so that we have at least one digit.
+  result[result_pos++] = '0';
+  // Move the resulting position back until we don't have any zeroes anymore
+  // or we reach the first digit. This is done so that we can remove all
+  // redundant leading zeroes.
   while (result_pos > 1 && result[result_pos - 1] == '0') {
     result_pos--;
   }
   if (bigint.IsNegative()) {
     result[result_pos++] = '-';
   }
   // Reverse the string.
   int i = 0;
   int j = result_pos - 1;
   while (i < j) {
@@ skipping 1397 matching lines @@
 intptr_t BigintOperations::CountBits(Chunk digit) {
   intptr_t result = 0;
   while (digit != 0) {
     digit >>= 1;
     result++;
   }
   return result;
 }
 
 }  // namespace dart