OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, 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 "vm/bigint_operations.h" | 7 #include "vm/bigint_operations.h" |
8 #include "vm/exceptions.h" | 8 #include "vm/exceptions.h" |
9 #include "vm/native_entry.h" | 9 #include "vm/native_entry.h" |
10 #include "vm/object.h" | 10 #include "vm/object.h" |
(...skipping 26 matching lines...) Expand all Loading... |
37 const String& error = String::Handle(String::NewFormatted( | 37 const String& error = String::Handle(String::NewFormatted( |
38 "length (%"Pd") must be in the range [0..%"Pd"]", len, max)); | 38 "length (%"Pd") must be in the range [0..%"Pd"]", len, max)); |
39 GrowableArray<const Object*> args; | 39 GrowableArray<const Object*> args; |
40 args.Add(&error); | 40 args.Add(&error); |
41 Exceptions::ThrowByType(Exceptions::kArgument, args); | 41 Exceptions::ThrowByType(Exceptions::kArgument, args); |
42 } | 42 } |
43 } | 43 } |
44 | 44 |
45 | 45 |
46 #define GETTER_ARGUMENTS(ArrayT, ValueT) \ | 46 #define GETTER_ARGUMENTS(ArrayT, ValueT) \ |
47 GET_NATIVE_ARGUMENT(ArrayT, array, arguments->At(0)); \ | 47 GET_NATIVE_ARGUMENT(ArrayT, array, arguments->NativeArgAt(0)); \ |
48 GET_NATIVE_ARGUMENT(Smi, index, arguments->At(1)); | 48 GET_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1)); |
49 | 49 |
50 | 50 |
51 #define SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT) \ | 51 #define SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT) \ |
52 GET_NATIVE_ARGUMENT(ArrayT, array, arguments->At(0)); \ | 52 GET_NATIVE_ARGUMENT(ArrayT, array, arguments->NativeArgAt(0)); \ |
53 GET_NATIVE_ARGUMENT(Smi, index, arguments->At(1)); \ | 53 GET_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1)); \ |
54 GET_NATIVE_ARGUMENT(ObjectT, value_object, arguments->At(2)); | 54 GET_NATIVE_ARGUMENT(ObjectT, value_object, arguments->NativeArgAt(2)); |
55 | 55 |
56 | 56 |
57 #define GETTER(ArrayT, ObjectT, ValueT) \ | 57 #define GETTER(ArrayT, ObjectT, ValueT) \ |
58 GETTER_ARGUMENTS(ArrayT, ValueT); \ | 58 GETTER_ARGUMENTS(ArrayT, ValueT); \ |
59 RangeCheck(array, index.Value() * sizeof(ValueT), sizeof(ValueT)); \ | 59 RangeCheck(array, index.Value() * sizeof(ValueT), sizeof(ValueT)); \ |
60 ValueT result = array.At(index.Value()); \ | 60 ValueT result = array.At(index.Value()); \ |
61 return ObjectT::New(result); | 61 return ObjectT::New(result); |
62 | 62 |
63 | 63 |
64 #define SETTER(ArrayT, ObjectT, Getter, ValueT) \ | 64 #define SETTER(ArrayT, ObjectT, Getter, ValueT) \ |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
140 #define UNALIGNED_SETTER_UINT64(ArrayT) \ | 140 #define UNALIGNED_SETTER_UINT64(ArrayT) \ |
141 SETTER_ARGUMENTS(ArrayT, Integer, uint64_t); \ | 141 SETTER_ARGUMENTS(ArrayT, Integer, uint64_t); \ |
142 RangeCheck(array, index.Value(), sizeof(uint64_t)); \ | 142 RangeCheck(array, index.Value(), sizeof(uint64_t)); \ |
143 uint64_t value; \ | 143 uint64_t value; \ |
144 INTEGER_TO_UINT64(value_object, value); \ | 144 INTEGER_TO_UINT64(value_object, value); \ |
145 ByteArray::Copy(array, index.Value(), &value, sizeof(uint64_t)); \ | 145 ByteArray::Copy(array, index.Value(), &value, sizeof(uint64_t)); \ |
146 return Integer::New(index.Value() + sizeof(uint64_t)); | 146 return Integer::New(index.Value() + sizeof(uint64_t)); |
147 | 147 |
148 | 148 |
149 DEFINE_NATIVE_ENTRY(ByteArray_getLength, 1) { | 149 DEFINE_NATIVE_ENTRY(ByteArray_getLength, 1) { |
150 GET_NATIVE_ARGUMENT(ByteArray, array, arguments->At(0)); | 150 GET_NATIVE_ARGUMENT(ByteArray, array, arguments->NativeArgAt(0)); |
151 return Smi::New(array.Length()); | 151 return Smi::New(array.Length()); |
152 } | 152 } |
153 | 153 |
154 | 154 |
155 DEFINE_NATIVE_ENTRY(ByteArray_getInt8, 2) { | 155 DEFINE_NATIVE_ENTRY(ByteArray_getInt8, 2) { |
156 UNALIGNED_GETTER(ByteArray, Smi, int8_t); | 156 UNALIGNED_GETTER(ByteArray, Smi, int8_t); |
157 } | 157 } |
158 | 158 |
159 | 159 |
160 DEFINE_NATIVE_ENTRY(ByteArray_setInt8, 3) { | 160 DEFINE_NATIVE_ENTRY(ByteArray_setInt8, 3) { |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
246 UNALIGNED_GETTER(ByteArray, Double, double); | 246 UNALIGNED_GETTER(ByteArray, Double, double); |
247 } | 247 } |
248 | 248 |
249 | 249 |
250 DEFINE_NATIVE_ENTRY(ByteArray_setFloat64, 3) { | 250 DEFINE_NATIVE_ENTRY(ByteArray_setFloat64, 3) { |
251 UNALIGNED_SETTER(ByteArray, Double, value, double); | 251 UNALIGNED_SETTER(ByteArray, Double, value, double); |
252 } | 252 } |
253 | 253 |
254 | 254 |
255 DEFINE_NATIVE_ENTRY(ByteArray_setRange, 5) { | 255 DEFINE_NATIVE_ENTRY(ByteArray_setRange, 5) { |
256 ByteArray& dst = ByteArray::CheckedHandle(arguments->At(0)); | 256 ByteArray& dst = ByteArray::CheckedHandle(arguments->NativeArgAt(0)); |
257 GET_NATIVE_ARGUMENT(Smi, dst_start, arguments->At(1)); | 257 GET_NATIVE_ARGUMENT(Smi, dst_start, arguments->NativeArgAt(1)); |
258 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(2)); | 258 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(2)); |
259 GET_NATIVE_ARGUMENT(ByteArray, src, arguments->At(3)); | 259 GET_NATIVE_ARGUMENT(ByteArray, src, arguments->NativeArgAt(3)); |
260 GET_NATIVE_ARGUMENT(Smi, src_start, arguments->At(4)); | 260 GET_NATIVE_ARGUMENT(Smi, src_start, arguments->NativeArgAt(4)); |
261 intptr_t length_value = length.Value(); | 261 intptr_t length_value = length.Value(); |
262 intptr_t src_start_value = src_start.Value(); | 262 intptr_t src_start_value = src_start.Value(); |
263 intptr_t dst_start_value = dst_start.Value(); | 263 intptr_t dst_start_value = dst_start.Value(); |
264 if (length_value < 0) { | 264 if (length_value < 0) { |
265 const String& error = String::Handle(String::NewFormatted( | 265 const String& error = String::Handle(String::NewFormatted( |
266 "length (%"Pd") must be non-negative", length_value)); | 266 "length (%"Pd") must be non-negative", length_value)); |
267 GrowableArray<const Object*> args; | 267 GrowableArray<const Object*> args; |
268 args.Add(&error); | 268 args.Add(&error); |
269 Exceptions::ThrowByType(Exceptions::kArgument, args); | 269 Exceptions::ThrowByType(Exceptions::kArgument, args); |
270 } | 270 } |
271 RangeCheck(src, src_start_value, length_value); | 271 RangeCheck(src, src_start_value, length_value); |
272 RangeCheck(dst, dst_start_value, length_value); | 272 RangeCheck(dst, dst_start_value, length_value); |
273 ByteArray::Copy(dst, dst_start_value, src, src_start_value, length_value); | 273 ByteArray::Copy(dst, dst_start_value, src, src_start_value, length_value); |
274 return Object::null(); | 274 return Object::null(); |
275 } | 275 } |
276 | 276 |
277 | 277 |
278 // Int8Array | 278 // Int8Array |
279 | 279 |
280 DEFINE_NATIVE_ENTRY(Int8Array_new, 1) { | 280 DEFINE_NATIVE_ENTRY(Int8Array_new, 1) { |
281 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(0)); | 281 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0)); |
282 intptr_t len = length.Value(); | 282 intptr_t len = length.Value(); |
283 LengthCheck(len, Int8Array::kMaxElements); | 283 LengthCheck(len, Int8Array::kMaxElements); |
284 return Int8Array::New(len); | 284 return Int8Array::New(len); |
285 } | 285 } |
286 | 286 |
287 | 287 |
288 DEFINE_NATIVE_ENTRY(Int8Array_getIndexed, 2) { | 288 DEFINE_NATIVE_ENTRY(Int8Array_getIndexed, 2) { |
289 GETTER(Int8Array, Smi, int8_t); | 289 GETTER(Int8Array, Smi, int8_t); |
290 } | 290 } |
291 | 291 |
292 | 292 |
293 DEFINE_NATIVE_ENTRY(Int8Array_setIndexed, 3) { | 293 DEFINE_NATIVE_ENTRY(Int8Array_setIndexed, 3) { |
294 SETTER(Int8Array, Smi, Value, int8_t); | 294 SETTER(Int8Array, Smi, Value, int8_t); |
295 } | 295 } |
296 | 296 |
297 | 297 |
298 // Uint8Array | 298 // Uint8Array |
299 | 299 |
300 DEFINE_NATIVE_ENTRY(Uint8Array_new, 1) { | 300 DEFINE_NATIVE_ENTRY(Uint8Array_new, 1) { |
301 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(0)); | 301 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0)); |
302 intptr_t len = length.Value(); | 302 intptr_t len = length.Value(); |
303 LengthCheck(len, Uint8Array::kMaxElements); | 303 LengthCheck(len, Uint8Array::kMaxElements); |
304 return Uint8Array::New(len); | 304 return Uint8Array::New(len); |
305 } | 305 } |
306 | 306 |
307 | 307 |
308 DEFINE_NATIVE_ENTRY(Uint8Array_getIndexed, 2) { | 308 DEFINE_NATIVE_ENTRY(Uint8Array_getIndexed, 2) { |
309 GETTER(Uint8Array, Smi, uint8_t); | 309 GETTER(Uint8Array, Smi, uint8_t); |
310 } | 310 } |
311 | 311 |
312 | 312 |
313 DEFINE_NATIVE_ENTRY(Uint8Array_setIndexed, 3) { | 313 DEFINE_NATIVE_ENTRY(Uint8Array_setIndexed, 3) { |
314 SETTER(Uint8Array, Smi, Value, uint8_t); | 314 SETTER(Uint8Array, Smi, Value, uint8_t); |
315 } | 315 } |
316 | 316 |
317 | 317 |
318 // Int16Array | 318 // Int16Array |
319 | 319 |
320 DEFINE_NATIVE_ENTRY(Int16Array_new, 1) { | 320 DEFINE_NATIVE_ENTRY(Int16Array_new, 1) { |
321 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(0)); | 321 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0)); |
322 intptr_t len = length.Value(); | 322 intptr_t len = length.Value(); |
323 LengthCheck(len, Int16Array::kMaxElements); | 323 LengthCheck(len, Int16Array::kMaxElements); |
324 return Int16Array::New(len); | 324 return Int16Array::New(len); |
325 } | 325 } |
326 | 326 |
327 | 327 |
328 DEFINE_NATIVE_ENTRY(Int16Array_getIndexed, 2) { | 328 DEFINE_NATIVE_ENTRY(Int16Array_getIndexed, 2) { |
329 GETTER(Int16Array, Smi, int16_t); | 329 GETTER(Int16Array, Smi, int16_t); |
330 } | 330 } |
331 | 331 |
332 | 332 |
333 DEFINE_NATIVE_ENTRY(Int16Array_setIndexed, 3) { | 333 DEFINE_NATIVE_ENTRY(Int16Array_setIndexed, 3) { |
334 SETTER(Int16Array, Smi, Value, int16_t); | 334 SETTER(Int16Array, Smi, Value, int16_t); |
335 } | 335 } |
336 | 336 |
337 | 337 |
338 // Uint16Array | 338 // Uint16Array |
339 | 339 |
340 DEFINE_NATIVE_ENTRY(Uint16Array_new, 1) { | 340 DEFINE_NATIVE_ENTRY(Uint16Array_new, 1) { |
341 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(0)); | 341 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0)); |
342 intptr_t len = length.Value(); | 342 intptr_t len = length.Value(); |
343 LengthCheck(len, Uint16Array::kMaxElements); | 343 LengthCheck(len, Uint16Array::kMaxElements); |
344 return Uint16Array::New(len); | 344 return Uint16Array::New(len); |
345 } | 345 } |
346 | 346 |
347 | 347 |
348 DEFINE_NATIVE_ENTRY(Uint16Array_getIndexed, 2) { | 348 DEFINE_NATIVE_ENTRY(Uint16Array_getIndexed, 2) { |
349 GETTER(Uint16Array, Smi, uint16_t); | 349 GETTER(Uint16Array, Smi, uint16_t); |
350 } | 350 } |
351 | 351 |
352 | 352 |
353 DEFINE_NATIVE_ENTRY(Uint16Array_setIndexed, 3) { | 353 DEFINE_NATIVE_ENTRY(Uint16Array_setIndexed, 3) { |
354 SETTER(Uint16Array, Smi, Value, uint16_t); | 354 SETTER(Uint16Array, Smi, Value, uint16_t); |
355 } | 355 } |
356 | 356 |
357 | 357 |
358 // Int32Array | 358 // Int32Array |
359 | 359 |
360 DEFINE_NATIVE_ENTRY(Int32Array_new, 1) { | 360 DEFINE_NATIVE_ENTRY(Int32Array_new, 1) { |
361 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(0)); | 361 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0)); |
362 intptr_t len = length.Value(); | 362 intptr_t len = length.Value(); |
363 LengthCheck(len, Int32Array::kMaxElements); | 363 LengthCheck(len, Int32Array::kMaxElements); |
364 return Int32Array::New(len); | 364 return Int32Array::New(len); |
365 } | 365 } |
366 | 366 |
367 | 367 |
368 DEFINE_NATIVE_ENTRY(Int32Array_getIndexed, 2) { | 368 DEFINE_NATIVE_ENTRY(Int32Array_getIndexed, 2) { |
369 GETTER(Int32Array, Integer, int32_t); | 369 GETTER(Int32Array, Integer, int32_t); |
370 } | 370 } |
371 | 371 |
372 | 372 |
373 DEFINE_NATIVE_ENTRY(Int32Array_setIndexed, 3) { | 373 DEFINE_NATIVE_ENTRY(Int32Array_setIndexed, 3) { |
374 SETTER(Int32Array, Integer, AsInt64Value, int32_t); | 374 SETTER(Int32Array, Integer, AsInt64Value, int32_t); |
375 } | 375 } |
376 | 376 |
377 | 377 |
378 // Uint32Array | 378 // Uint32Array |
379 | 379 |
380 DEFINE_NATIVE_ENTRY(Uint32Array_new, 1) { | 380 DEFINE_NATIVE_ENTRY(Uint32Array_new, 1) { |
381 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(0)); | 381 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0)); |
382 intptr_t len = length.Value(); | 382 intptr_t len = length.Value(); |
383 LengthCheck(len, Uint32Array::kMaxElements); | 383 LengthCheck(len, Uint32Array::kMaxElements); |
384 return Uint32Array::New(len); | 384 return Uint32Array::New(len); |
385 } | 385 } |
386 | 386 |
387 | 387 |
388 DEFINE_NATIVE_ENTRY(Uint32Array_getIndexed, 2) { | 388 DEFINE_NATIVE_ENTRY(Uint32Array_getIndexed, 2) { |
389 GETTER(Uint32Array, Integer, uint32_t); | 389 GETTER(Uint32Array, Integer, uint32_t); |
390 } | 390 } |
391 | 391 |
392 | 392 |
393 DEFINE_NATIVE_ENTRY(Uint32Array_setIndexed, 3) { | 393 DEFINE_NATIVE_ENTRY(Uint32Array_setIndexed, 3) { |
394 SETTER(Uint32Array, Integer, AsInt64Value, uint32_t); | 394 SETTER(Uint32Array, Integer, AsInt64Value, uint32_t); |
395 } | 395 } |
396 | 396 |
397 | 397 |
398 // Int64Array | 398 // Int64Array |
399 | 399 |
400 DEFINE_NATIVE_ENTRY(Int64Array_new, 1) { | 400 DEFINE_NATIVE_ENTRY(Int64Array_new, 1) { |
401 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(0)); | 401 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0)); |
402 intptr_t len = length.Value(); | 402 intptr_t len = length.Value(); |
403 LengthCheck(len, Int64Array::kMaxElements); | 403 LengthCheck(len, Int64Array::kMaxElements); |
404 return Int64Array::New(len); | 404 return Int64Array::New(len); |
405 } | 405 } |
406 | 406 |
407 | 407 |
408 DEFINE_NATIVE_ENTRY(Int64Array_getIndexed, 2) { | 408 DEFINE_NATIVE_ENTRY(Int64Array_getIndexed, 2) { |
409 GETTER(Int64Array, Integer, int64_t); | 409 GETTER(Int64Array, Integer, int64_t); |
410 } | 410 } |
411 | 411 |
412 | 412 |
413 DEFINE_NATIVE_ENTRY(Int64Array_setIndexed, 3) { | 413 DEFINE_NATIVE_ENTRY(Int64Array_setIndexed, 3) { |
414 SETTER(Int64Array, Integer, AsInt64Value, int64_t); | 414 SETTER(Int64Array, Integer, AsInt64Value, int64_t); |
415 } | 415 } |
416 | 416 |
417 | 417 |
418 // Uint64Array | 418 // Uint64Array |
419 | 419 |
420 DEFINE_NATIVE_ENTRY(Uint64Array_new, 1) { | 420 DEFINE_NATIVE_ENTRY(Uint64Array_new, 1) { |
421 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(0)); | 421 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0)); |
422 intptr_t len = length.Value(); | 422 intptr_t len = length.Value(); |
423 LengthCheck(len, Uint64Array::kMaxElements); | 423 LengthCheck(len, Uint64Array::kMaxElements); |
424 return Uint64Array::New(len); | 424 return Uint64Array::New(len); |
425 } | 425 } |
426 | 426 |
427 | 427 |
428 DEFINE_NATIVE_ENTRY(Uint64Array_getIndexed, 2) { | 428 DEFINE_NATIVE_ENTRY(Uint64Array_getIndexed, 2) { |
429 GETTER_UINT64(Uint64Array); | 429 GETTER_UINT64(Uint64Array); |
430 } | 430 } |
431 | 431 |
432 | 432 |
433 DEFINE_NATIVE_ENTRY(Uint64Array_setIndexed, 3) { | 433 DEFINE_NATIVE_ENTRY(Uint64Array_setIndexed, 3) { |
434 SETTER_UINT64(Uint64Array); | 434 SETTER_UINT64(Uint64Array); |
435 } | 435 } |
436 | 436 |
437 | 437 |
438 // Float32Array | 438 // Float32Array |
439 | 439 |
440 DEFINE_NATIVE_ENTRY(Float32Array_new, 1) { | 440 DEFINE_NATIVE_ENTRY(Float32Array_new, 1) { |
441 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(0)); | 441 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0)); |
442 intptr_t len = length.Value(); | 442 intptr_t len = length.Value(); |
443 LengthCheck(len, Float32Array::kMaxElements); | 443 LengthCheck(len, Float32Array::kMaxElements); |
444 return Float32Array::New(len); | 444 return Float32Array::New(len); |
445 } | 445 } |
446 | 446 |
447 | 447 |
448 DEFINE_NATIVE_ENTRY(Float32Array_getIndexed, 2) { | 448 DEFINE_NATIVE_ENTRY(Float32Array_getIndexed, 2) { |
449 GETTER(Float32Array, Double, float); | 449 GETTER(Float32Array, Double, float); |
450 } | 450 } |
451 | 451 |
452 | 452 |
453 DEFINE_NATIVE_ENTRY(Float32Array_setIndexed, 3) { | 453 DEFINE_NATIVE_ENTRY(Float32Array_setIndexed, 3) { |
454 SETTER(Float32Array, Double, value, float); | 454 SETTER(Float32Array, Double, value, float); |
455 } | 455 } |
456 | 456 |
457 | 457 |
458 // Float64Array | 458 // Float64Array |
459 | 459 |
460 DEFINE_NATIVE_ENTRY(Float64Array_new, 1) { | 460 DEFINE_NATIVE_ENTRY(Float64Array_new, 1) { |
461 GET_NATIVE_ARGUMENT(Smi, length, arguments->At(0)); | 461 GET_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0)); |
462 intptr_t len = length.Value(); | 462 intptr_t len = length.Value(); |
463 LengthCheck(len, Float64Array::kMaxElements); | 463 LengthCheck(len, Float64Array::kMaxElements); |
464 return Float64Array::New(len); | 464 return Float64Array::New(len); |
465 } | 465 } |
466 | 466 |
467 | 467 |
468 DEFINE_NATIVE_ENTRY(Float64Array_getIndexed, 2) { | 468 DEFINE_NATIVE_ENTRY(Float64Array_getIndexed, 2) { |
469 GETTER(Float64Array, Double, double); | 469 GETTER(Float64Array, Double, double); |
470 } | 470 } |
471 | 471 |
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
588 DEFINE_NATIVE_ENTRY(ExternalFloat64Array_getIndexed, 2) { | 588 DEFINE_NATIVE_ENTRY(ExternalFloat64Array_getIndexed, 2) { |
589 GETTER(ExternalFloat64Array, Double, double); | 589 GETTER(ExternalFloat64Array, Double, double); |
590 } | 590 } |
591 | 591 |
592 | 592 |
593 DEFINE_NATIVE_ENTRY(ExternalFloat64Array_setIndexed, 3) { | 593 DEFINE_NATIVE_ENTRY(ExternalFloat64Array_setIndexed, 3) { |
594 SETTER(ExternalFloat64Array, Double, value, double); | 594 SETTER(ExternalFloat64Array, Double, value, double); |
595 } | 595 } |
596 | 596 |
597 } // namespace dart | 597 } // namespace dart |
OLD | NEW |