New bigint implementation in the vm.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
-#include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_message.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debuginfo.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
@@ skipping 120 matching lines @@
     return true;
   }
   Isolate* isolate = arguments->isolate();
   ASSERT(isolate == Isolate::Current());
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   intptr_t cid = obj.GetClassId();
   if (cid == kBigintCid) {
     const Bigint& bigint = Bigint::Cast(obj);
-    if (BigintOperations::FitsIntoInt64(bigint)) {
-      *value = BigintOperations::ToInt64(bigint);
+    if (bigint.FitsIntoInt64()) {
+      *value = bigint.AsInt64Value();
       return true;
     }
   }
   return false;
 }
 
 
 static bool GetNativeUnsignedIntegerArgument(NativeArguments* arguments,
                                              int arg_index,
                                              uint64_t* value) {
   ASSERT(value != NULL);
   int64_t arg_value = 0;
   if (Api::GetNativeIntegerArgument(arguments, arg_index, &arg_value)) {
     *value = static_cast<uint64_t>(arg_value);
     return true;
   }
   Isolate* isolate = arguments->isolate();
   ASSERT(isolate == Isolate::Current());
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   intptr_t cid = obj.GetClassId();
   if (cid == kBigintCid) {
     const Bigint& bigint = Bigint::Cast(obj);
-    if (BigintOperations::FitsIntoUint64(bigint)) {
-      *value = BigintOperations::ToUint64(bigint);
+    if (bigint.FitsIntoUint64()) {
+      *value = bigint.AsUint64Value();
       return true;
     }
   }
   return false;
 }
 
 
 static bool GetNativeDoubleArgument(NativeArguments* arguments,
                                     int arg_index,
                                     double* value) {
@@ skipping 688 matching lines @@
     return Smi::Cast(result).Value();
   }
   if (result.IsMint()) {
     const Mint& mint = Mint::Cast(result);
     if (!mint.IsNegative()) {
       return mint.AsInt64Value();
     }
   }
   if (result.IsBigint()) {
     const Bigint& bigint = Bigint::Cast(result);
-    if (BigintOperations::FitsIntoUint64(bigint)) {
-      return BigintOperations::ToUint64(bigint);
+    if (bigint.FitsIntoUint64()) {
+      return bigint.AsUint64Value();
     }
   }
   return 0;
 }
 
 
 DART_EXPORT Dart_Handle Dart_HandleFromPersistent(
     Dart_PersistentHandle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
@@ skipping 1000 matching lines @@
   if (class_id == kSmiCid || class_id == kMintCid) {
     *fits = true;
     return Api::Success();
   }
   // Slow path for Mints and Bigints.
   DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
-  ASSERT(!BigintOperations::FitsIntoInt64(Bigint::Cast(int_obj)));
+  ASSERT(!Bigint::Cast(int_obj).FitsIntoInt64());
   *fits = false;
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoUint64(Dart_Handle integer,
                                                    bool* fits) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     *fits = (Api::SmiValue(integer) >= 0);
     return Api::Success();
   }
   // Slow path for Mints and Bigints.
   DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint()) {
     *fits = !int_obj.IsNegative();
   } else {
-    *fits = BigintOperations::FitsIntoUint64(Bigint::Cast(int_obj));
+    *fits = Bigint::Cast(int_obj).FitsIntoUint64();
   }
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Smi::IsValid(value)) {
@@ skipping 30 matching lines @@
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint()) {
     *value = int_obj.AsInt64Value();
     return Api::Success();
   } else {
     const Bigint& bigint = Bigint::Cast(int_obj);
-    if (BigintOperations::FitsIntoInt64(bigint)) {
-      *value = BigintOperations::ToInt64(bigint);
+    if (bigint.FitsIntoInt64()) {
+      *value = bigint.AsInt64Value();
       return Api::Success();
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as an int64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToUint64(Dart_Handle integer,
                                              uint64_t* value) {
@@ skipping 12 matching lines @@
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint() && !int_obj.IsNegative()) {
     *value = int_obj.AsInt64Value();
     return Api::Success();
   } else {
     const Bigint& bigint = Bigint::Cast(int_obj);
-    if (BigintOperations::FitsIntoUint64(bigint)) {
-      *value = BigintOperations::ToUint64(bigint);
+    if (bigint.FitsIntoUint64()) {
+      *value = bigint.AsUint64Value();
       return Api::Success();
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as a uint64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
 
 static uword BigintAllocate(intptr_t size) {
   return Api::TopScope(Isolate::Current())->zone()->AllocUnsafe(size);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToHexCString(Dart_Handle integer,
                                                  const char** value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     const Bigint& bigint = Bigint::Handle(isolate,
-        BigintOperations::NewFromInt64(int_obj.AsInt64Value()));
-    *value = BigintOperations::ToHexCString(bigint, BigintAllocate);
+        Bigint::NewFromInt64(int_obj.AsInt64Value()));
+    *value = bigint.ToHexCString(BigintAllocate);
   } else {
-    *value = BigintOperations::ToHexCString(Bigint::Cast(int_obj),
-                                            BigintAllocate);
+    *value = Bigint::Cast(int_obj).ToHexCString(BigintAllocate);
   }
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewDouble(double value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, Double::New(value));
@@ skipping 419 matching lines @@
   } else if (retval.IsMint() || retval.IsBigint()) {
     if (retval.IsMint()) {
       int64_t mint_value = Mint::Cast(retval).value();
       if (mint_value >= kIntptrMin && mint_value <= kIntptrMax) {
         *len = static_cast<intptr_t>(mint_value);
       }
     } else {
       // Check for a non-canonical Mint range value.
       ASSERT(retval.IsBigint());
       const Bigint& bigint = Bigint::Handle();
-      if (BigintOperations::FitsIntoInt64(bigint)) {
+      if (bigint.FitsIntoInt64()) {
         int64_t bigint_value = bigint.AsInt64Value();
         if (bigint_value >= kIntptrMin && bigint_value <= kIntptrMax) {
           *len = static_cast<intptr_t>(bigint_value);
         }
       }
     }
     return Api::NewError("Length of List object is greater than the "
                          "maximum value that 'len' parameter can hold");
   } else if (retval.IsError()) {
     return Api::NewHandle(isolate, retval.raw());
@@ skipping 2887 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart