Constraint List length values to the Smi type.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2012, 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 1258 matching lines @@
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer,
                                                   bool* fits) {
   // Fast path for Smis and Mints.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   intptr_t class_id = Api::ClassId(integer);
   if (class_id == kSmiCid || class_id == kMintCid) {
     *fits = true;
     return Api::Success(isolate);
   }
-
+  // Slow path for Mints and Bigints.
   DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   ASSERT(!BigintOperations::FitsIntoMint(Bigint::Cast(int_obj)));
   *fits = false;
   return Api::Success(isolate);
 }
 
 
 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(isolate);
   }
-
+  // Slow path for Mints and Bigints.
   DARTSCOPE_NOCHECKS(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()) {
+  ASSERT(!int_obj.IsSmi());
+  if (int_obj.IsMint()) {
     *fits = !int_obj.IsNegative();
   } else {
     *fits = BigintOperations::FitsIntoUint64(Bigint::Cast(int_obj));
   }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Smi::IsValid64(value)) {
     NOHANDLESCOPE(isolate);
-    return Api::NewHandle(isolate, Smi::New(value));
+    return Api::NewHandle(isolate, Smi::New(static_cast<intptr_t>(value)));
   }
-
+  // Slow path for Mints and Bigints.
   DARTSCOPE_NOCHECKS(isolate);
   return Api::NewHandle(isolate, Integer::New(value));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* str) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str_obj = String::Handle(isolate, String::New(str));
   return Api::NewHandle(isolate, Integer::New(str_obj));
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer,
                                             int64_t* value) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     *value = Api::SmiValue(integer);
     return Api::Success(isolate);
   }
-
+  // Slow path for Mints and Bigints.
   DARTSCOPE_NOCHECKS(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()) {
+  ASSERT(!int_obj.IsSmi());
+  if (int_obj.IsMint()) {
     *value = int_obj.AsInt64Value();
     return Api::Success(isolate);
   } else {
     const Bigint& bigint = Bigint::Cast(int_obj);
     if (BigintOperations::FitsIntoMint(bigint)) {
       *value = BigintOperations::ToMint(bigint);
       return Api::Success(isolate);
     }
   }
   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) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     intptr_t smi_value = Api::SmiValue(integer);
     if (smi_value >= 0) {
       *value = smi_value;
       return Api::Success(isolate);
     }
   }
-
+  // Slow path for Mints and Bigints.
   DARTSCOPE_NOCHECKS(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()) {
-    if (!int_obj.IsNegative()) {
-      *value = int_obj.AsInt64Value();
-      return Api::Success(isolate);
-    }
+  ASSERT(!int_obj.IsSmi());
+  if (int_obj.IsMint() && !int_obj.IsNegative()) {
+    *value = int_obj.AsInt64Value();
+    return Api::Success(isolate);
   } else {
     const Bigint& bigint = Bigint::Cast(int_obj);
     if (BigintOperations::FitsIntoUint64(bigint)) {
       *value = BigintOperations::ToUint64(bigint);
       return Api::Success(isolate);
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as a uint64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
@@ skipping 432 matching lines @@
       Function::Handle(isolate, Resolver::ResolveDynamic(instance, name, 1, 0));
   if (function.IsNull()) {
     return Api::NewError("List object does not have a 'length' field.");
   }
 
   GrowableArray<const Object*> args(0);
   const Array& kNoArgumentNames = Array::Handle(isolate);
   const Object& retval = Object::Handle(
       isolate,
       DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
-  if (retval.IsSmi() || retval.IsMint()) {
-    *len = Integer::Cast(retval).AsInt64Value();
+  if (retval.IsSmi()) {
+    *len = Smi::Cast(retval).Value();
     return Api::Success(isolate);

[siva, 2012/09/19 00:57:34]

As discussed offline we should probably allow for values upto kIntptrMax instead
of restricting it to kSmiMax.

-  } else if (retval.IsBigint()) {
-    const Bigint& bigint = Bigint::Cast(retval);
-    if (BigintOperations::FitsIntoMint(bigint)) {
-      *len = BigintOperations::ToMint(bigint);
-      return Api::Success(isolate);
-    } else {
-      return Api::NewError("Length of List object is greater than the "
-                           "maximum value that 'len' parameter can hold");
-    }
+  } else if (retval.IsMint() || retval.IsBigint()) {
+    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());
   } else {
     return Api::NewError("Length of List object is not an integer");
   }
 }
 
 
 #define GET_LIST_ELEMENT(isolate, type, obj, index)                            \
   const type& array_obj = type::Cast(obj);                                     \
@@ skipping 2574 matching lines @@
 DART_EXPORT void Dart_InitPerfEventsSupport(Dart_FileWriterFunction function) {
   Dart::set_perf_events_writer(function);
 }
 
 
 DART_EXPORT void Dart_InitFlowGraphPrinting(Dart_FileWriterFunction function) {
   Dart::set_flow_graph_writer(function);
 }
 
 }  // namespace dart