void ScriptFunction::callCallback(
const v8::FunctionCallbackInfo<v8::Value>& args) {
ASSERT(args.Data()->IsExternal());
ScriptFunction* scriptFunction = static_cast<ScriptFunction*>(
v8::Local<v8::External>::Cast(args.Data())->Value());
ScriptValue result = scriptFunction->call(
ScriptValue(scriptFunction->getScriptState(), args[0]));
v8SetReturnValue(args, result.v8Value());
}
void promiseRejectCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
ASSERT(!info.Data().IsEmpty());
v8::Local<v8::Object> promise = info.Data().As<v8::Object>();
v8::Local<v8::Value> result = v8::Undefined(info.GetIsolate());
if (info.Length() > 0)
result = info[0];
V8PromiseCustom::reject(promise, result, info.GetIsolate());
}
void ScriptFunction::callCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
{
v8::Isolate* isolate = args.GetIsolate();
ASSERT(!args.Data().IsEmpty());
ScriptFunction* function = ScriptFunction::Cast(args.Data());
v8::Local<v8::Value> value = args.Length() > 0 ? args[0] : v8::Local<v8::Value>(v8::Undefined(isolate));
ScriptValue result = function->call(ScriptValue(ScriptState::current(isolate), value));
v8SetReturnValue(args, result.v8Value());
}
/**
* Callback function to be used when invoking functions
* defined from the PHP side
*
* @param info callback information
*/
static void callback(const v8::FunctionCallbackInfo<v8::Value> &info)
{
// create a local handle, so properties "fall out of scope"
v8::HandleScope scope(Isolate::get());
// retrieve handle to the original object
Handle handle(info.Data());
// an array to hold all the arguments
Php::Array arguments;
// add all the arguments
for (int i = 0; i < info.Length(); ++i) arguments.set(i, value(info[i]));
// catch any exceptions the PHP code might throw
try
{
// now execute the function
Php::Value result(Php::call("call_user_func_array", handle, arguments));
// cast the value and set it as return parameter
info.GetReturnValue().Set(value(result));
}
catch (const Php::Exception& exception)
{
// pass the exception on to javascript userspace
Isolate::get()->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(Isolate::get(), exception.what())));
}
}
static void constructCustomElement(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Isolate* isolate = info.GetIsolate();
if (!info.IsConstructCall()) {
V8ThrowException::throwTypeError(isolate, "DOM object constructor cannot be called as a function.");
return;
}
if (info.Length() > 0) {
V8ThrowException::throwTypeError(isolate, "This constructor should be called without arguments.");
return;
}
ScriptState* scriptState = ScriptState::current(isolate);
v8::Local<v8::Object> data = v8::Local<v8::Object>::Cast(info.Data());
Document* document = V8Document::toImpl(V8HiddenValue::getHiddenValue(scriptState, data, V8HiddenValue::customElementDocument(isolate)).As<v8::Object>());
TOSTRING_VOID(V8StringResource<>, namespaceURI, V8HiddenValue::getHiddenValue(scriptState, data, V8HiddenValue::customElementNamespaceURI(isolate)));
TOSTRING_VOID(V8StringResource<>, tagName, V8HiddenValue::getHiddenValue(scriptState, data, V8HiddenValue::customElementTagName(isolate)));
v8::Local<v8::Value> maybeType = V8HiddenValue::getHiddenValue(scriptState, data, V8HiddenValue::customElementType(isolate));
TOSTRING_VOID(V8StringResource<>, type, maybeType);
ExceptionState exceptionState(ExceptionState::ConstructionContext, "CustomElement", info.Holder(), info.GetIsolate());
V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
Element* element = document->createElementNS(namespaceURI, tagName, maybeType->IsNull() ? nullAtom : type, exceptionState);
if (exceptionState.throwIfNeeded())
return;
v8SetReturnValueFast(info, element, document);
}
void PreludeScript::log_callback(const v8::FunctionCallbackInfo<v8::Value>& args)
{
if (args.Length() != 1)
{
args.GetReturnValue().Set(
v8::Isolate::GetCurrent()->ThrowException(
v8::Exception::Error(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), "The 'log' handler expects 1 argument"))));
return;
}
if (args[0].IsEmpty())
{
args.GetReturnValue().Set(v8::Isolate::GetCurrent()->ThrowException(
v8::Exception::Error(v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), "The 'log' handler argument cannot be empty"))));
return;
}
// TODO: do we need to check argument data type?
v8::Handle<v8::External> data = args.Data().As<v8::External>();
PreludeScript *prelude = reinterpret_cast<PreludeScript *>(data->Value());
//TODO: make sure correct value type passed
v8::String::Value message(args[0].As<v8::String>());
prelude->log_handler(*message);
args.GetReturnValue().Set(v8::Undefined(v8::Isolate::GetCurrent()));
return;
};
typename std::enable_if<is_function_pointer<F>::value,
typename function_traits<F>::return_type>::type
invoke(v8::FunctionCallbackInfo<v8::Value> const& args)
{
F f = get_external_data<F>(args.Data());
return call_from_v8(std::forward<F>(f), args);
}
void MetadataNode::ClassConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
try
{
SET_PROFILER_FRAME();
auto thiz = info.This();
auto node = reinterpret_cast<MetadataNode*>(info.Data().As<External>()->Value());
Local<Object> outerThis;
string extendName;
auto className = node->m_name;
SetInstanceMetadata(info.GetIsolate(), thiz, node);
ArgsWrapper argWrapper(info, ArgType::Class, outerThis);
string fullClassName = CreateFullClassName(className, extendName);
bool success = NativeScriptRuntime::RegisterInstance(thiz, fullClassName, argWrapper, outerThis, false);
}
catch (NativeScriptException& e)
{
e.ReThrowToV8();
}
catch (std::exception e) {
stringstream ss;
ss << "Error: c++ exception: " << e.what() << endl;
NativeScriptException nsEx(ss.str());
nsEx.ReThrowToV8();
}
catch (...) {
NativeScriptException nsEx(std::string("Error: c++ exception!"));
nsEx.ReThrowToV8();
}
}
static void FXJSE_V8ProxyCallback_defineProperty(
const v8::FunctionCallbackInfo<v8::Value>& info) {
const FXJSE_CLASS* lpClass =
static_cast<FXJSE_CLASS*>(info.Data().As<v8::External>()->Value());
if (!lpClass) {
return;
}
v8::Isolate* pIsolate = info.GetIsolate();
v8::HandleScope scope(pIsolate);
v8::Local<v8::String> hPropName = info[0]->ToString();
v8::Local<v8::Object> hPropDescriptor = info[1]->ToObject();
v8::String::Utf8Value szPropName(hPropName);
if (!hPropDescriptor->Has(v8::String::NewFromUtf8(pIsolate, "value"))) {
return;
}
v8::Local<v8::Value> hPropValue =
hPropDescriptor->Get(v8::String::NewFromUtf8(pIsolate, "value"));
CFX_ByteStringC szFxPropName(*szPropName, szPropName.length());
CFXJSE_Value* lpThisValue = CFXJSE_Value::Create(info.GetIsolate());
CFXJSE_Value* lpPropValue = CFXJSE_Value::Create(info.GetIsolate());
lpThisValue->ForceSetValue(info.This());
lpPropValue->ForceSetValue(hPropValue);
FXJSE_DynPropSetterAdapter(
lpClass, reinterpret_cast<FXJSE_HOBJECT>(lpThisValue), szFxPropName,
reinterpret_cast<FXJSE_HVALUE>(lpPropValue));
delete lpThisValue;
lpThisValue = nullptr;
delete lpPropValue;
lpPropValue = nullptr;
}
void MetadataNode::ExtendedClassConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
SET_PROFILER_FRAME();
assert(info.IsConstructCall());
auto isolate = info.GetIsolate();
auto thiz = info.This();
auto extData = reinterpret_cast<ExtendedClassData*>(info.Data().As<External>()->Value());
auto implementationObject = Local<Object>::New(isolate, *extData->implementationObject);
const auto& extendName = extData->extendedName;
// auto className = TNS_PREFIX + extData->node->m_name;
SetInstanceMetadata(isolate, thiz, extData->node);
thiz->SetInternalField(static_cast<int>(ObjectManager::MetadataNodeKeys::CallSuper), True(isolate));
thiz->SetHiddenValue(ConvertToV8String("t::implObj"), implementationObject);
ArgsWrapper argWrapper(info, ArgType::Class, Local<Object>());
// string fullClassName = CreateFullClassName(className, extendName);
string fullClassName = extData->fullClassName;
bool success = NativeScriptRuntime::RegisterInstance(thiz, fullClassName, argWrapper, implementationObject, false);
}
static void FXJSE_DynPropGetterAdapter_MethodCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Local<v8::Object> hCallBackInfo = info.Data().As<v8::Object>();
FXJSE_CLASS* lpClass = static_cast<FXJSE_CLASS*>(
hCallBackInfo->GetAlignedPointerFromInternalField(0));
v8::Local<v8::String> hPropName =
hCallBackInfo->GetInternalField(1).As<v8::String>();
ASSERT(lpClass && !hPropName.IsEmpty());
v8::String::Utf8Value szPropName(hPropName);
CFX_ByteStringC szFxPropName = *szPropName;
CFXJSE_Value* lpThisValue = CFXJSE_Value::Create(info.GetIsolate());
lpThisValue->ForceSetValue(info.This());
CFXJSE_Value* lpRetValue = CFXJSE_Value::Create(info.GetIsolate());
CFXJSE_ArgumentsImpl impl = {&info, lpRetValue};
lpClass->dynMethodCall(reinterpret_cast<FXJSE_HOBJECT>(lpThisValue),
szFxPropName,
reinterpret_cast<CFXJSE_Arguments&>(impl));
if (!lpRetValue->DirectGetValue().IsEmpty()) {
info.GetReturnValue().Set(lpRetValue->DirectGetValue());
}
delete lpRetValue;
lpRetValue = nullptr;
delete lpThisValue;
lpThisValue = nullptr;
}
void MetadataNode::InterfaceConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
SET_PROFILER_FRAME();
auto thiz = info.This();
auto node = reinterpret_cast<MetadataNode*>(info.Data().As<External>()->Value());
Handle<Object> implementationObject;
Handle<String> v8ExtendName;
string extendLocation;
bool extendLocationFound = GetExtendLocation(extendLocation);
if (info.Length() == 1)
{
if (!extendLocationFound)
{
ASSERT_FAIL("Invalid extend() call. No name specified for extend. Location: %s", extendLocation.c_str());
}
ASSERT_MESSAGE(info[0]->IsObject(), "Invalid extend() call. No implementation object specified. Location: %s", extendLocation.c_str());
implementationObject = info[0]->ToObject();
}
else if (info.Length() == 2)
{
ASSERT_MESSAGE(info[0]->IsString(), "Invalid extend() call. No name for extend specified. Location: %s", extendLocation.c_str());
ASSERT_MESSAGE(info[1]->IsObject(), "Invalid extend() call. Named extend should be called with second object parameter containing overridden methods. Location: %s", extendLocation.c_str());
DEBUG_WRITE("InterfaceConstructorCallback: getting extend name");
v8ExtendName = info[0]->ToString();
implementationObject = info[1]->ToObject();
}
else
{
ASSERT_FAIL("Invalid extend() call. Location: %s", extendLocation.c_str());
}
auto className = node->m_implType;
auto extendName = ConvertToString(v8ExtendName);
auto extendNameAndLocation = extendLocation + extendName;
SetInstanceMetadata(info.GetIsolate(), implementationObject, node);
//@@@ Refactor
string fullClassName = CreateFullClassName(className, extendNameAndLocation);
thiz->SetHiddenValue(ConvertToV8String("implClassName"), ConvertToV8String(fullClassName));
//
jclass generatedClass = s_resolveClass(fullClassName, implementationObject);
implementationObject->SetHiddenValue(ConvertToV8String(fullClassName), External::New(Isolate::GetCurrent(), generatedClass));//
implementationObject->SetPrototype(thiz->GetPrototype());
thiz->SetPrototype(implementationObject);
thiz->SetHiddenValue(ConvertToV8String("t::implObj"), implementationObject);
ArgsWrapper argWrapper(info, ArgType::Interface, Handle<Object>());
auto success = s_registerInstance(thiz, fullClassName, argWrapper, implementationObject, true);
assert(success);
}
void CallbackInterfaces::VoidPointerCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
{
Types::CallbackInfoIMPL cb(args);
v8::Handle<v8::External> ext = v8::Handle<v8::External>::Cast(args.Data());
Types::VoidPFunction icb = (Types::VoidPFunction)ext->Value();
args.GetReturnValue().Set((int)icb(cb));
}
void MetadataNode::MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
SET_PROFILER_FRAME();
auto e = info.Data().As<External>();
auto callbackData = reinterpret_cast<MethodCallbackData*>(e->Value());
auto& candidates = callbackData->candidates;
auto className = callbackData->node->m_name;
auto methodName = candidates.front().name;
int argLength = info.Length();
int count = 0;
MetadataEntry *entry = nullptr;
for (auto& c: candidates)
{
if (c.paramCount == argLength)
{
if (++count > 1)
break;
entry = &c;
}
}
auto thiz = info.This();
auto isSuper = false;
const auto& first = candidates.front();
if (!first.isStatic)
{
auto extededClassName = thiz->GetHiddenValue(ConvertToV8String("implClassName"));
isSuper = !extededClassName.IsEmpty();
if (!isSuper)
{
auto superValue = thiz->GetHiddenValue(ConvertToV8String("issupervalue"));
isSuper = !superValue.IsEmpty();
}
}
// TODO: refactor this
if (isSuper && (className == "com/tns/NativeScriptActivity"))
{
className = "android/app/Activity";
}
if ((methodName == V8StringConstants::VALUE_OF) && (argLength == 0))
{
info.GetReturnValue().Set(thiz);
}
else
{
s_callJavaMethod(thiz, className, methodName, entry, first.isStatic, isSuper, info);
}
}
AdblockPlus::JsEnginePtr AdblockPlus::JsEngine::FromArguments(const v8::FunctionCallbackInfo<v8::Value>& arguments)
{
const v8::Local<const v8::External> external =
v8::Local<const v8::External>::Cast(arguments.Data());
std::weak_ptr<JsEngine>* data =
static_cast<std::weak_ptr<JsEngine>*>(external->Value());
JsEnginePtr result = data->lock();
if (!result)
throw std::runtime_error("Oops, our JsEngine is gone, how did that happen?");
return result;
}
void CallbackInterfaces::WideStringCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
{
Types::CallbackInfoIMPL cb(args);
v8::Handle<v8::External> ext = v8::Handle<v8::External>::Cast(args.Data());
Types::WideStringFunction icb = (Types::WideStringFunction)ext->Value();
wchar_t *result = icb(cb);
v8::Local<v8::String> v8Result = v8::String::NewFromTwoByte(args.GetIsolate(), (uint16_t *)result);
args.GetReturnValue().Set(v8Result);
}
void Proxy::onPropertyChanged(const v8::FunctionCallbackInfo<v8::Value>& args)
{
Isolate* isolate = args.GetIsolate();
if (args.Length() < 1) {
JSException::Error(isolate, "Requires property name as first parameters.");
return;
}
Local<String> name = args.Data()->ToString(isolate);
Local<Value> value = args[0];
onPropertyChangedForProxy(isolate, name, value, args.Holder());
}
typename std::enable_if<std::is_member_function_pointer<F>::value,
typename function_traits<F>::return_type>::type
invoke(v8::FunctionCallbackInfo<v8::Value> const& args)
{
using arguments = typename function_traits<F>::arguments;
static_assert(std::tuple_size<arguments>::value > 0, "");
using class_type = typename std::tuple_element<0, arguments>::type;
F f = get_external_data<F>(args.Data());
class_type& obj = from_v8<class_type&>(args.GetIsolate(), args.This());
return call_from_v8(obj, std::forward<F>(f), args);
}
void promiseAllFulfillCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Isolate* isolate = info.GetIsolate();
ASSERT(!info.Data().IsEmpty());
v8::Local<v8::Object> environment = info.Data().As<v8::Object>();
v8::Local<v8::Value> result = v8::Undefined(isolate);
if (info.Length() > 0)
result = info[0];
v8::Local<v8::Object> promise = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentPromiseIndex).As<v8::Object>();
v8::Local<v8::Object> countdownWrapper = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentCountdownIndex).As<v8::Object>();
v8::Local<v8::Integer> index = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentIndexIndex).As<v8::Integer>();
v8::Local<v8::Array> results = environment->GetInternalField(V8PromiseCustom::PromiseAllEnvironmentResultsIndex).As<v8::Array>();
results->Set(index->Value(), result);
v8::Local<v8::Integer> countdown = countdownWrapper->GetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex).As<v8::Integer>();
ASSERT(countdown->Value() >= 1);
if (countdown->Value() == 1) {
V8PromiseCustom::resolve(promise, results, isolate);
return;
}
countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(isolate, countdown->Value() - 1));
}
static void JS_PagerOutput(v8::FunctionCallbackInfo<v8::Value> const& args) {
TRI_V8_TRY_CATCH_BEGIN(isolate);
v8::HandleScope scope(isolate);
v8::Local<v8::External> wrap = v8::Local<v8::External>::Cast(args.Data());
ConsoleFeature* console = static_cast<ConsoleFeature*>(wrap->Value());
for (int i = 0; i < args.Length(); i++) {
// extract the next argument
console->print(TRI_ObjectToString(args[i]));
}
TRI_V8_RETURN_UNDEFINED();
TRI_V8_TRY_CATCH_END
}
void MetadataNode::InnerClassConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
auto thiz = info.This();
auto isolate = info.GetIsolate();
auto data = reinterpret_cast<InnerClassData*>(info.Data().As<External>()->Value());
auto outerThis = Local<Object>::New(isolate, *data->outerThis);
string extendName;
auto className = data->node->m_name;
SetInstanceMetadata(info.GetIsolate(), thiz, data->node);
ArgsWrapper argWrapper(info, ArgType::Class, outerThis);
string fullClassName = CreateFullClassName(className, extendName);
bool success = NativeScriptRuntime::RegisterInstance(thiz, fullClassName, argWrapper, outerThis, false);
}
void _json_loader(const v8::FunctionCallbackInfo<v8::Value>& args)
{
v8::Isolate* isolate = args.GetIsolate();
obj_ptr<Buffer_base> src = Buffer_base::getInstance(args.Data());
exlib::string strScript;
src->toString(strScript);
v8::Local<v8::Value> v;
result_t hr = json_base::decode(strScript, v);
if (hr < 0) {
ThrowResult(hr);
return;
}
v8::Local<v8::Object> module = v8::Local<v8::Object>::Cast(args[5]);
module->Set(NewString(isolate, "exports"), v);
}
void JSZCluster::constructor(const v8::FunctionCallbackInfo<v8::Value> &info) {
if (info.IsConstructCall()) {
return;
}
Isolate *isolate = info.GetIsolate();
try {
JSZCluster *This = (JSZCluster *) (Local<External>::Cast(info.Data())->Value());
checkConstructorValidArgument(isolate, info);
ExtAddress extAddress = getExtAddressFromArg(info, 0);
EndpointID endpointId(info[1].As<v8::Integer>()->Value());
ClusterID clusterId(info[2].As<v8::Integer>()->Value());
info.GetReturnValue().Set(This->createInstance(info.GetIsolate(), extAddress, endpointId, clusterId));
} catch (std::exception &excp) {
v8::Local<v8::String> errorMsg = v8::String::NewFromUtf8(isolate, excp.what());
isolate->ThrowException(errorMsg);
}
}
void MetadataNode::ClassConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
SET_PROFILER_FRAME();
auto thiz = info.This();
auto node = reinterpret_cast<MetadataNode*>(info.Data().As<External>()->Value());
Local<Object> outerThis;
string extendName;
auto className = node->m_name;
SetInstanceMetadata(info.GetIsolate(), thiz, node);
ArgsWrapper argWrapper(info, ArgType::Class, outerThis);
string fullClassName = CreateFullClassName(className, extendName);
bool success = NativeScriptRuntime::RegisterInstance(thiz, fullClassName, argWrapper, outerThis, false);
}
static void JS_StopOutputPager(
v8::FunctionCallbackInfo<v8::Value> const& args) {
TRI_V8_TRY_CATCH_BEGIN(isolate);
v8::HandleScope scope(isolate);
v8::Local<v8::External> wrap = v8::Local<v8::External>::Cast(args.Data());
ConsoleFeature* console = static_cast<ConsoleFeature*>(wrap->Value());
if (console->pager()) {
console->print("Stopping pager.\n");
} else {
console->print("Pager not running.\n");
}
console->setPager(false);
TRI_V8_RETURN_UNDEFINED();
TRI_V8_TRY_CATCH_END
}
static void JS_StartOutputPager(
v8::FunctionCallbackInfo<v8::Value> const& args) {
TRI_V8_TRY_CATCH_BEGIN(isolate);
v8::HandleScope scope(isolate);
v8::Local<v8::External> wrap = v8::Local<v8::External>::Cast(args.Data());
ConsoleFeature* console = static_cast<ConsoleFeature*>(wrap->Value());
if (console->pager()) {
console->print("Using pager already.\n");
} else {
console->setPager(true);
console->print(std::string(std::string("Using pager ") +
console->pagerCommand() +
" for output buffering.\n"));
}
TRI_V8_RETURN_UNDEFINED();
TRI_V8_TRY_CATCH_END
}
void MetadataNode::ExtendedClassConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
try
{
SET_PROFILER_FRAME();
assert(info.IsConstructCall());
auto isolate = info.GetIsolate();
auto thiz = info.This();
auto extData = reinterpret_cast<ExtendedClassData*>(info.Data().As<External>()->Value());
auto implementationObject = Local<Object>::New(isolate, *extData->implementationObject);
const auto& extendName = extData->extendedName;
SetInstanceMetadata(isolate, thiz, extData->node);
thiz->SetInternalField(static_cast<int>(ObjectManager::MetadataNodeKeys::CallSuper), True(isolate));
thiz->SetHiddenValue(ConvertToV8String("t::implObj"), implementationObject);
ArgsWrapper argWrapper(info, ArgType::Class, Local<Object>());
string fullClassName = extData->fullClassName;
bool success = NativeScriptRuntime::RegisterInstance(thiz, fullClassName, argWrapper, implementationObject, false);
}
catch (NativeScriptException& e)
{
e.ReThrowToV8();
}
catch (std::exception e) {
stringstream ss;
ss << "Error: c++ exception: " << e.what() << endl;
NativeScriptException nsEx(ss.str());
nsEx.ReThrowToV8();
}
catch (...) {
NativeScriptException nsEx(std::string("Error: c++ exception!"));
nsEx.ReThrowToV8();
}
}
void JNIV8ClassInfo::v8MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
JNIEnv *env = JNIWrapper::getEnvironment();
JNILocalFrame localFrame(env);
HandleScope scope(args.GetIsolate());
v8::Local<v8::External> ext;
ext = args.Data().As<v8::External>();
JNIV8ObjectCallbackHolder* cb = static_cast<JNIV8ObjectCallbackHolder*>(ext->Value());
if(cb->isStatic) {
// we do NOT check how this function was invoked.. if a this was supplied, we just ignore it!
(cb->callback.s)(cb->methodName, args);
} else {
ext = args.This()->GetInternalField(0).As<v8::External>();
JNIV8Object *v8Object = reinterpret_cast<JNIV8Object *>(ext->Value());
(v8Object->*(cb->callback.i))(cb->methodName, args);
}
}
static void FXJSE_V8ProxyCallback_getOwnPropertyDescriptor_setter(
const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Local<v8::Object> hCallBackInfo = info.Data().As<v8::Object>();
FXJSE_CLASS* lpClass = static_cast<FXJSE_CLASS*>(
hCallBackInfo->GetAlignedPointerFromInternalField(0));
v8::Local<v8::String> hPropName =
hCallBackInfo->GetInternalField(1).As<v8::String>();
ASSERT(lpClass && !hPropName.IsEmpty());
v8::String::Utf8Value szPropName(hPropName);
CFX_ByteStringC szFxPropName = *szPropName;
CFXJSE_Value* lpThisValue = CFXJSE_Value::Create(info.GetIsolate());
CFXJSE_Value* lpNewValue = CFXJSE_Value::Create(info.GetIsolate());
lpThisValue->ForceSetValue(info.This());
lpNewValue->ForceSetValue(info[0]);
FXJSE_DynPropSetterAdapter(
lpClass, reinterpret_cast<FXJSE_HOBJECT>(lpThisValue), szFxPropName,
reinterpret_cast<FXJSE_HVALUE>(lpNewValue));
delete lpThisValue;
lpThisValue = nullptr;
delete lpNewValue;
lpNewValue = nullptr;
}
void JSZAttribute::constructor(const v8::FunctionCallbackInfo<v8::Value> &info) {
if (info.IsConstructCall()) {
return;
}
Isolate *isolate = info.GetIsolate();
try {
validateParams(info);
ExtAddress extAddress = getExtAddressFromArg(info);
EndpointID endpointId(info[1].As<v8::Integer>()->Value());
ClusterID clusterId(info[2].As<v8::Integer>()->Value());
uint32_t attributeId = info[3].As<v8::Integer>()->Value();
JSZAttribute *This = (JSZAttribute *) (Local<External>::Cast(info.Data())->Value());
std::shared_ptr<ZCLAttribute> zclAttribute = This->getZCLAttribute(extAddress, endpointId, clusterId,
attributeId);
info.GetReturnValue().Set(This->createInstance(isolate, zclAttribute));
} catch (std::exception &excp) {
v8::Local<v8::String> errorMsg = v8::String::NewFromUtf8(isolate, excp.what());
isolate->ThrowException(errorMsg);
}
}