Print Bigints in decimal format.

runtime/vm/bigint_operations.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/bigint_operations.h"
 
 #include <openssl/crypto.h>
 
 #include "vm/bigint_store.h"
 #include "vm/double_internals.h"
@@ skipping 202 matching lines @@
     result[0] = '0';
     result[1] = 'x';
     // memcpy would suffice
     memmove(result + 2, str, length - 2);
   }
   OPENSSL_free(to_free);
   return result;
 }
 
 
+const char* BigintOperations::ToDecCString(const Bigint& bigint,
+                                           uword (*allocator)(intptr_t size)) {
+  return ToDecCString(bigint.BNAddr(), allocator);
+}
+
+
+const char* BigintOperations::ToDecCString(const BIGNUM *bn,
+                                           uword (*allocator)(intptr_t size)) {
+  char* str = BN_bn2dec(bn);

[cshapiro, 2011/11/02 00:19:01]

BN has historically used an inefficient algorithm for binary to decimal
conversion.  Should we replace BN, a faster algorithm, such as the one used by
GMP, would be preferable.

http://www.gnu.org/software/gmp/manual/html_mono/gmp.html#Binary%20to%20Radix

[sra1, 2011/11/02 03:10:23]

It might be fun to write the b^(n*2^i) algorithm in Dart, selecting n such that
b^n is a Smi.
You would need to have simple access to
(1) a Smi test
(2) some approximate comparison to tell if x*x > v without doing the
multiplication (number of bits/bytes/words).
(3) a divide producing both quotient and remainder

If the output is some kind of stream (.writeOn) instead of a string, you can
generate and the high digits before the low digits are ready.
If you are happy to over-allocate by 1 character, a string can be generated
without copying.

+  intptr_t length = strlen(str) + 1;  // '\0'-terminated.
+  char* result = reinterpret_cast<char*>(allocator(length));
+  memmove(result, str, length);
+  OPENSSL_free(str);
+  return result;
+}
+
+
 const char* BigintOperations::ToHexCString(const Bigint& bigint,
                                            uword (*allocator)(intptr_t size)) {
   return ToHexCString(bigint.BNAddr(), allocator);
 }
 
 
 bool BigintOperations::FitsIntoSmi(const Bigint& bigint) {
   const BIGNUM *bn = bigint.BNAddr();
   int bits = BN_num_bits(bn);
   // Special case for kMinValue as the absolute value is 1 bit longer
@@ skipping 316 matching lines @@
   result.ToggleSign();
   return result.raw();
 }
 
 
 int BigintOperations::Compare(const Bigint& a, const Bigint& b) {
   return BN_cmp(a.BNAddr(), b.BNAddr());
 }
 
 }  // namespace dart