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 <math.h> | 5 #include <math.h> |
6 | 6 |
7 #include "vm/bootstrap_natives.h" | 7 #include "vm/bootstrap_natives.h" |
8 | 8 |
9 #include "vm/bigint_operations.h" | 9 #include "vm/bigint_operations.h" |
10 #include "vm/double_conversion.h" | 10 #include "vm/double_conversion.h" |
(...skipping 12 matching lines...) Expand all Loading... |
23 const Integer& value = Integer::CheckedHandle(arguments->NativeArgAt(1)); | 23 const Integer& value = Integer::CheckedHandle(arguments->NativeArgAt(1)); |
24 if (FLAG_trace_intrinsified_natives) { | 24 if (FLAG_trace_intrinsified_natives) { |
25 OS::Print("Double_doubleFromInteger %s\n", value.ToCString()); | 25 OS::Print("Double_doubleFromInteger %s\n", value.ToCString()); |
26 } | 26 } |
27 return Double::New(value.AsDoubleValue()); | 27 return Double::New(value.AsDoubleValue()); |
28 } | 28 } |
29 | 29 |
30 | 30 |
31 DEFINE_NATIVE_ENTRY(Double_add, 2) { | 31 DEFINE_NATIVE_ENTRY(Double_add, 2) { |
32 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 32 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
33 GET_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 33 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
34 double right = right_object.value(); | 34 double right = right_object.value(); |
35 if (FLAG_trace_intrinsified_natives) { | 35 if (FLAG_trace_intrinsified_natives) { |
36 OS::Print("Double_add %f + %f\n", left, right); | 36 OS::Print("Double_add %f + %f\n", left, right); |
37 } | 37 } |
38 return Double::New(left + right); | 38 return Double::New(left + right); |
39 } | 39 } |
40 | 40 |
41 | 41 |
42 DEFINE_NATIVE_ENTRY(Double_sub, 2) { | 42 DEFINE_NATIVE_ENTRY(Double_sub, 2) { |
43 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 43 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
44 GET_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 44 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
45 double right = right_object.value(); | 45 double right = right_object.value(); |
46 if (FLAG_trace_intrinsified_natives) { | 46 if (FLAG_trace_intrinsified_natives) { |
47 OS::Print("Double_sub %f - %f\n", left, right); | 47 OS::Print("Double_sub %f - %f\n", left, right); |
48 } | 48 } |
49 return Double::New(left - right); | 49 return Double::New(left - right); |
50 } | 50 } |
51 | 51 |
52 | 52 |
53 DEFINE_NATIVE_ENTRY(Double_mul, 2) { | 53 DEFINE_NATIVE_ENTRY(Double_mul, 2) { |
54 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 54 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
55 GET_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 55 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
56 double right = right_object.value(); | 56 double right = right_object.value(); |
57 if (FLAG_trace_intrinsified_natives) { | 57 if (FLAG_trace_intrinsified_natives) { |
58 OS::Print("Double_mul %f * %f\n", left, right); | 58 OS::Print("Double_mul %f * %f\n", left, right); |
59 } | 59 } |
60 return Double::New(left * right); | 60 return Double::New(left * right); |
61 } | 61 } |
62 | 62 |
63 | 63 |
64 DEFINE_NATIVE_ENTRY(Double_div, 2) { | 64 DEFINE_NATIVE_ENTRY(Double_div, 2) { |
65 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 65 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
66 GET_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 66 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
67 double right = right_object.value(); | 67 double right = right_object.value(); |
68 if (FLAG_trace_intrinsified_natives) { | 68 if (FLAG_trace_intrinsified_natives) { |
69 OS::Print("Double_div %f / %f\n", left, right); | 69 OS::Print("Double_div %f / %f\n", left, right); |
70 } | 70 } |
71 return Double::New(left / right); | 71 return Double::New(left / right); |
72 } | 72 } |
73 | 73 |
74 | 74 |
75 DEFINE_NATIVE_ENTRY(Double_trunc_div, 2) { | 75 DEFINE_NATIVE_ENTRY(Double_trunc_div, 2) { |
76 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 76 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
77 GET_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 77 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
78 double right = right_object.value(); | 78 double right = right_object.value(); |
79 if (FLAG_trace_intrinsified_natives) { | 79 if (FLAG_trace_intrinsified_natives) { |
80 OS::Print("Double_trunc_div %f ~/ %f\n", left, right); | 80 OS::Print("Double_trunc_div %f ~/ %f\n", left, right); |
81 } | 81 } |
82 return Double::New(trunc(left / right)); | 82 return Double::New(trunc(left / right)); |
83 } | 83 } |
84 | 84 |
85 | 85 |
86 DEFINE_NATIVE_ENTRY(Double_modulo, 2) { | 86 DEFINE_NATIVE_ENTRY(Double_modulo, 2) { |
87 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 87 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
88 GET_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 88 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
89 double right = right_object.value(); | 89 double right = right_object.value(); |
90 | 90 |
91 double remainder = fmod_ieee(left, right); | 91 double remainder = fmod_ieee(left, right); |
92 if (remainder == 0.0) { | 92 if (remainder == 0.0) { |
93 // We explicitely switch to the positive 0.0 (just in case it was negative). | 93 // We explicitely switch to the positive 0.0 (just in case it was negative). |
94 remainder = +0.0; | 94 remainder = +0.0; |
95 } else if (remainder < 0) { | 95 } else if (remainder < 0) { |
96 if (right < 0) { | 96 if (right < 0) { |
97 remainder -= right; | 97 remainder -= right; |
98 } else { | 98 } else { |
99 remainder += right; | 99 remainder += right; |
100 } | 100 } |
101 } | 101 } |
102 return Double::New(remainder); | 102 return Double::New(remainder); |
103 } | 103 } |
104 | 104 |
105 | 105 |
106 DEFINE_NATIVE_ENTRY(Double_remainder, 2) { | 106 DEFINE_NATIVE_ENTRY(Double_remainder, 2) { |
107 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 107 double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
108 GET_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); | 108 GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1)); |
109 double right = right_object.value(); | 109 double right = right_object.value(); |
110 return Double::New(fmod_ieee(left, right)); | 110 return Double::New(fmod_ieee(left, right)); |
111 } | 111 } |
112 | 112 |
113 | 113 |
114 DEFINE_NATIVE_ENTRY(Double_greaterThan, 2) { | 114 DEFINE_NATIVE_ENTRY(Double_greaterThan, 2) { |
115 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); | 115 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); |
116 GET_NATIVE_ARGUMENT(Double, right, arguments->NativeArgAt(1)); | 116 GET_NON_NULL_NATIVE_ARGUMENT(Double, right, arguments->NativeArgAt(1)); |
117 bool result = right.IsNull() ? false : (left.value() > right.value()); | 117 bool result = right.IsNull() ? false : (left.value() > right.value()); |
118 if (FLAG_trace_intrinsified_natives) { | 118 if (FLAG_trace_intrinsified_natives) { |
119 OS::Print("Double_greaterThan %s > %s\n", | 119 OS::Print("Double_greaterThan %s > %s\n", |
120 left.ToCString(), right.ToCString()); | 120 left.ToCString(), right.ToCString()); |
121 } | 121 } |
122 return Bool::Get(result); | 122 return Bool::Get(result); |
123 } | 123 } |
124 | 124 |
125 | 125 |
126 DEFINE_NATIVE_ENTRY(Double_greaterThanFromInteger, 2) { | 126 DEFINE_NATIVE_ENTRY(Double_greaterThanFromInteger, 2) { |
127 const Double& right = Double::CheckedHandle(arguments->NativeArgAt(0)); | 127 const Double& right = Double::CheckedHandle(arguments->NativeArgAt(0)); |
128 GET_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); | 128 GET_NON_NULL_NATIVE_ARGUMENT(Integer, left, arguments->NativeArgAt(1)); |
129 return Bool::Get(left.AsDoubleValue() > right.value()); | 129 return Bool::Get(left.AsDoubleValue() > right.value()); |
130 } | 130 } |
131 | 131 |
132 | 132 |
133 DEFINE_NATIVE_ENTRY(Double_equal, 2) { | 133 DEFINE_NATIVE_ENTRY(Double_equal, 2) { |
134 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); | 134 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); |
135 GET_NATIVE_ARGUMENT(Double, right, arguments->NativeArgAt(1)); | 135 GET_NON_NULL_NATIVE_ARGUMENT(Double, right, arguments->NativeArgAt(1)); |
136 bool result = right.IsNull() ? false : (left.value() == right.value()); | 136 bool result = right.IsNull() ? false : (left.value() == right.value()); |
137 if (FLAG_trace_intrinsified_natives) { | 137 if (FLAG_trace_intrinsified_natives) { |
138 OS::Print("Double_equal %s == %s\n", | 138 OS::Print("Double_equal %s == %s\n", |
139 left.ToCString(), right.ToCString()); | 139 left.ToCString(), right.ToCString()); |
140 } | 140 } |
141 return Bool::Get(result); | 141 return Bool::Get(result); |
142 } | 142 } |
143 | 143 |
144 | 144 |
145 DEFINE_NATIVE_ENTRY(Double_equalToInteger, 2) { | 145 DEFINE_NATIVE_ENTRY(Double_equalToInteger, 2) { |
146 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); | 146 const Double& left = Double::CheckedHandle(arguments->NativeArgAt(0)); |
147 GET_NATIVE_ARGUMENT(Integer, right, arguments->NativeArgAt(1)); | 147 GET_NON_NULL_NATIVE_ARGUMENT(Integer, right, arguments->NativeArgAt(1)); |
148 return Bool::Get(left.value() == right.AsDoubleValue()); | 148 return Bool::Get(left.value() == right.AsDoubleValue()); |
149 } | 149 } |
150 | 150 |
151 | 151 |
152 DEFINE_NATIVE_ENTRY(Double_round, 1) { | 152 DEFINE_NATIVE_ENTRY(Double_round, 1) { |
153 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 153 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
154 return Double::New(round(arg.value())); | 154 return Double::New(round(arg.value())); |
155 } | 155 } |
156 | 156 |
157 DEFINE_NATIVE_ENTRY(Double_floor, 1) { | 157 DEFINE_NATIVE_ENTRY(Double_floor, 1) { |
158 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 158 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
159 return Double::New(floor(arg.value())); | 159 return Double::New(floor(arg.value())); |
160 } | 160 } |
161 | 161 |
162 DEFINE_NATIVE_ENTRY(Double_ceil, 1) { | 162 DEFINE_NATIVE_ENTRY(Double_ceil, 1) { |
163 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 163 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
164 return Double::New(ceil(arg.value())); | 164 return Double::New(ceil(arg.value())); |
165 } | 165 } |
166 | 166 |
167 | 167 |
168 DEFINE_NATIVE_ENTRY(Double_truncate, 1) { | 168 DEFINE_NATIVE_ENTRY(Double_truncate, 1) { |
169 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 169 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
170 return Double::New(trunc(arg.value())); | 170 return Double::New(trunc(arg.value())); |
171 } | 171 } |
172 | 172 |
173 | 173 |
174 DEFINE_NATIVE_ENTRY(Double_pow, 2) { | 174 DEFINE_NATIVE_ENTRY(Double_pow, 2) { |
175 const double operand = | 175 const double operand = |
176 Double::CheckedHandle(arguments->NativeArgAt(0)).value(); | 176 Double::CheckedHandle(arguments->NativeArgAt(0)).value(); |
177 GET_NATIVE_ARGUMENT(Double, exponent_object, arguments->NativeArgAt(1)); | 177 GET_NON_NULL_NATIVE_ARGUMENT( |
| 178 Double, exponent_object, arguments->NativeArgAt(1)); |
178 const double exponent = exponent_object.value(); | 179 const double exponent = exponent_object.value(); |
179 return Double::New(pow(operand, exponent)); | 180 return Double::New(pow(operand, exponent)); |
180 } | 181 } |
181 | 182 |
182 | 183 |
183 #if defined(TARGET_OS_MACOS) | 184 #if defined(TARGET_OS_MACOS) |
184 // MAC OSX math library produces old style cast warning. | 185 // MAC OSX math library produces old style cast warning. |
185 #pragma GCC diagnostic ignored "-Wold-style-cast" | 186 #pragma GCC diagnostic ignored "-Wold-style-cast" |
186 #endif | 187 #endif |
187 | 188 |
(...skipping 10 matching lines...) Expand all Loading... |
198 return Smi::New(static_cast<intptr_t>(result)); | 199 return Smi::New(static_cast<intptr_t>(result)); |
199 } else if ((Mint::kMinValue <= result) && (result <= Mint::kMaxValue)) { | 200 } else if ((Mint::kMinValue <= result) && (result <= Mint::kMaxValue)) { |
200 return Mint::New(static_cast<int64_t>(result)); | 201 return Mint::New(static_cast<int64_t>(result)); |
201 } else { | 202 } else { |
202 return BigintOperations::NewFromDouble(result); | 203 return BigintOperations::NewFromDouble(result); |
203 } | 204 } |
204 } | 205 } |
205 | 206 |
206 | 207 |
207 DEFINE_NATIVE_ENTRY(Double_parse, 1) { | 208 DEFINE_NATIVE_ENTRY(Double_parse, 1) { |
208 GET_NATIVE_ARGUMENT(String, value, arguments->NativeArgAt(0)); | 209 GET_NON_NULL_NATIVE_ARGUMENT(String, value, arguments->NativeArgAt(0)); |
209 const String& dummy_key = String::Handle(Symbols::Empty()); | 210 const String& dummy_key = String::Handle(Symbols::Empty()); |
210 Scanner scanner(value, dummy_key); | 211 Scanner scanner(value, dummy_key); |
211 const Scanner::GrowableTokenStream& tokens = scanner.GetStream(); | 212 const Scanner::GrowableTokenStream& tokens = scanner.GetStream(); |
212 String* number_string; | 213 String* number_string; |
213 bool is_positive; | 214 bool is_positive; |
214 if (Scanner::IsValidLiteral(tokens, | 215 if (Scanner::IsValidLiteral(tokens, |
215 Token::kDOUBLE, | 216 Token::kDOUBLE, |
216 &is_positive, | 217 &is_positive, |
217 &number_string)) { | 218 &number_string)) { |
218 const char* cstr = number_string->ToCString(); | 219 const char* cstr = number_string->ToCString(); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
258 return Object::null(); | 259 return Object::null(); |
259 } | 260 } |
260 | 261 |
261 | 262 |
262 DEFINE_NATIVE_ENTRY(Double_toStringAsFixed, 2) { | 263 DEFINE_NATIVE_ENTRY(Double_toStringAsFixed, 2) { |
263 // The boundaries are exclusive. | 264 // The boundaries are exclusive. |
264 static const double kLowerBoundary = -1e21; | 265 static const double kLowerBoundary = -1e21; |
265 static const double kUpperBoundary = 1e21; | 266 static const double kUpperBoundary = 1e21; |
266 | 267 |
267 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 268 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
268 GET_NATIVE_ARGUMENT(Smi, fraction_digits, arguments->NativeArgAt(1)); | 269 GET_NON_NULL_NATIVE_ARGUMENT(Smi, fraction_digits, arguments->NativeArgAt(1)); |
269 double d = arg.value(); | 270 double d = arg.value(); |
270 intptr_t fraction_digits_value = fraction_digits.Value(); | 271 intptr_t fraction_digits_value = fraction_digits.Value(); |
271 if (0 <= fraction_digits_value && fraction_digits_value <= 20 | 272 if (0 <= fraction_digits_value && fraction_digits_value <= 20 |
272 && kLowerBoundary < d && d < kUpperBoundary) { | 273 && kLowerBoundary < d && d < kUpperBoundary) { |
273 return DoubleToStringAsFixed(d, static_cast<int>(fraction_digits_value)); | 274 return DoubleToStringAsFixed(d, static_cast<int>(fraction_digits_value)); |
274 } else { | 275 } else { |
275 GrowableArray<const Object*> args; | 276 GrowableArray<const Object*> args; |
276 args.Add(&String::ZoneHandle(String::New( | 277 args.Add(&String::ZoneHandle(String::New( |
277 "Illegal arguments to double.toStringAsFixed"))); | 278 "Illegal arguments to double.toStringAsFixed"))); |
278 Exceptions::ThrowByType(Exceptions::kArgument, args); | 279 Exceptions::ThrowByType(Exceptions::kArgument, args); |
279 return Object::null(); | 280 return Object::null(); |
280 } | 281 } |
281 } | 282 } |
282 | 283 |
283 | 284 |
284 DEFINE_NATIVE_ENTRY(Double_toStringAsExponential, 2) { | 285 DEFINE_NATIVE_ENTRY(Double_toStringAsExponential, 2) { |
285 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 286 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
286 GET_NATIVE_ARGUMENT(Smi, fraction_digits, arguments->NativeArgAt(1)); | 287 GET_NON_NULL_NATIVE_ARGUMENT(Smi, fraction_digits, arguments->NativeArgAt(1)); |
287 double d = arg.value(); | 288 double d = arg.value(); |
288 intptr_t fraction_digits_value = fraction_digits.Value(); | 289 intptr_t fraction_digits_value = fraction_digits.Value(); |
289 if (-1 <= fraction_digits_value && fraction_digits_value <= 20) { | 290 if (-1 <= fraction_digits_value && fraction_digits_value <= 20) { |
290 return DoubleToStringAsExponential( | 291 return DoubleToStringAsExponential( |
291 d, static_cast<int>(fraction_digits_value)); | 292 d, static_cast<int>(fraction_digits_value)); |
292 } else { | 293 } else { |
293 GrowableArray<const Object*> args; | 294 GrowableArray<const Object*> args; |
294 args.Add(&String::ZoneHandle(String::New( | 295 args.Add(&String::ZoneHandle(String::New( |
295 "Illegal arguments to double.toStringAsExponential"))); | 296 "Illegal arguments to double.toStringAsExponential"))); |
296 Exceptions::ThrowByType(Exceptions::kArgument, args); | 297 Exceptions::ThrowByType(Exceptions::kArgument, args); |
297 return Object::null(); | 298 return Object::null(); |
298 } | 299 } |
299 } | 300 } |
300 | 301 |
301 | 302 |
302 DEFINE_NATIVE_ENTRY(Double_toStringAsPrecision, 2) { | 303 DEFINE_NATIVE_ENTRY(Double_toStringAsPrecision, 2) { |
303 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 304 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
304 GET_NATIVE_ARGUMENT(Smi, precision, arguments->NativeArgAt(1)); | 305 GET_NON_NULL_NATIVE_ARGUMENT(Smi, precision, arguments->NativeArgAt(1)); |
305 double d = arg.value(); | 306 double d = arg.value(); |
306 intptr_t precision_value = precision.Value(); | 307 intptr_t precision_value = precision.Value(); |
307 if (1 <= precision_value && precision_value <= 21) { | 308 if (1 <= precision_value && precision_value <= 21) { |
308 return DoubleToStringAsPrecision(d, static_cast<int>(precision_value)); | 309 return DoubleToStringAsPrecision(d, static_cast<int>(precision_value)); |
309 } else { | 310 } else { |
310 GrowableArray<const Object*> args; | 311 GrowableArray<const Object*> args; |
311 args.Add(&String::ZoneHandle(String::New( | 312 args.Add(&String::ZoneHandle(String::New( |
312 "Illegal arguments to double.toStringAsPrecision"))); | 313 "Illegal arguments to double.toStringAsPrecision"))); |
313 Exceptions::ThrowByType(Exceptions::kArgument, args); | 314 Exceptions::ThrowByType(Exceptions::kArgument, args); |
314 return Object::null(); | 315 return Object::null(); |
(...skipping 15 matching lines...) Expand all Loading... |
330 | 331 |
331 DEFINE_NATIVE_ENTRY(Double_getIsNegative, 1) { | 332 DEFINE_NATIVE_ENTRY(Double_getIsNegative, 1) { |
332 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); | 333 const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0)); |
333 // Include negative zero, infinity. | 334 // Include negative zero, infinity. |
334 return Bool::Get(signbit(arg.value()) && !isnan(arg.value())); | 335 return Bool::Get(signbit(arg.value()) && !isnan(arg.value())); |
335 } | 336 } |
336 | 337 |
337 // Add here only functions using/referring to old-style casts. | 338 // Add here only functions using/referring to old-style casts. |
338 | 339 |
339 } // namespace dart | 340 } // namespace dart |
OLD | NEW |