using node::ThrowRangeError;
using node::ThrowTypeError;
using node::ThrowError;
-using node::node_isolate;
struct BatchedMethods {
const char* name;
args.This()->SetAlignedPointerInInternalField(0, buf);
args.This()->Set(v8::String::New("byteLength"),
- v8::Integer::NewFromUnsigned(num_bytes, node_isolate),
+ v8::Integer::NewFromUnsigned(num_bytes),
(v8::PropertyAttribute)(v8::ReadOnly|v8::DontDelete));
// NOTE(deanm): This is not in the spec, you shouldn't be able to index
unsigned int slice_length = end - begin;
v8::Local<v8::Value> argv[] = {
- v8::Integer::New(slice_length, node_isolate)};
+ v8::Integer::New(slice_length)};
v8::Local<v8::Object> buffer = ArrayBuffer::GetTemplate()->
GetFunction()->NewInstance(1, argv);
- if (buffer.IsEmpty()) {
- return v8::Undefined(node_isolate); // constructor failed
- }
+ if (buffer.IsEmpty()) return v8::Undefined(); // constructor failed
void* src = args.This()->GetAlignedPointerFromInternalField(0);
void* dest = buffer->GetAlignedPointerFromInternalField(0);
}
void* buf = buffer->GetIndexedPropertiesExternalArrayData();
- char* begin = static_cast<char*>(buf) + byte_offset;
+ char* begin = reinterpret_cast<char*>(buf) + byte_offset;
if (!checkAlignment(reinterpret_cast<uintptr_t>(begin), TBytes))
return ThrowRangeError("Byte offset is not aligned.");
// TODO(deanm): Handle integer overflow.
v8::Local<v8::Value> argv[1] = {
- v8::Integer::NewFromUnsigned(length * TBytes, node_isolate)};
+ v8::Integer::NewFromUnsigned(length * TBytes)};
buffer = ArrayBuffer::GetTemplate()->
GetFunction()->NewInstance(1, argv);
- if (buffer.IsEmpty()) {
- return v8::Undefined(node_isolate); // constructor failed
- }
+ if (buffer.IsEmpty()) return v8::Undefined(); // constructor failed
void* buf = buffer->GetAlignedPointerFromInternalField(0);
args.This()->SetIndexedPropertiesToExternalArrayData(
length = args[0]->Uint32Value();
// TODO(deanm): Handle integer overflow.
v8::Local<v8::Value> argv[1] = {
- v8::Integer::NewFromUnsigned(length * TBytes, node_isolate)};
+ v8::Integer::NewFromUnsigned(length * TBytes)};
buffer = ArrayBuffer::GetTemplate()->
GetFunction()->NewInstance(1, argv);
- if (buffer.IsEmpty()) {
- return v8::Undefined(node_isolate); // constructor failed
- }
+ if (buffer.IsEmpty()) return v8::Undefined(); // constructor failed
void* buf = buffer->GetAlignedPointerFromInternalField(0);
args.This()->SetIndexedPropertiesToExternalArrayData(
buffer,
(v8::PropertyAttribute)(v8::ReadOnly|v8::DontDelete));
args.This()->Set(v8::String::New("length"),
- v8::Integer::NewFromUnsigned(length, node_isolate),
+ v8::Integer::NewFromUnsigned(length),
(v8::PropertyAttribute)(v8::ReadOnly|v8::DontDelete));
args.This()->Set(v8::String::New("byteOffset"),
- v8::Integer::NewFromUnsigned(byte_offset, node_isolate),
+ v8::Integer::NewFromUnsigned(byte_offset),
(v8::PropertyAttribute)(v8::ReadOnly|v8::DontDelete));
args.This()->Set(v8::String::New("byteLength"),
- v8::Integer::NewFromUnsigned(length * TBytes,
- node_isolate),
+ v8::Integer::NewFromUnsigned(length * TBytes),
(v8::PropertyAttribute)(v8::ReadOnly|v8::DontDelete));
return args.This();
if (args[0]->IsNumber())
return args.This()->Get(args[0]->Uint32Value());
- return v8::Undefined(node_isolate);
+ return v8::Undefined();
}
static v8::Handle<v8::Value> set(const v8::Arguments& args) {
// place as if all the data is first copied into a temporary buffer that
// does not overlap either of the arrays, and then the data from the
// temporary buffer is copied into the current array.
- memmove(static_cast<char*>(dst_ptr) + offset * TBytes, src_ptr,
+ memmove(reinterpret_cast<char*>(dst_ptr) + offset * TBytes, src_ptr,
src_length * TBytes);
} else { // type[]
if (args[1]->Int32Value() < 0)
}
}
- return v8::Undefined(node_isolate);
+ return v8::Undefined();
}
static v8::Handle<v8::Value> subarray(const v8::Arguments& args) {
// Call through to the ArrayBuffer, byteOffset, length constructor.
v8::Local<v8::Value> argv[] = {
args.This()->Get(v8::String::New("buffer")),
- v8::Integer::New(byte_offset, node_isolate),
- v8::Integer::New(end - begin, node_isolate)};
+ v8::Integer::New(byte_offset),
+ v8::Integer::New(end - begin)};
return TypedArray<TBytes, TEAType>::GetTemplate()->
GetFunction()->NewInstance(3, argv);
}
template <typename T>
v8::Handle<v8::Value> cTypeToValue(T) {
- return v8::Undefined(node_isolate);
+ return v8::Undefined();
}
template <>
v8::Handle<v8::Value> cTypeToValue(unsigned char val) {
- return v8::Integer::NewFromUnsigned(val, node_isolate);
+ return v8::Integer::NewFromUnsigned(val);
}
template <>
v8::Handle<v8::Value> cTypeToValue(signed char val) {
- return v8::Integer::New(val, node_isolate);
+ return v8::Integer::New(val);
}
template <>
v8::Handle<v8::Value> cTypeToValue(unsigned short val) {
- return v8::Integer::NewFromUnsigned(val, node_isolate);
+ return v8::Integer::NewFromUnsigned(val);
}
template <>
v8::Handle<v8::Value> cTypeToValue(short val) {
- return v8::Integer::New(val, node_isolate);
+ return v8::Integer::New(val);
}
template <>
v8::Handle<v8::Value> cTypeToValue(unsigned int val) {
- return v8::Integer::NewFromUnsigned(val, node_isolate);
+ return v8::Integer::NewFromUnsigned(val);
}
template <>
v8::Handle<v8::Value> cTypeToValue(int val) {
- return v8::Integer::New(val, node_isolate);
+ return v8::Integer::New(val);
}
template <>
// Like ArrayBuffer, we violate the spec and add an operator[].
args.This()->SetIndexedPropertiesToExternalArrayData(
- static_cast<char*>(buf) + byte_offset,
+ reinterpret_cast<char*>(buf) + byte_offset,
v8::kExternalUnsignedByteArray, byte_length);
args.This()->Set(v8::String::New("buffer"),
buffer,
(v8::PropertyAttribute)(v8::ReadOnly|v8::DontDelete));
args.This()->Set(v8::String::New("byteOffset"),
- v8::Integer::NewFromUnsigned(byte_offset, node_isolate),
+ v8::Integer::NewFromUnsigned(byte_offset),
(v8::PropertyAttribute)(v8::ReadOnly|v8::DontDelete));
args.This()->Set(v8::String::New("byteLength"),
- v8::Integer::NewFromUnsigned(byte_length, node_isolate),
+ v8::Integer::NewFromUnsigned(byte_length),
(v8::PropertyAttribute)(v8::ReadOnly|v8::DontDelete));
return args.This();
}
template <typename T>
static T getValue(void* ptr, unsigned int index, bool swiz) {
char buf[sizeof(T)];
- memcpy(buf, static_cast<char*>(ptr) + index, sizeof(T));
+ memcpy(buf, reinterpret_cast<char*>(ptr) + index, sizeof(T));
if (swiz)
swizzle(buf, sizeof(T));
T val;
memcpy(buf, &val, sizeof(T));
if (swiz)
swizzle(buf, sizeof(T));
- memcpy(static_cast<char*>(ptr) + index, buf, sizeof(T));
+ memcpy(reinterpret_cast<char*>(ptr) + index, buf, sizeof(T));
}
template <typename T>
void* ptr = args.This()->GetIndexedPropertiesExternalArrayData();
setValue<T>(ptr, index, valueToCType<T>(args[1]), !little_endian);
- return v8::Undefined(node_isolate);
+ return v8::Undefined();
}
static v8::Handle<v8::Value> getUint8(const v8::Arguments& args) {