Add methods for creating Bigint objects from unsigned 64-bit integers.

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 55 matching lines @@
 }
 
 
 RawBigint* BigintOperations::NewFromInt64(int64_t value, Heap::Space space) {
   bool is_negative = value < 0;
 
   if (is_negative) {
     value = -value;
   }
 
+  const Bigint& result = Bigint::Handle(NewFromUInt64(value, space));
+  result.SetSign(is_negative);
+
+  return result.raw();
+}
+
+
+RawBigint* BigintOperations::NewFromUInt64(uint64_t value, Heap::Space space) {
   const int kNumBytes = sizeof(value);
   unsigned char pch[kNumBytes];
   for (int i = kNumBytes - 1; i >= 0; i--) {
     unsigned char c = value & 0xFF;
     value >>=8;
     pch[i] = c;
   }
-
   BN_bin2bn(pch, kNumBytes, TmpBN());
-
-  const Bigint& result = Bigint::Handle(Bigint::New(TmpBN(), space));
-  result.SetSign(is_negative);
-
-  return result.raw();
+  return Bigint::New(TmpBN(), space);
 }
 
 
 RawBigint* BigintOperations::NewFromCString(const char* str,
                                             Heap::Space space) {
   ASSERT(str != NULL);
   if (str[0] == '\0') {
     return NewFromInt64(0, space);
   }
 
@@ skipping 204 matching lines @@
   // one bit.
   ASSERT(bigint.Bit(63) != 0);
   for (int i = 0; i < 63; i++) {
     // Verify that all 63 least significant bits are 0.
     if (bigint.Bit(i) != 0) return false;
   }
   return true;
 }
 
 
+uint64_t BigintOperations::AbsToUInt64(const Bigint& bigint) {
+  unsigned char bytes[8];
+  ASSERT(BN_num_bytes(bigint.BNAddr()) <= static_cast<int>(sizeof bytes));
+  int n = BN_bn2bin(bigint.BNAddr(), bytes);
+  ASSERT(n >= 0);
+  uint64_t value = 0;
+  ASSERT(n <= static_cast<int>(sizeof value));
+  for (int i = 0; i < n; ++i) {
+    value <<= 8;
+    value |= bytes[i];
+  }
+  return value;
+}
+
+
 int64_t BigintOperations::ToInt64(const Bigint& bigint) {
   ASSERT(FitsIntoInt64(bigint));
-  unsigned char bytes[8];
-  ASSERT(BN_num_bytes(bigint.BNAddr()) <= static_cast<int>(sizeof bytes));
-  int n = BN_bn2bin(bigint.BNAddr(), bytes);
-  ASSERT(n >= 0);
-  int64_t value = 0;
-  ASSERT(n <= static_cast<int>(sizeof value));
-  for (int i = 0; i < n; ++i) {
-    value <<= 8;
-    value |= bytes[i];
-  }
+  int64_t value = AbsToUInt64(bigint);
   if (bigint.IsNegative()) {
     value = -value;
   }
   return value;
 }
 
 
+bool BigintOperations::FitsIntoUInt64(const Bigint& bigint) {
+  const BIGNUM *bn = bigint.BNAddr();
+  if (bigint.IsNegative()) return false;
+  int bits = BN_num_bits(bn);
+  if (bits > 64) return false;
+  return true;
+}
+
+
+uint64_t BigintOperations::ToUInt64(const Bigint& bigint) {
+  ASSERT(FitsIntoUInt64(bigint));
+  return AbsToUInt64(bigint);
+}
+
+
 RawBigint* BigintOperations::Add(const Bigint& a, const Bigint& b) {
   int status = BN_add(TmpBN(), a.BNAddr(), b.BNAddr());
   ASSERT(status == 1);
   const Bigint& result = Bigint::Handle(Bigint::New(TmpBN()));
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::Subtract(const Bigint& a, const Bigint& b) {
   int status = BN_sub(TmpBN(), a.BNAddr(), b.BNAddr());
@@ skipping 223 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