OLD | NEW |
1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "vm/bootstrap_natives.h" | 5 #include "vm/bootstrap_natives.h" |
6 | 6 |
7 #include "platform/math.h" | 7 #include "platform/math.h" |
8 | 8 |
9 #include "vm/dart_entry.h" | 9 #include "vm/dart_entry.h" |
10 #include "vm/double_conversion.h" | 10 #include "vm/double_conversion.h" |
(...skipping 10 matching lines...) Expand all Loading... |
21 | 21 |
22 DEFINE_NATIVE_ENTRY(Double_doubleFromInteger, 2) { | 22 DEFINE_NATIVE_ENTRY(Double_doubleFromInteger, 2) { |
23 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); | 23 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); |
24 const Integer& value = Integer::CheckedHandle(arguments->NativeArgAt(1)); | 24 const Integer& value = Integer::CheckedHandle(arguments->NativeArgAt(1)); |
25 if (FLAG_trace_intrinsified_natives) { | 25 if (FLAG_trace_intrinsified_natives) { |
26 OS::Print("Double_doubleFromInteger %s\n", value.ToCString()); | 26 OS::Print("Double_doubleFromInteger %s\n", value.ToCString()); |
27 } | 27 } |
28 return Double::New(value.AsDoubleValue()); | 28 return Double::New(value.AsDoubleValue()); |
29 } | 29 } |
30 | 30 |
31 | |
32 DEFINE_NATIVE_ENTRY(Double_add, 2) { | 31 DEFINE_NATIVE_ENTRY(Double_add, 2) { |
33 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 32 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
34 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 33 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
35 double right = right_object.value(); | 34 double right = right_object.value(); |
36 if (FLAG_trace_intrinsified_natives) { | 35 if (FLAG_trace_intrinsified_natives) { |
37 OS::Print("Double_add %f + %f\n", left, right); | 36 OS::Print("Double_add %f + %f\n", left, right); |
38 } | 37 } |
39 return Double::New(left + right); | 38 return Double::New(left + right); |
40 } | 39 } |
41 | 40 |
42 | |
43 DEFINE_NATIVE_ENTRY(Double_sub, 2) { | 41 DEFINE_NATIVE_ENTRY(Double_sub, 2) { |
44 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 42 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
45 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 43 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
46 double right = right_object.value(); | 44 double right = right_object.value(); |
47 if (FLAG_trace_intrinsified_natives) { | 45 if (FLAG_trace_intrinsified_natives) { |
48 OS::Print("Double_sub %f - %f\n", left, right); | 46 OS::Print("Double_sub %f - %f\n", left, right); |
49 } | 47 } |
50 return Double::New(left - right); | 48 return Double::New(left - right); |
51 } | 49 } |
52 | 50 |
53 | |
54 DEFINE_NATIVE_ENTRY(Double_mul, 2) { | 51 DEFINE_NATIVE_ENTRY(Double_mul, 2) { |
55 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 52 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
56 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 53 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
57 double right = right_object.value(); | 54 double right = right_object.value(); |
58 if (FLAG_trace_intrinsified_natives) { | 55 if (FLAG_trace_intrinsified_natives) { |
59 OS::Print("Double_mul %f * %f\n", left, right); | 56 OS::Print("Double_mul %f * %f\n", left, right); |
60 } | 57 } |
61 return Double::New(left * right); | 58 return Double::New(left * right); |
62 } | 59 } |
63 | 60 |
64 | |
65 DEFINE_NATIVE_ENTRY(Double_div, 2) { | 61 DEFINE_NATIVE_ENTRY(Double_div, 2) { |
66 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 62 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
67 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 63 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
68 double right = right_object.value(); | 64 double right = right_object.value(); |
69 if (FLAG_trace_intrinsified_natives) { | 65 if (FLAG_trace_intrinsified_natives) { |
70 OS::Print("Double_div %f / %f\n", left, right); | 66 OS::Print("Double_div %f / %f\n", left, right); |
71 } | 67 } |
72 return Double::New(left / right); | 68 return Double::New(left / right); |
73 } | 69 } |
74 | 70 |
75 | |
76 static RawInteger* DoubleToInteger(double val, const char* error_msg) { | 71 static RawInteger* DoubleToInteger(double val, const char* error_msg) { |
77 if (isinf(val) || isnan(val)) { | 72 if (isinf(val) || isnan(val)) { |
78 const Array& args = Array::Handle(Array::New(1)); | 73 const Array& args = Array::Handle(Array::New(1)); |
79 args.SetAt(0, String::Handle(String::New(error_msg))); | 74 args.SetAt(0, String::Handle(String::New(error_msg))); |
80 Exceptions::ThrowByType(Exceptions::kUnsupported, args); | 75 Exceptions::ThrowByType(Exceptions::kUnsupported, args); |
81 } | 76 } |
82 if (FLAG_limit_ints_to_64_bits) { | 77 if (FLAG_limit_ints_to_64_bits) { |
83 // TODO(alexmarkov): decide on the double-to-integer conversion semantics | 78 // TODO(alexmarkov): decide on the double-to-integer conversion semantics |
84 // in truncating mode. | 79 // in truncating mode. |
85 int64_t ival = 0; | 80 int64_t ival = 0; |
(...skipping 30 matching lines...) Expand all Loading... |
116 } | 111 } |
117 if (exponent == 0) { | 112 if (exponent == 0) { |
118 // The double fits in a Smi or Mint. | 113 // The double fits in a Smi or Mint. |
119 return Integer::New(ival); | 114 return Integer::New(ival); |
120 } | 115 } |
121 Integer& result = Integer::Handle(); | 116 Integer& result = Integer::Handle(); |
122 result = Bigint::NewFromShiftedInt64(ival, exponent); | 117 result = Bigint::NewFromShiftedInt64(ival, exponent); |
123 return result.AsValidInteger(); | 118 return result.AsValidInteger(); |
124 } | 119 } |
125 | 120 |
126 | |
127 DEFINE_NATIVE_ENTRY(Double_trunc_div, 2) { | 121 DEFINE_NATIVE_ENTRY(Double_trunc_div, 2) { |
128 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 122 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
129 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 123 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
130 double right = right_object.value(); | 124 double right = right_object.value(); |
131 if (FLAG_trace_intrinsified_natives) { | 125 if (FLAG_trace_intrinsified_natives) { |
132 OS::Print("Double_trunc_div %f ~/ %f\n", left, right); | 126 OS::Print("Double_trunc_div %f ~/ %f\n", left, right); |
133 } | 127 } |
134 return DoubleToInteger(trunc(left / right), | 128 return DoubleToInteger(trunc(left / right), |
135 "Result of truncating division is Infinity or NaN"); | 129 "Result of truncating division is Infinity or NaN"); |
136 } | 130 } |
137 | 131 |
138 | |
139 DEFINE_NATIVE_ENTRY(Double_modulo, 2) { | 132 DEFINE_NATIVE_ENTRY(Double_modulo, 2) { |
140 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 133 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
141 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 134 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
142 double right = right_object.value(); | 135 double right = right_object.value(); |
143 return Double::New(DartModulo(left, right)); | 136 return Double::New(DartModulo(left, right)); |
144 } | 137 } |
145 | 138 |
146 | |
147 DEFINE_NATIVE_ENTRY(Double_remainder, 2) { | 139 DEFINE_NATIVE_ENTRY(Double_remainder, 2) { |
148 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 140 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
149 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 141 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
150 double right = right_object.value(); | 142 double right = right_object.value(); |
151 return Double::New(fmod_ieee(left, right)); | 143 return Double::New(fmod_ieee(left, right)); |
152 } | 144 } |
153 | 145 |
154 | |
155 DEFINE_NATIVE_ENTRY(Double_greaterThan, 2) { | 146 DEFINE_NATIVE_ENTRY(Double_greaterThan, 2) { |
156 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); | 147 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); |
157 GET_NON_NULL_NATIVE_ARGUMENT(Double, right, arguments->NativeArgAt(1)); | 148 GET_NON_NULL_NATIVE_ARGUMENT(Double, right, arguments->NativeArgAt(1)); |
158 bool result = right.IsNull() ? false : (left.value() > right.value()); | 149 bool result = right.IsNull() ? false : (left.value() > right.value()); |
159 if (FLAG_trace_intrinsified_natives) { | 150 if (FLAG_trace_intrinsified_natives) { |
160 OS::Print("Double_greaterThan %s > %s\n", left.ToCString(), | 151 OS::Print("Double_greaterThan %s > %s\n", left.ToCString(), |
161 right.ToCString()); | 152 right.ToCString()); |
162 } | 153 } |
163 return Bool::Get(result).raw(); | 154 return Bool::Get(result).raw(); |
164 } | 155 } |
165 | 156 |
166 | |
167 DEFINE_NATIVE_ENTRY(Double_greaterThanFromInteger, 2) { | 157 DEFINE_NATIVE_ENTRY(Double_greaterThanFromInteger, 2) { |
168 const Double& right = Double::CheckedHandle(arguments->NativeArgAt(0)); | 158 const Double& right = Double::CheckedHandle(arguments->NativeArgAt(0)); |
169 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); | 159 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); |
170 return Bool::Get(left.AsDoubleValue() > right.value()).raw(); | 160 return Bool::Get(left.AsDoubleValue() > right.value()).raw(); |
171 } | 161 } |
172 | 162 |
173 | |
174 DEFINE_NATIVE_ENTRY(Double_equal, 2) { | 163 DEFINE_NATIVE_ENTRY(Double_equal, 2) { |
175 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); | 164 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); |
176 GET_NON_NULL_NATIVE_ARGUMENT(Double, right, arguments->NativeArgAt(1)); | 165 GET_NON_NULL_NATIVE_ARGUMENT(Double, right, arguments->NativeArgAt(1)); |
177 bool result = right.IsNull() ? false : (left.value() == right.value()); | 166 bool result = right.IsNull() ? false : (left.value() == right.value()); |
178 if (FLAG_trace_intrinsified_natives) { | 167 if (FLAG_trace_intrinsified_natives) { |
179 OS::Print("Double_equal %s == %s\n", left.ToCString(), right.ToCString()); | 168 OS::Print("Double_equal %s == %s\n", left.ToCString(), right.ToCString()); |
180 } | 169 } |
181 return Bool::Get(result).raw(); | 170 return Bool::Get(result).raw(); |
182 } | 171 } |
183 | 172 |
184 | |
185 DEFINE_NATIVE_ENTRY(Double_equalToInteger, 2) { | 173 DEFINE_NATIVE_ENTRY(Double_equalToInteger, 2) { |
186 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); | 174 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); |
187 GET_NON_NULL_NATIVE_ARGUMENT(Integer, right, arguments->NativeArgAt(1)); | 175 GET_NON_NULL_NATIVE_ARGUMENT(Integer, right, arguments->NativeArgAt(1)); |
188 return Bool::Get(left.value() == right.AsDoubleValue()).raw(); | 176 return Bool::Get(left.value() == right.AsDoubleValue()).raw(); |
189 } | 177 } |
190 | 178 |
191 | |
192 DEFINE_NATIVE_ENTRY(Double_round, 1) { | 179 DEFINE_NATIVE_ENTRY(Double_round, 1) { |
193 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 180 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
194 return Double::New(round(arg.value())); | 181 return Double::New(round(arg.value())); |
195 } | 182 } |
196 | 183 |
197 DEFINE_NATIVE_ENTRY(Double_floor, 1) { | 184 DEFINE_NATIVE_ENTRY(Double_floor, 1) { |
198 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 185 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
199 return Double::New(floor(arg.value())); | 186 return Double::New(floor(arg.value())); |
200 } | 187 } |
201 | 188 |
202 DEFINE_NATIVE_ENTRY(Double_ceil, 1) { | 189 DEFINE_NATIVE_ENTRY(Double_ceil, 1) { |
203 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 190 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
204 return Double::New(ceil(arg.value())); | 191 return Double::New(ceil(arg.value())); |
205 } | 192 } |
206 | 193 |
207 | |
208 DEFINE_NATIVE_ENTRY(Double_truncate, 1) { | 194 DEFINE_NATIVE_ENTRY(Double_truncate, 1) { |
209 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 195 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
210 return Double::New(trunc(arg.value())); | 196 return Double::New(trunc(arg.value())); |
211 } | 197 } |
212 | 198 |
213 | |
214 #if defined(HOST_OS_MACOS) | 199 #if defined(HOST_OS_MACOS) |
215 // MAC OSX math library produces old style cast warning. | 200 // MAC OSX math library produces old style cast warning. |
216 #pragma GCC diagnostic ignored "-Wold-style-cast" | 201 #pragma GCC diagnostic ignored "-Wold-style-cast" |
217 #endif | 202 #endif |
218 | 203 |
219 DEFINE_NATIVE_ENTRY(Double_toInt, 1) { | 204 DEFINE_NATIVE_ENTRY(Double_toInt, 1) { |
220 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 205 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
221 return DoubleToInteger(arg.value(), "Infinity or NaN toInt"); | 206 return DoubleToInteger(arg.value(), "Infinity or NaN toInt"); |
222 } | 207 } |
223 | 208 |
224 | |
225 DEFINE_NATIVE_ENTRY(Double_parse, 3) { | 209 DEFINE_NATIVE_ENTRY(Double_parse, 3) { |
226 GET_NON_NULL_NATIVE_ARGUMENT(String, value, arguments->NativeArgAt(0)); | 210 GET_NON_NULL_NATIVE_ARGUMENT(String, value, arguments->NativeArgAt(0)); |
227 GET_NON_NULL_NATIVE_ARGUMENT(Integer, startValue, arguments->NativeArgAt(1)); | 211 GET_NON_NULL_NATIVE_ARGUMENT(Integer, startValue, arguments->NativeArgAt(1)); |
228 GET_NON_NULL_NATIVE_ARGUMENT(Integer, endValue, arguments->NativeArgAt(2)); | 212 GET_NON_NULL_NATIVE_ARGUMENT(Integer, endValue, arguments->NativeArgAt(2)); |
229 | 213 |
230 const intptr_t start = startValue.AsTruncatedUint32Value(); | 214 const intptr_t start = startValue.AsTruncatedUint32Value(); |
231 const intptr_t end = endValue.AsTruncatedUint32Value(); | 215 const intptr_t end = endValue.AsTruncatedUint32Value(); |
232 const intptr_t len = value.Length(); | 216 const intptr_t len = value.Length(); |
233 | 217 |
234 // Indices should be inside the string, and 0 <= start < end <= len. | 218 // Indices should be inside the string, and 0 <= start < end <= len. |
235 if (0 <= start && start < end && end <= len) { | 219 if (0 <= start && start < end && end <= len) { |
236 double double_value; | 220 double double_value; |
237 if (String::ParseDouble(value, start, end, &double_value)) { | 221 if (String::ParseDouble(value, start, end, &double_value)) { |
238 return Double::New(double_value); | 222 return Double::New(double_value); |
239 } | 223 } |
240 } | 224 } |
241 return Object::null(); | 225 return Object::null(); |
242 } | 226 } |
243 | 227 |
244 | |
245 DEFINE_NATIVE_ENTRY(Double_toString, 1) { | 228 DEFINE_NATIVE_ENTRY(Double_toString, 1) { |
246 const Number& number = Number::CheckedHandle(arguments->NativeArgAt(0)); | 229 const Number& number = Number::CheckedHandle(arguments->NativeArgAt(0)); |
247 return number.ToString(Heap::kNew); | 230 return number.ToString(Heap::kNew); |
248 } | 231 } |
249 | 232 |
250 | |
251 DEFINE_NATIVE_ENTRY(Double_toStringAsFixed, 2) { | 233 DEFINE_NATIVE_ENTRY(Double_toStringAsFixed, 2) { |
252 // The boundaries are exclusive. | 234 // The boundaries are exclusive. |
253 static const double kLowerBoundary = -1e21; | 235 static const double kLowerBoundary = -1e21; |
254 static const double kUpperBoundary = 1e21; | 236 static const double kUpperBoundary = 1e21; |
255 | 237 |
256 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 238 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
257 GET_NON_NULL_NATIVE_ARGUMENT(Smi, fraction_digits, arguments->NativeArgAt(1)); | 239 GET_NON_NULL_NATIVE_ARGUMENT(Smi, fraction_digits, arguments->NativeArgAt(1)); |
258 double d = arg.value(); | 240 double d = arg.value(); |
259 intptr_t fraction_digits_value = fraction_digits.Value(); | 241 intptr_t fraction_digits_value = fraction_digits.Value(); |
260 if (0 <= fraction_digits_value && fraction_digits_value <= 20 && | 242 if (0 <= fraction_digits_value && fraction_digits_value <= 20 && |
261 kLowerBoundary < d && d < kUpperBoundary) { | 243 kLowerBoundary < d && d < kUpperBoundary) { |
262 return DoubleToStringAsFixed(d, static_cast<int>(fraction_digits_value)); | 244 return DoubleToStringAsFixed(d, static_cast<int>(fraction_digits_value)); |
263 } else { | 245 } else { |
264 Exceptions::ThrowArgumentError(String::Handle( | 246 Exceptions::ThrowArgumentError(String::Handle( |
265 String::New("Illegal arguments to double.toStringAsFixed"))); | 247 String::New("Illegal arguments to double.toStringAsFixed"))); |
266 return Object::null(); | 248 return Object::null(); |
267 } | 249 } |
268 } | 250 } |
269 | 251 |
270 | |
271 DEFINE_NATIVE_ENTRY(Double_toStringAsExponential, 2) { | 252 DEFINE_NATIVE_ENTRY(Double_toStringAsExponential, 2) { |
272 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 253 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
273 GET_NON_NULL_NATIVE_ARGUMENT(Smi, fraction_digits, arguments->NativeArgAt(1)); | 254 GET_NON_NULL_NATIVE_ARGUMENT(Smi, fraction_digits, arguments->NativeArgAt(1)); |
274 double d = arg.value(); | 255 double d = arg.value(); |
275 intptr_t fraction_digits_value = fraction_digits.Value(); | 256 intptr_t fraction_digits_value = fraction_digits.Value(); |
276 if (-1 <= fraction_digits_value && fraction_digits_value <= 20) { | 257 if (-1 <= fraction_digits_value && fraction_digits_value <= 20) { |
277 return DoubleToStringAsExponential(d, | 258 return DoubleToStringAsExponential(d, |
278 static_cast<int>(fraction_digits_value)); | 259 static_cast<int>(fraction_digits_value)); |
279 } else { | 260 } else { |
280 Exceptions::ThrowArgumentError(String::Handle( | 261 Exceptions::ThrowArgumentError(String::Handle( |
281 String::New("Illegal arguments to double.toStringAsExponential"))); | 262 String::New("Illegal arguments to double.toStringAsExponential"))); |
282 return Object::null(); | 263 return Object::null(); |
283 } | 264 } |
284 } | 265 } |
285 | 266 |
286 | |
287 DEFINE_NATIVE_ENTRY(Double_toStringAsPrecision, 2) { | 267 DEFINE_NATIVE_ENTRY(Double_toStringAsPrecision, 2) { |
288 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 268 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
289 GET_NON_NULL_NATIVE_ARGUMENT(Smi, precision, arguments->NativeArgAt(1)); | 269 GET_NON_NULL_NATIVE_ARGUMENT(Smi, precision, arguments->NativeArgAt(1)); |
290 double d = arg.value(); | 270 double d = arg.value(); |
291 intptr_t precision_value = precision.Value(); | 271 intptr_t precision_value = precision.Value(); |
292 if (1 <= precision_value && precision_value <= 21) { | 272 if (1 <= precision_value && precision_value <= 21) { |
293 return DoubleToStringAsPrecision(d, static_cast<int>(precision_value)); | 273 return DoubleToStringAsPrecision(d, static_cast<int>(precision_value)); |
294 } else { | 274 } else { |
295 Exceptions::ThrowArgumentError(String::Handle( | 275 Exceptions::ThrowArgumentError(String::Handle( |
296 String::New("Illegal arguments to double.toStringAsPrecision"))); | 276 String::New("Illegal arguments to double.toStringAsPrecision"))); |
297 return Object::null(); | 277 return Object::null(); |
298 } | 278 } |
299 } | 279 } |
300 | 280 |
301 | |
302 DEFINE_NATIVE_ENTRY(Double_getIsInfinite, 1) { | 281 DEFINE_NATIVE_ENTRY(Double_getIsInfinite, 1) { |
303 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 282 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
304 return Bool::Get(isinf(arg.value())).raw(); | 283 return Bool::Get(isinf(arg.value())).raw(); |
305 } | 284 } |
306 | 285 |
307 | |
308 DEFINE_NATIVE_ENTRY(Double_getIsNaN, 1) { | 286 DEFINE_NATIVE_ENTRY(Double_getIsNaN, 1) { |
309 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 287 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
310 return Bool::Get(isnan(arg.value())).raw(); | 288 return Bool::Get(isnan(arg.value())).raw(); |
311 } | 289 } |
312 | 290 |
313 | |
314 DEFINE_NATIVE_ENTRY(Double_getIsNegative, 1) { | 291 DEFINE_NATIVE_ENTRY(Double_getIsNegative, 1) { |
315 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 292 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
316 // Include negative zero, infinity. | 293 // Include negative zero, infinity. |
317 double dval = arg.value(); | 294 double dval = arg.value(); |
318 return Bool::Get(signbit(dval) && !isnan(dval)).raw(); | 295 return Bool::Get(signbit(dval) && !isnan(dval)).raw(); |
319 } | 296 } |
320 | 297 |
321 | |
322 DEFINE_NATIVE_ENTRY(Double_flipSignBit, 1) { | 298 DEFINE_NATIVE_ENTRY(Double_flipSignBit, 1) { |
323 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 299 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
324 const double in_val = arg.value(); | 300 const double in_val = arg.value(); |
325 const int64_t bits = bit_cast<int64_t, double>(in_val) ^ kSignBitDouble; | 301 const int64_t bits = bit_cast<int64_t, double>(in_val) ^ kSignBitDouble; |
326 return Double::New(bit_cast<double, int64_t>(bits)); | 302 return Double::New(bit_cast<double, int64_t>(bits)); |
327 } | 303 } |
328 | 304 |
329 // Add here only functions using/referring to old-style casts. | 305 // Add here only functions using/referring to old-style casts. |
330 | 306 |
331 } // namespace dart | 307 } // namespace dart |
OLD | NEW |