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

runtime/vm/dart_api_impl.cc

Index: runtime/vm/dart_api_impl.cc
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index f445bdb442af1c153a919c74f965d4caadba70c4..7640e6247a3826782c573050954a722fe7dcc821 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -714,7 +714,8 @@ DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* str) {
 }
 
 
-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()) {
@@ -737,6 +738,34 @@ DART_EXPORT Dart_Handle Dart_IntegerValue(Dart_Handle integer, int64_t* value) {
 }
 
 
+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());