Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(256)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: runtime/lib/byte_array.cc

Issue 13139002: Remove support for 'dart:scalarlist' in the Dart VM. (Closed) Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge/dart/
Patch Set: Created 7 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « no previous file | runtime/lib/byte_array.dart » ('j') | runtime/vm/dart_api_impl.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: runtime/lib/byte_array.cc
===================================================================
--- runtime/lib/byte_array.cc (revision 20600)
+++ runtime/lib/byte_array.cc (working copy)
@@ -1,797 +0,0 @@
-// 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 "vm/bootstrap_natives.h"
-
-#include "include/dart_api.h"
-
-#include "vm/bigint_operations.h"
-#include "vm/exceptions.h"
-#include "vm/native_entry.h"
-#include "vm/object.h"
-
-namespace dart {
-
-// ByteArray
-
-// Checks to see if (index * num_bytes) is in the range
-// [0..array.ByteLength()). without the risk of integer overflow. If
-// the index is out of range, then a RangeError is thrown.
-static void RangeCheck(const ByteArray& array,
- intptr_t index,
- intptr_t num_bytes) {
- if (!Utils::RangeCheck(index, num_bytes, array.ByteLength())) {
- const String& error = String::Handle(String::NewFormatted(
- "index (%"Pd") must be in the range [0..%"Pd")",
- (index / num_bytes), (array.ByteLength() / num_bytes)));
- const Array& args = Array::Handle(Array::New(1));
- args.SetAt(0, error);
- Exceptions::ThrowByType(Exceptions::kRange, args);
- }
-}
-
-
-// Checks to see if a length is in the range [0..max]. If the length
-// is out of range, then an ArgumentError is thrown.
-static void LengthCheck(intptr_t len, intptr_t max) {
- if (len < 0 || len > max) {
- const String& error = String::Handle(String::NewFormatted(
- "length (%"Pd") must be in the range [0..%"Pd"]", len, max));
- const Array& args = Array::Handle(Array::New(1));
- args.SetAt(0, error);
- Exceptions::ThrowByType(Exceptions::kArgument, args);
- }
-}
-
-
-#define GETTER_ARGUMENTS(ArrayT, ValueT) \
- GET_NON_NULL_NATIVE_ARGUMENT(ArrayT, array, arguments->NativeArgAt(0)); \
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1));
-
-
-#define SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT) \
- GET_NON_NULL_NATIVE_ARGUMENT(ArrayT, array, arguments->NativeArgAt(0)); \
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, index, arguments->NativeArgAt(1)); \
- GET_NON_NULL_NATIVE_ARGUMENT( \
- ObjectT, value_object, arguments->NativeArgAt(2));
-
-
-#define GETTER(ArrayT, ObjectT, ValueT) \
- GETTER_ARGUMENTS(ArrayT, ValueT); \
- RangeCheck(array, index.Value() * sizeof(ValueT), sizeof(ValueT)); \
- ValueT result = array.At(index.Value()); \
- return ObjectT::New(result);
-
-
-#define SETTER(ArrayT, ObjectT, Getter, ValueT) \
- SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT); \
- RangeCheck(array, index.Value() * sizeof(ValueT), sizeof(ValueT)); \
- ValueT value = value_object.Getter(); \
- array.SetAt(index.Value(), value); \
- return Object::null();
-
-
-#define UNALIGNED_GETTER(ArrayT, ObjectT, ValueT) \
- GETTER_ARGUMENTS(ArrayT, ValueT); \
- RangeCheck(array, index.Value(), sizeof(ValueT)); \
- ValueT result; \
- ByteArray::Copy(&result, array, index.Value(), sizeof(ValueT)); \
- return ObjectT::New(result);
-
-
-#define UNALIGNED_SETTER(ArrayT, ObjectT, Getter, ValueT) \
- SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT); \
- RangeCheck(array, index.Value(), sizeof(ValueT)); \
- ValueT src = value_object.Getter(); \
- ByteArray::Copy(array, index.Value(), &src, sizeof(ValueT)); \
- return Integer::New(index.Value() + sizeof(ValueT));
-
-
-#define SCALED_UNALIGNED_GETTER(ArrayT, ObjectT, ValueT) \
- GETTER_ARGUMENTS(ArrayT, ValueT); \
- RangeCheck(array, index.Value() * sizeof(ValueT), sizeof(ValueT)); \
- ValueT result; \
- ByteArray::Copy(&result, array, \
- index.Value() * sizeof(ValueT), sizeof(ValueT)); \
- return ObjectT::New(result);
-
-
-#define SCALED_UNALIGNED_SETTER(ArrayT, ObjectT, Getter, ValueT) \
- SETTER_ARGUMENTS(ArrayT, ObjectT, ValueT); \
- RangeCheck(array, index.Value() * sizeof(ValueT), sizeof(ValueT)); \
- ValueT src = value_object.Getter(); \
- ByteArray::Copy(array, index.Value() * sizeof(ValueT), &src, sizeof(ValueT));\
- return Integer::New(index.Value() + sizeof(ValueT));
-
-
-#define UINT64_TO_INTEGER(value, integer) \
- if (value > static_cast<uint64_t>(Mint::kMaxValue)) { \
- result = BigintOperations::NewFromUint64(value); \
- } else if (value > static_cast<uint64_t>(Smi::kMaxValue)) { \
- result = Mint::New(value); \
- } else { \
- result = Smi::New(value); \
- }
-
-
-#define GETTER_UINT64(ArrayT) \
- GETTER_ARGUMENTS(ArrayT, uint64_t); \
- intptr_t size = sizeof(uint64_t); \
- RangeCheck(array, index.Value() * size, size); \
- uint64_t value = array.At(index.Value()); \
- Integer& result = Integer::Handle(); \
- UINT64_TO_INTEGER(value, result); \
- return result.raw();
-
-
-#define UNALIGNED_GETTER_UINT64(ArrayT) \
- GETTER_ARGUMENTS(ArrayT, uint64_t); \
- RangeCheck(array, index.Value(), sizeof(uint64_t)); \
- uint64_t value; \
- ByteArray::Copy(&value, array, index.Value(), sizeof(uint64_t)); \
- Integer& result = Integer::Handle(); \
- UINT64_TO_INTEGER(value, result); \
- return result.raw();
-
-
-#define INTEGER_TO_UINT64(integer, uint64) \
- if (integer.IsBigint()) { \
- const Bigint& bigint = Bigint::Cast(integer); \
- ASSERT(BigintOperations::FitsIntoUint64(bigint)); \
- value = BigintOperations::AbsToUint64(bigint); \
- } else { \
- ASSERT(integer.IsMint() || integer.IsSmi()); \
- value = integer.AsInt64Value(); \
- } \
-
-
-#define SETTER_UINT64(ArrayT) \
- SETTER_ARGUMENTS(ArrayT, Integer, uint64_t); \
- intptr_t size = sizeof(uint64_t); \
- RangeCheck(array, index.Value() * size, size); \
- uint64_t value; \
- INTEGER_TO_UINT64(value_object, value); \
- array.SetAt(index.Value(), value); \
- return Object::null();
-
-
-#define UNALIGNED_SETTER_UINT64(ArrayT) \
- SETTER_ARGUMENTS(ArrayT, Integer, uint64_t); \
- RangeCheck(array, index.Value(), sizeof(uint64_t)); \
- uint64_t value; \
- INTEGER_TO_UINT64(value_object, value); \
- ByteArray::Copy(array, index.Value(), &value, sizeof(uint64_t)); \
- return Integer::New(index.Value() + sizeof(uint64_t));
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getLength, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(ByteArray, array, arguments->NativeArgAt(0));
- return Smi::New(array.Length());
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getInt8, 2) {
- UNALIGNED_GETTER(ByteArray, Smi, int8_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setInt8, 3) {
- UNALIGNED_SETTER(ByteArray, Smi, Value, int8_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getUint8, 2) {
- UNALIGNED_GETTER(ByteArray, Smi, uint8_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setUint8, 3) {
- UNALIGNED_SETTER(ByteArray, Smi, Value, uint8_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getInt16, 2) {
- UNALIGNED_GETTER(ByteArray, Smi, int16_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setInt16, 3) {
- UNALIGNED_SETTER(ByteArray, Smi, Value, int16_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getUint16, 2) {
- UNALIGNED_GETTER(ByteArray, Smi, uint16_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setUint16, 3) {
- UNALIGNED_SETTER(ByteArray, Smi, Value, uint16_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getInt32, 2) {
- UNALIGNED_GETTER(ByteArray, Integer, int32_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setInt32, 3) {
- UNALIGNED_SETTER(ByteArray, Integer, AsInt64Value, int32_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getUint32, 2) {
- UNALIGNED_GETTER(ByteArray, Integer, uint32_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setUint32, 3) {
- UNALIGNED_SETTER(ByteArray, Integer, AsInt64Value, uint32_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getInt64, 2) {
- UNALIGNED_GETTER(ByteArray, Integer, int64_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setInt64, 3) {
- UNALIGNED_SETTER(ByteArray, Integer, AsInt64Value, int64_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getUint64, 2) {
- UNALIGNED_GETTER_UINT64(ByteArray);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setUint64, 3) {
- UNALIGNED_SETTER_UINT64(ByteArray);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getFloat32, 2) {
- UNALIGNED_GETTER(ByteArray, Double, float);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setFloat32, 3) {
- UNALIGNED_SETTER(ByteArray, Double, value, float);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_getFloat64, 2) {
- UNALIGNED_GETTER(ByteArray, Double, double);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setFloat64, 3) {
- UNALIGNED_SETTER(ByteArray, Double, value, double);
-}
-
-
-DEFINE_NATIVE_ENTRY(ByteArray_setRange, 5) {
- ByteArray& dst = ByteArray::CheckedHandle(arguments->NativeArgAt(0));
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, dst_start, arguments->NativeArgAt(1));
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(2));
- GET_NON_NULL_NATIVE_ARGUMENT(ByteArray, src, arguments->NativeArgAt(3));
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, src_start, arguments->NativeArgAt(4));
- intptr_t length_value = length.Value();
- intptr_t src_start_value = src_start.Value();
- intptr_t dst_start_value = dst_start.Value();
- if (length_value < 0) {
- const String& error = String::Handle(String::NewFormatted(
- "length (%"Pd") must be non-negative", length_value));
- const Array& args = Array::Handle(Array::New(1));
- args.SetAt(0, error);
- Exceptions::ThrowByType(Exceptions::kArgument, args);
- }
- RangeCheck(src, src_start_value, length_value);
- RangeCheck(dst, dst_start_value, length_value);
- ByteArray::Copy(dst, dst_start_value, src, src_start_value, length_value);
- return Object::null();
-}
-
-
-static void PeerFinalizer(Dart_Handle handle, void* peer) {
- Dart_DeletePersistentHandle(handle);
- OS::AlignedFree(peer);
-}
-
-
-// Int8Array
-
-DEFINE_NATIVE_ENTRY(Int8Array_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Int8Array::kMaxElements);
- return Int8Array::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Int8List_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Int8Array::kMaxElements);
- int8_t* bytes = OS::AllocateAlignedArray<int8_t>(len, kAlignment);
- const ExternalInt8Array& obj =
- ExternalInt8Array::Handle(ExternalInt8Array::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Int8Array_getIndexed, 2) {
- GETTER(Int8Array, Smi, int8_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(Int8Array_setIndexed, 3) {
- SETTER(Int8Array, Smi, Value, int8_t);
-}
-
-
-// Uint8Array
-
-DEFINE_NATIVE_ENTRY(Uint8Array_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Uint8Array::kMaxElements);
- return Uint8Array::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint8List_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Uint8Array::kMaxElements);
- uint8_t* bytes = OS::AllocateAlignedArray<uint8_t>(len, kAlignment);
- const ExternalUint8Array& obj =
- ExternalUint8Array::Handle(ExternalUint8Array::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint8Array_getIndexed, 2) {
- GETTER(Uint8Array, Smi, uint8_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint8Array_setIndexed, 3) {
- SETTER(Uint8Array, Smi, Value, uint8_t);
-}
-
-
-// Uint8ClampedArray
-
-DEFINE_NATIVE_ENTRY(Uint8ClampedArray_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Uint8ClampedArray::kMaxElements);
- return Uint8ClampedArray::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint8ClampedList_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Uint8ClampedArray::kMaxElements);
- uint8_t* bytes = OS::AllocateAlignedArray<uint8_t>(len, kAlignment);
- const ExternalUint8ClampedArray& obj = ExternalUint8ClampedArray::Handle(
- ExternalUint8ClampedArray::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint8ClampedArray_getIndexed, 2) {
- GETTER(Uint8ClampedArray, Smi, uint8_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint8ClampedArray_setIndexed, 3) {
- SETTER(Uint8ClampedArray, Smi, Value, uint8_t);
-}
-
-
-// Int16Array
-
-DEFINE_NATIVE_ENTRY(Int16Array_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Int16Array::kMaxElements);
- return Int16Array::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Int16List_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Int16Array::kMaxElements);
- int16_t* bytes = OS::AllocateAlignedArray<int16_t>(len, kAlignment);
- const ExternalInt16Array& obj =
- ExternalInt16Array::Handle(ExternalInt16Array::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Int16Array_getIndexed, 2) {
- GETTER(Int16Array, Smi, int16_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(Int16Array_setIndexed, 3) {
- SETTER(Int16Array, Smi, Value, int16_t);
-}
-
-
-// Uint16Array
-
-DEFINE_NATIVE_ENTRY(Uint16Array_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Uint16Array::kMaxElements);
- return Uint16Array::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint16List_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Uint16Array::kMaxElements);
- uint16_t* bytes = OS::AllocateAlignedArray<uint16_t>(len, kAlignment);
- const ExternalUint16Array& obj =
- ExternalUint16Array::Handle(ExternalUint16Array::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint16Array_getIndexed, 2) {
- GETTER(Uint16Array, Smi, uint16_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint16Array_setIndexed, 3) {
- SETTER(Uint16Array, Smi, Value, uint16_t);
-}
-
-
-// Int32Array
-
-DEFINE_NATIVE_ENTRY(Int32Array_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Int32Array::kMaxElements);
- return Int32Array::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Int32List_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Int32Array::kMaxElements);
- int32_t* bytes = OS::AllocateAlignedArray<int32_t>(len, kAlignment);
- const ExternalInt32Array& obj =
- ExternalInt32Array::Handle(ExternalInt32Array::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Int32Array_getIndexed, 2) {
- GETTER(Int32Array, Integer, int32_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(Int32Array_setIndexed, 3) {
- SETTER(Int32Array, Integer, AsInt64Value, int32_t);
-}
-
-
-// Uint32Array
-
-DEFINE_NATIVE_ENTRY(Uint32Array_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Uint32Array::kMaxElements);
- return Uint32Array::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint32List_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Uint32Array::kMaxElements);
- uint32_t* bytes = OS::AllocateAlignedArray<uint32_t>(len, kAlignment);
- const ExternalUint32Array& obj =
- ExternalUint32Array::Handle(ExternalUint32Array::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint32Array_getIndexed, 2) {
- GETTER(Uint32Array, Integer, uint32_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint32Array_setIndexed, 3) {
- SETTER(Uint32Array, Integer, AsInt64Value, uint32_t);
-}
-
-
-// Int64Array
-
-DEFINE_NATIVE_ENTRY(Int64Array_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Int64Array::kMaxElements);
- return Int64Array::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Int64List_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Int64Array::kMaxElements);
- int64_t* bytes = OS::AllocateAlignedArray<int64_t>(len, kAlignment);
- const ExternalInt64Array& obj =
- ExternalInt64Array::Handle(ExternalInt64Array::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Int64Array_getIndexed, 2) {
- GETTER(Int64Array, Integer, int64_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(Int64Array_setIndexed, 3) {
- SETTER(Int64Array, Integer, AsInt64Value, int64_t);
-}
-
-
-// Uint64Array
-
-DEFINE_NATIVE_ENTRY(Uint64Array_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Uint64Array::kMaxElements);
- return Uint64Array::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint64List_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Uint64Array::kMaxElements);
- uint64_t* bytes = OS::AllocateAlignedArray<uint64_t>(len, kAlignment);
- const ExternalUint64Array& obj =
- ExternalUint64Array::Handle(ExternalUint64Array::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint64Array_getIndexed, 2) {
- GETTER_UINT64(Uint64Array);
-}
-
-
-DEFINE_NATIVE_ENTRY(Uint64Array_setIndexed, 3) {
- SETTER_UINT64(Uint64Array);
-}
-
-
-// Float32Array
-
-DEFINE_NATIVE_ENTRY(Float32Array_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Float32Array::kMaxElements);
- return Float32Array::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Float32List_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Float32Array::kMaxElements);
- float* bytes = OS::AllocateAlignedArray<float>(len, kAlignment);
- const ExternalFloat32Array& obj =
- ExternalFloat32Array::Handle(ExternalFloat32Array::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Float32Array_getIndexed, 2) {
- GETTER(Float32Array, Double, float);
-}
-
-
-DEFINE_NATIVE_ENTRY(Float32Array_setIndexed, 3) {
- SETTER(Float32Array, Double, value, float);
-}
-
-
-// Float64Array
-
-DEFINE_NATIVE_ENTRY(Float64Array_new, 1) {
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Float64Array::kMaxElements);
- return Float64Array::New(len);
-}
-
-
-DEFINE_NATIVE_ENTRY(Float64List_newTransferable, 1) {
- const int kAlignment = 16;
- GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));
- intptr_t len = length.Value();
- LengthCheck(len, Float64Array::kMaxElements);
- double* bytes = OS::AllocateAlignedArray<double>(len, kAlignment);
- const ExternalFloat64Array& obj =
- ExternalFloat64Array::Handle(ExternalFloat64Array::New(bytes, len));
- obj.AddFinalizer(bytes, PeerFinalizer);
- return obj.raw();
-}
-
-
-DEFINE_NATIVE_ENTRY(Float64Array_getIndexed, 2) {
- GETTER(Float64Array, Double, double);
-}
-
-
-DEFINE_NATIVE_ENTRY(Float64Array_setIndexed, 3) {
- SETTER(Float64Array, Double, value, double);
-}
-
-
-// ExternalInt8Array
-
-DEFINE_NATIVE_ENTRY(ExternalInt8Array_getIndexed, 2) {
- GETTER(ExternalInt8Array, Smi, int8_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalInt8Array_setIndexed, 3) {
- SETTER(ExternalInt8Array, Smi, Value, int8_t);
-}
-
-
-// ExternalUint8Array
-
-DEFINE_NATIVE_ENTRY(ExternalUint8Array_getIndexed, 2) {
- SCALED_UNALIGNED_GETTER(ExternalUint8Array, Smi, uint8_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalUint8Array_setIndexed, 3) {
- SCALED_UNALIGNED_SETTER(ExternalUint8Array, Smi, Value, uint8_t);
-}
-
-
-// ExternalUint8ClampedArray
-
-DEFINE_NATIVE_ENTRY(ExternalUint8ClampedArray_getIndexed, 2) {
- SCALED_UNALIGNED_GETTER(ExternalUint8ClampedArray, Smi, uint8_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalUint8ClampedArray_setIndexed, 3) {
- SCALED_UNALIGNED_SETTER(ExternalUint8ClampedArray, Smi, Value, uint8_t);
-}
-
-
-// ExternalInt16Array
-
-DEFINE_NATIVE_ENTRY(ExternalInt16Array_getIndexed, 2) {
- GETTER(ExternalInt16Array, Smi, int16_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalInt16Array_setIndexed, 3) {
- SETTER(ExternalInt16Array, Smi, Value, int16_t);
-}
-
-
-// ExternalUint16Array
-
-DEFINE_NATIVE_ENTRY(ExternalUint16Array_getIndexed, 2) {
- SCALED_UNALIGNED_GETTER(ExternalUint16Array, Smi, uint16_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalUint16Array_setIndexed, 3) {
- SCALED_UNALIGNED_SETTER(ExternalUint16Array, Smi, Value, uint16_t);
-}
-
-
-// ExternalInt32Array
-
-DEFINE_NATIVE_ENTRY(ExternalInt32Array_getIndexed, 2) {
- GETTER(ExternalInt32Array, Integer, int32_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalInt32Array_setIndexed, 3) {
- SETTER(ExternalInt32Array, Integer, AsInt64Value, int32_t);
-}
-
-
-// ExternalUint32Array
-
-DEFINE_NATIVE_ENTRY(ExternalUint32Array_getIndexed, 2) {
- SCALED_UNALIGNED_GETTER(ExternalUint32Array, Integer, uint32_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalUint32Array_setIndexed, 3) {
- SCALED_UNALIGNED_SETTER(ExternalUint32Array, Integer, AsInt64Value, uint32_t);
-}
-
-
-// ExternalInt64Array
-
-DEFINE_NATIVE_ENTRY(ExternalInt64Array_getIndexed, 2) {
- GETTER(ExternalInt64Array, Integer, int64_t);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalInt64Array_setIndexed, 3) {
- SETTER(ExternalInt64Array, Integer, AsInt64Value, int64_t);
-}
-
-
-// ExternalUint64Array
-
-DEFINE_NATIVE_ENTRY(ExternalUint64Array_getIndexed, 2) {
- GETTER_UINT64(ExternalUint64Array);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalUint64Array_setIndexed, 3) {
- SETTER_UINT64(ExternalUint64Array);
-}
-
-
-// ExternalFloat32Array
-
-DEFINE_NATIVE_ENTRY(ExternalFloat32Array_getIndexed, 2) {
- GETTER(ExternalFloat32Array, Double, float);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalFloat32Array_setIndexed, 3) {
- SETTER(ExternalFloat32Array, Double, value, float);
-}
-
-
-// ExternalFloat64Array
-
-DEFINE_NATIVE_ENTRY(ExternalFloat64Array_getIndexed, 2) {
- GETTER(ExternalFloat64Array, Double, double);
-}
-
-
-DEFINE_NATIVE_ENTRY(ExternalFloat64Array_setIndexed, 3) {
- SETTER(ExternalFloat64Array, Double, value, double);
-}
-
-} // namespace dart
« no previous file with comments | « no previous file | runtime/lib/byte_array.dart » ('j') | runtime/vm/dart_api_impl.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698