Make ~/, round, ceil, floor, truncate return ints. Remove toInt.

runtime/lib/double.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 <math.h>
 
 #include "vm/bootstrap_natives.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/double_conversion.h"
@@ skipping 61 matching lines @@
 }
 
 
 DEFINE_NATIVE_ENTRY(Double_trunc_div, 2) {
   double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value();
   GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
   double right = right_object.value();
   if (FLAG_trace_intrinsified_natives) {
     OS::Print("Double_trunc_div %f ~/ %f\n", left, right);
   }
-  return Double::New(trunc(left / right));
+  double result = trunc(left / right);
+  if (isinf(result) || isnan(result)) {

[floitsch, 2013/01/03 18:23:17]

From here on same as 'toInt' on the left (except that I changed the
error-message).

+    const Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, String::Handle(String::New(
+        "Result of truncating division is Infinity or NaN")));
+    Exceptions::ThrowByType(Exceptions::kFormat, args);

[Lasse Reichstein Nielsen, 2013/01/04 10:29:42]

Consider using UnsupportedError instead of FormatException.
The method is not supported by the current object (inf or nan) so it fits the
use of UnsupportedError. And it really is an error, not an exception.

+  }
+  if ((Smi::kMinValue <= result) && (result <= Smi::kMaxValue)) {
+    return Smi::New(static_cast<intptr_t>(result));
+  } else if ((Mint::kMinValue <= result) && (result <= Mint::kMaxValue)) {
+    return Mint::New(static_cast<int64_t>(result));
+  } else {
+    return BigintOperations::NewFromDouble(result);
+  }
 }
 
 
 DEFINE_NATIVE_ENTRY(Double_modulo, 2) {
   double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value();
   GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
   double right = right_object.value();
 
   double remainder = fmod_ieee(left, right);
   if (remainder == 0.0) {
@@ skipping 51 matching lines @@
 
 DEFINE_NATIVE_ENTRY(Double_equalToInteger, 2) {
   const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Integer, right, arguments->NativeArgAt(1));
   return Bool::Get(left.value() == right.AsDoubleValue());
 }
 
 
 DEFINE_NATIVE_ENTRY(Double_round, 1) {
   const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0));
-  return Double::New(round(arg.value()));
+  if (isinf(arg.value()) || isnan(arg.value())) {

[floitsch, 2013/01/03 18:23:17]

same as "toInt" on the left. Only change: error-message.

[Lasse Reichstein Nielsen, 2013/01/04 10:29:42]

Repeated code should be abstracted into a helper method, possibly parameterized
by the error message.

+    const Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, String::Handle(String::New("Infinity or NaN round")));
+    Exceptions::ThrowByType(Exceptions::kFormat, args);
+  }
+  double result = round(arg.value());
+  if ((Smi::kMinValue <= result) && (result <= Smi::kMaxValue)) {
+    return Smi::New(static_cast<intptr_t>(result));
+  } else if ((Mint::kMinValue <= result) && (result <= Mint::kMaxValue)) {
+    return Mint::New(static_cast<int64_t>(result));
+  } else {
+    return BigintOperations::NewFromDouble(result);
+  }
 }
 
 DEFINE_NATIVE_ENTRY(Double_floor, 1) {
   const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0));
-  return Double::New(floor(arg.value()));
+  if (isinf(arg.value()) || isnan(arg.value())) {
+    const Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, String::Handle(String::New("Infinity or NaN floor")));
+    Exceptions::ThrowByType(Exceptions::kFormat, args);
+  }
+  double result = floor(arg.value());
+  if ((Smi::kMinValue <= result) && (result <= Smi::kMaxValue)) {
+    return Smi::New(static_cast<intptr_t>(result));
+  } else if ((Mint::kMinValue <= result) && (result <= Mint::kMaxValue)) {
+    return Mint::New(static_cast<int64_t>(result));
+  } else {
+    return BigintOperations::NewFromDouble(result);
+  }
 }
 
 DEFINE_NATIVE_ENTRY(Double_ceil, 1) {
   const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0));
-  return Double::New(ceil(arg.value()));
+  if (isinf(arg.value()) || isnan(arg.value())) {
+    const Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, String::Handle(String::New("Infinity or NaN ceil")));
+    Exceptions::ThrowByType(Exceptions::kFormat, args);
+  }
+  double result = ceil(arg.value());
+  if ((Smi::kMinValue <= result) && (result <= Smi::kMaxValue)) {
+    return Smi::New(static_cast<intptr_t>(result));
+  } else if ((Mint::kMinValue <= result) && (result <= Mint::kMaxValue)) {
+    return Mint::New(static_cast<int64_t>(result));
+  } else {
+    return BigintOperations::NewFromDouble(result);
+  }
 }
 
 
 DEFINE_NATIVE_ENTRY(Double_truncate, 1) {
   const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0));
-  return Double::New(trunc(arg.value()));
+  if (isinf(arg.value()) || isnan(arg.value())) {
+    const Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, String::Handle(String::New("Infinity or NaN truncate")));
+    Exceptions::ThrowByType(Exceptions::kFormat, args);
+  }
+  double result = trunc(arg.value());
+  if ((Smi::kMinValue <= result) && (result <= Smi::kMaxValue)) {
+    return Smi::New(static_cast<intptr_t>(result));
+  } else if ((Mint::kMinValue <= result) && (result <= Mint::kMaxValue)) {
+    return Mint::New(static_cast<int64_t>(result));
+  } else {
+    return BigintOperations::NewFromDouble(result);
+  }
 }
 
 
 DEFINE_NATIVE_ENTRY(Double_pow, 2) {
   const double operand =
       Double::CheckedHandle(arguments->NativeArgAt(0)).value();
   GET_NON_NULL_NATIVE_ARGUMENT(
       Double, exponent_object, arguments->NativeArgAt(1));
   const double exponent = exponent_object.value();
   return Double::New(pow(operand, exponent));
 }
 
 
 #if defined(TARGET_OS_MACOS)
 // MAC OSX math library produces old style cast warning.
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 
-DEFINE_NATIVE_ENTRY(Double_toInt, 1) {
-  const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0));
-  if (isinf(arg.value()) || isnan(arg.value())) {
-    const Array& args = Array::Handle(Array::New(1));
-    args.SetAt(0, String::Handle(String::New("Infinity or NaN toInt")));
-    Exceptions::ThrowByType(Exceptions::kFormat, args);
-  }
-  double result = trunc(arg.value());
-  if ((Smi::kMinValue <= result) && (result <= Smi::kMaxValue)) {
-    return Smi::New(static_cast<intptr_t>(result));
-  } else if ((Mint::kMinValue <= result) && (result <= Mint::kMaxValue)) {
-    return Mint::New(static_cast<int64_t>(result));
-  } else {
-    return BigintOperations::NewFromDouble(result);
-  }
-}
-
-
 DEFINE_NATIVE_ENTRY(Double_parse, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(String, value, arguments->NativeArgAt(0));
   const String& dummy_key = String::Handle(Symbols::Empty());
   Scanner scanner(value, dummy_key);
   const Scanner::GrowableTokenStream& tokens = scanner.GetStream();
   String* number_string;
   bool is_positive;
   if (Scanner::IsValidLiteral(tokens,
                               Token::kDOUBLE,
                               &is_positive,
@@ skipping 113 matching lines @@
 
 DEFINE_NATIVE_ENTRY(Double_getIsNegative, 1) {
   const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0));
   // Include negative zero, infinity.
   return Bool::Get(signbit(arg.value()) && !isnan(arg.value()));
 }
 
 // Add here only functions using/referring to old-style casts.
 
 }  // namespace dart