static v8::Handle<v8::Value> fooMethod(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
Float64Array* imp = V8Float64Array::toNative(args.Holder());
V8TRYCATCH(Float32Array*, array, V8Float32Array::HasInstance(args[0], args.GetIsolate(), worldType(args.GetIsolate())) ? V8Float32Array::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0);
return toV8(imp->foo(array), args.Holder(), args.GetIsolate());
}
already_AddRefed<DOMMatrix>
DOMMatrix::Constructor(const GlobalObject& aGlobal, const Float64Array& aArray64, ErrorResult& aRv)
{
RefPtr<DOMMatrix> obj = new DOMMatrix(aGlobal.GetAsSupports());
aArray64.ComputeLengthAndData();
SetDataInMatrix(obj, aArray64.Data(), aArray64.Length(), aRv);
return obj.forget();
}
static v8::Handle<v8::Value> fooCallback(const v8::Arguments& args)
{
INC_STATS("DOM.Float64Array.foo");
if (args.Length() < 1)
return throwNotEnoughArgumentsError(args.GetIsolate());
Float64Array* imp = V8Float64Array::toNative(args.Holder());
EXCEPTION_BLOCK(Float32Array*, array, V8Float32Array::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8Float32Array::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
return toV8(imp->foo(array), args.Holder(), args.GetIsolate());
}
static v8::Handle<v8::Value> subarrayCallback(const v8::Arguments& args)
{
Float64Array* imp = V8Float64Array::toNative(args.Holder());
V8TRYCATCH(int, start, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
if (args.Length() <= 1) {
return toV8(imp->subarray(start), args.Holder(), args.GetIsolate());
}
V8TRYCATCH(int, end, toInt32(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)));
return toV8(imp->subarray(start, end), args.Holder(), args.GetIsolate());
}
EncodedJSValue JSC_HOST_CALL jsFloat64ArrayPrototypeFunctionFoo(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
if (!thisValue.inherits(&JSFloat64Array::s_info))
return throwVMTypeError(exec);
JSFloat64Array* castedThis = jsCast<JSFloat64Array*>(asObject(thisValue));
ASSERT_GC_OBJECT_INHERITS(castedThis, &JSFloat64Array::s_info);
Float64Array* impl = static_cast<Float64Array*>(castedThis->impl());
if (exec->argumentCount() < 1)
return throwVMError(exec, createNotEnoughArgumentsError(exec));
Float32Array* array(toFloat32Array(exec->argument(0)));
if (exec->hadException())
return JSValue::encode(jsUndefined());
JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->foo(array)));
return JSValue::encode(result);
}
template<> void CData::writeTo<Uint8ClampedArray>(Uint8ClampedArray* dest)
{
#ifdef DIRECT_WRITE
if (dest->length() != m_length)
return;
switch (getType()) {
case ArrayBufferView::TypeFloat32: {
Float32Array* src = getValue<Float32Array>();
if (!src)
return;
// write with clamping
uint8_t* pDest = dest->data();
float* pSrc = src->data();
for (size_t pos = 0; pos < m_length; pos++) {
float val = pSrc[pos];
pDest[pos] = (val > 255) ? 255 : ((val < 0) ? 0 : val);
}
break;
}
case ArrayBufferView::TypeFloat64: {
Float64Array* src = getValue<Float64Array>();
if (!src)
return;
// write with clamping
uint8_t* pDest = dest->data();
double* pSrc = src->data();
for (size_t pos = 0; pos < m_length; pos++) {
double val = pSrc[pos];
pDest[pos] = (val > 255) ? 255 : ((val < 0) ? 0 : val);
}
break;
}
default:
break;
}
#endif // DIRECT_WRITE
}
static v8::Handle<v8::Value> New (const v8::Arguments& args) {
if (args.Length() == 1 && args[0]->IsUint32()) {
// std::cout<<"New "<<args[0]->ToUint32()->IntegerValue()<<std::endl;
Float64Array* array = new Float64Array(args[0]->ToUint32()->IntegerValue());
array->Wrap(args.This());
}
else if(args.Length() == 1 && args[0]->IsObject())
{
// unwrap array buffer object
ArrayBuffer* buf = ObjectWrap::Unwrap<ArrayBuffer>(args[0]->ToObject());
Float64Array* array = new Float64Array(buf->length/8);
array->Wrap(args.This());
}
// std::cout<<"old Float64Array New "<<std::endl;
return args.This();
}
static v8::Handle<v8::Value> lengthAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
Float64Array* imp = V8Float64Array::toNative(info.Holder());
return v8UnsignedInteger(imp->length(), info.GetIsolate());
}
