Add an interface for retrieving the value of unsigned 64-bit integers.

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 696 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* str) {
   DARTSCOPE(Isolate::Current());
   const String& str_obj = String::Handle(String::New(str));
   const Integer& obj = Integer::Handle(Integer::New(str_obj));
   return Api::NewLocalHandle(obj);
 }
 
 
-DART_EXPORT Dart_Handle Dart_IntegerValue(Dart_Handle integer, int64_t* value) {
+DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer,
+                                            int64_t* value) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(integer));
   if (obj.IsSmi() || obj.IsMint()) {
     Integer& integer = Integer::Handle();
     integer ^= obj.raw();
     *value = integer.AsInt64Value();
     return Api::Success();
   }
   if (obj.IsBigint()) {
     Bigint& bigint = Bigint::Handle();
     bigint ^= obj.raw();
     if (BigintOperations::FitsIntoInt64(bigint)) {
       *value = BigintOperations::ToInt64(bigint);
       return Api::Success();
     } else {
       return Api::Error("Integer too big to fit in int64_t");
     }
   }
   return Api::Error("Object is not a Integer");
 }
 
 
+DART_EXPORT Dart_Handle Dart_IntegerToUint64(Dart_Handle integer,
+                                             uint64_t* value) {

[turnidge, 2011/11/17 23:19:02]

Seeing "Uint64", I might actually prefer the form "UInt64", because in my mind I
think of it as Unsigned Int, instead of an opaque abbrevation.  It looks like we
were pretty consistent on UInt64 in the code before.  Thoughts?

[cshapiro, 2011/11/18 10:06:54]

I agree, but I was the one who put the UInt into the code base and, in
retrospect, I was not being consistent with the rest of the system.  Plus, the
JavaScript API for Typed Arrays uses the Uint convention and so its in our Dart
code.  Better one convention than two.  But, there is no reason we cannot wholly
go either way on this.  I have no preference aside from consistency so I am
happy to flip everything in the UInt direction instead.

[turnidge, 2011/11/22 21:06:14]

Okay, go ahead with Uint then.  That seems okay.

On 2011/11/18 10:06:54, cshapiro wrote:

+  DARTSCOPE(Isolate::Current());
+  const Object& obj = Object::Handle(Api::UnwrapHandle(integer));
+  if (obj.IsSmi() || obj.IsMint()) {
+    Integer& integer = Integer::Handle();
+    integer ^= obj.raw();
+    if (integer.IsNegative()) {
+      return Api::Error("Integer too small to fit in uint64_t");
+    }
+    integer ^= obj.raw();
+    *value = integer.AsInt64Value();
+    return Api::Success();
+  }
+  if (obj.IsBigint()) {
+    Bigint& bigint = Bigint::Handle();
+    bigint ^= obj.raw();
+    if (BigintOperations::FitsIntoUint64(bigint)) {
+      *value = BigintOperations::ToUint64(bigint);
+      return Api::Success();
+    } else {
+      return Api::Error("Integer too big to fit in uint64_t");

[turnidge, 2011/11/17 23:19:02]

Regarding the range checks here and above.

Not sure I personally think "small" when I see a large negative integer.  Also,
negative numbers will come out as "too big" here in the second test.  One could
hoist the negative test above out of the smi/mint case and say something about
"must be non-negative".

Whatever we do, we should consider making the IntegerToInt64 above have
consistent error messages.

[cshapiro, 2011/11/18 10:06:54]

The missing negative test is an outright bug.  (That is what I get for not
writing a unit test for this API call.   I will fix that in the re-upload.) 
This is meant to be an access and not a conversion so it should never return a
value from thin air.

At any rate, I will lose the "too small" phrasing and put something (hopefully)
more accessible in its place.

+    }
+  }
+  return Api::Error("Object is not a Integer");
+}
+
+
 DART_EXPORT Dart_Handle Dart_IntegerValueHexCString(Dart_Handle integer,
                                                     const char** value) {

[turnidge, 2011/11/17 23:19:02]

I think we should make this name consistent with the name above, possibly
changing to "IntegerToHexCString".

These become inconsistent with most of the value-accessors in this file,
unfortunately, so I could see these all going through another round of changes
down the line.

[cshapiro, 2011/11/18 10:06:54]

We should certainly try and reduce the amount of naming entropy.  I will go
ahead and make the change here as well.

   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(integer));
   Bigint& bigint = Bigint::Handle();
   if (obj.IsSmi() || obj.IsMint()) {
     Integer& integer = Integer::Handle();
     integer ^= obj.raw();
     bigint ^= BigintOperations::NewFromInt64(integer.AsInt64Value());
     *value = BigintOperations::ToHexCString(bigint, &Api::Allocate);
     return Api::Success();
   }
@@ skipping 1395 matching lines @@
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   return scope->zone().Reallocate(ptr, old_size, new_size);
 }
 
 
 }  // namespace dart