From ecec46e33fefb87d8589e985db7bef44764e64c8 Mon Sep 17 00:00:00 2001 From: dinglei Date: Thu, 4 Jan 2024 15:55:09 +0800 Subject: [PATCH] =?UTF-8?q?=E3=80=90=E7=89=B9=E6=80=A7=E9=9C=80=E6=B1=82?= =?UTF-8?q?=E3=80=91=E6=8F=90=E4=BE=9Bv8=E4=BD=9C=E4=B8=BA=E4=B8=89?= =?UTF-8?q?=E6=96=B9=E5=8F=AF=E7=94=A8=E7=9A=84JS=E5=BC=95=E6=93=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: dinglei --- src/api/environment.cc | 4 +- src/env_properties.h | 2 +- src/js_native_api_v8.cc | 1704 +++++++++++++++--------------- src/js_native_api_v8.h | 184 ++-- src/js_native_api_v8_internals.h | 4 +- src/jsvm.h | 561 ++++++++++ src/jsvm_node_api.h | 275 +++++ src/jsvm_node_api_types.h | 50 + src/jsvm_type.h | 160 +++ src/node.h | 6 +- src/node_api.cc | 532 +++++----- src/node_api_internals.h | 10 +- src/node_binding.cc | 12 +- src/node_binding.h | 6 +- src/node_internals.h | 4 +- 15 files changed, 2280 insertions(+), 1234 deletions(-) create mode 100644 src/jsvm.h create mode 100644 src/jsvm_node_api.h create mode 100644 src/jsvm_node_api_types.h create mode 100644 src/jsvm_type.h diff --git a/src/api/environment.cc b/src/api/environment.cc index e1095037f..f1b0032e1 100644 --- a/src/api/environment.cc +++ b/src/api/environment.cc @@ -782,7 +782,7 @@ void AddLinkedBinding(Environment* env, const node_module& mod) { prev_tail->nm_link = &env->extra_linked_bindings()->back(); } -void AddLinkedBinding(Environment* env, const napi_module& mod) { +void AddLinkedBinding(Environment* env, const jsvm_module& mod) { node_module node_mod = napi_module_to_node_module(&mod); node_mod.nm_flags = NM_F_LINKED; AddLinkedBinding(env, node_mod); @@ -808,7 +808,7 @@ void AddLinkedBinding(Environment* env, void AddLinkedBinding(Environment* env, const char* name, - napi_addon_register_func fn, + jsvm_addon_register_func fn, int32_t module_api_version) { node_module mod = { -1, // nm_version for Node-API diff --git a/src/env_properties.h b/src/env_properties.h index 2a1843f68..5bc3510db 100644 --- a/src/env_properties.h +++ b/src/env_properties.h @@ -21,7 +21,7 @@ V(arrow_message_private_symbol, "node:arrowMessage") \ V(contextify_context_private_symbol, "node:contextify:context") \ V(decorated_private_symbol, "node:decorated") \ - V(napi_type_tag, "node:napi:type_tag") \ + V(napi_typeTag, "node:napi:typeTag") \ V(napi_wrapper, "node:napi:wrapper") \ V(untransferable_object_private_symbol, "node:untransferableObject") \ V(exiting_aliased_Uint32Array, "node:exiting_aliased_Uint32Array") \ diff --git a/src/js_native_api_v8.cc b/src/js_native_api_v8.cc index 10b821119..341e879c6 100644 --- a/src/js_native_api_v8.cc +++ b/src/js_native_api_v8.cc @@ -1,7 +1,7 @@ #include #include // INT_MAX #include -#define NAPI_EXPERIMENTAL +#define JSVM_EXPERIMENTAL #include "env-inl.h" #include "js_native_api.h" #include "js_native_api_v8.h" @@ -14,47 +14,47 @@ RETURN_STATUS_IF_FALSE_WITH_PREAMBLE((env), !((maybe).IsNothing()), (status)) #define CHECK_TO_NUMBER(env, context, result, src) \ - CHECK_TO_TYPE((env), Number, (context), (result), (src), napi_number_expected) + CHECK_TO_TYPE((env), Number, (context), (result), (src), JSVM_NUMBER_EXPECTED) -// n-api defines NAPI_AUTO_LENGTH as the indicator that a string +// n-api defines JSVM_AUTO_LENGTH as the indicator that a string // is null terminated. For V8 the equivalent is -1. The assert -// validates that our cast of NAPI_AUTO_LENGTH results in -1 as +// validates that our cast of JSVM_AUTO_LENGTH results in -1 as // needed by V8. #define CHECK_NEW_FROM_UTF8_LEN(env, result, str, len) \ do { \ - static_assert(static_cast(NAPI_AUTO_LENGTH) == -1, \ - "Casting NAPI_AUTO_LENGTH to int must result in -1"); \ + static_assert(static_cast(JSVM_AUTO_LENGTH) == -1, \ + "Casting JSVM_AUTO_LENGTH to int must result in -1"); \ RETURN_STATUS_IF_FALSE( \ - (env), (len == NAPI_AUTO_LENGTH) || len <= INT_MAX, napi_invalid_arg); \ - RETURN_STATUS_IF_FALSE((env), (str) != nullptr, napi_invalid_arg); \ + (env), (len == JSVM_AUTO_LENGTH) || len <= INT_MAX, JSVM_INVALID_ARG); \ + RETURN_STATUS_IF_FALSE((env), (str) != nullptr, JSVM_INVALID_ARG); \ auto str_maybe = v8::String::NewFromUtf8((env)->isolate, \ (str), \ v8::NewStringType::kInternalized, \ static_cast(len)); \ - CHECK_MAYBE_EMPTY((env), str_maybe, napi_generic_failure); \ + CHECK_MAYBE_EMPTY((env), str_maybe, JSVM_GENERIC_FAILURE); \ (result) = str_maybe.ToLocalChecked(); \ } while (0) #define CHECK_NEW_FROM_UTF8(env, result, str) \ - CHECK_NEW_FROM_UTF8_LEN((env), (result), (str), NAPI_AUTO_LENGTH) + CHECK_NEW_FROM_UTF8_LEN((env), (result), (str), JSVM_AUTO_LENGTH) #define CREATE_TYPED_ARRAY( \ - env, type, size_of_element, buffer, byte_offset, length, out) \ + env, type, size_of_element, buffer, byteOffset, length, out) \ do { \ if ((size_of_element) > 1) { \ THROW_RANGE_ERROR_IF_FALSE( \ (env), \ - (byte_offset) % (size_of_element) == 0, \ - "ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT", \ + (byteOffset) % (size_of_element) == 0, \ + "ERR_JSVM_INVALID_TYPEDARRAY_ALIGNMENT", \ "start offset of " #type \ " should be a multiple of " #size_of_element); \ } \ THROW_RANGE_ERROR_IF_FALSE( \ (env), \ - (length) * (size_of_element) + (byte_offset) <= buffer->ByteLength(), \ - "ERR_NAPI_INVALID_TYPEDARRAY_LENGTH", \ + (length) * (size_of_element) + (byteOffset) <= buffer->ByteLength(), \ + "ERR_JSVM_INVALID_TYPEDARRAY_LENGTH", \ "Invalid typed array length"); \ - (out) = v8::type::New((buffer), (byte_offset), (length)); \ + (out) = v8::type::New((buffer), (byteOffset), (length)); \ } while (0) namespace v8impl { @@ -62,49 +62,49 @@ namespace v8impl { namespace { template -napi_status NewString(napi_env env, +JSVM_Status NewString(JSVM_Env env, const CCharType* str, size_t length, - napi_value* result, + JSVM_Value* result, StringMaker string_maker) { CHECK_ENV(env); if (length > 0) CHECK_ARG(env, str); CHECK_ARG(env, result); RETURN_STATUS_IF_FALSE( - env, (length == NAPI_AUTO_LENGTH) || length <= INT_MAX, napi_invalid_arg); + env, (length == JSVM_AUTO_LENGTH) || length <= INT_MAX, JSVM_INVALID_ARG); auto isolate = env->isolate; auto str_maybe = string_maker(isolate); - CHECK_MAYBE_EMPTY(env, str_maybe, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, str_maybe, JSVM_GENERIC_FAILURE); *result = v8impl::JsValueFromV8LocalValue(str_maybe.ToLocalChecked()); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } template -napi_status NewExternalString(napi_env env, +JSVM_Status NewExternalString(JSVM_Env env, CharType* str, size_t length, - napi_finalize finalize_callback, - void* finalize_hint, - napi_value* result, + JSVM_FINALIZE finalizeCallback, + void* finalizeHint, + JSVM_Value* result, bool* copied, CreateAPI create_api, StringMaker string_maker) { - napi_status status; + JSVM_Status status; #if defined(V8_ENABLE_SANDBOX) status = create_api(env, str, length, result); - if (status == napi_ok) { + if (status == JSVM_OK) { if (copied != nullptr) { *copied = true; } - if (finalize_callback) { + if (finalizeCallback) { env->CallFinalizer( - finalize_callback, static_cast(str), finalize_hint); + finalizeCallback, static_cast(str), finalizeHint); } } #else status = NewString(env, str, length, result, string_maker); - if (status == napi_ok && copied != nullptr) { + if (status == JSVM_OK && copied != nullptr) { *copied = false; } #endif // V8_ENABLE_SANDBOX @@ -113,12 +113,12 @@ napi_status NewExternalString(napi_env env, class TrackedStringResource : public Finalizer, RefTracker { public: - TrackedStringResource(napi_env env, - napi_finalize finalize_callback, + TrackedStringResource(JSVM_Env env, + JSVM_FINALIZE finalizeCallback, void* data, - void* finalize_hint) - : Finalizer(env, finalize_callback, data, finalize_hint) { - Link(finalize_callback == nullptr ? &env->reflist + void* finalizeHint) + : Finalizer(env, finalizeCallback, data, finalizeHint) { + Link(finalizeCallback == nullptr ? &env->reflist : &env->finalizing_reflist); } @@ -151,12 +151,12 @@ class ExternalOneByteStringResource : public v8::String::ExternalOneByteStringResource, TrackedStringResource { public: - ExternalOneByteStringResource(napi_env env, + ExternalOneByteStringResource(JSVM_Env env, char* string, const size_t length, - napi_finalize finalize_callback, - void* finalize_hint) - : TrackedStringResource(env, finalize_callback, string, finalize_hint), + JSVM_FINALIZE finalizeCallback, + void* finalizeHint) + : TrackedStringResource(env, finalizeCallback, string, finalizeHint), string_(string), length_(length) {} @@ -171,12 +171,12 @@ class ExternalOneByteStringResource class ExternalStringResource : public v8::String::ExternalStringResource, TrackedStringResource { public: - ExternalStringResource(napi_env env, + ExternalStringResource(JSVM_Env env, char16_t* string, const size_t length, - napi_finalize finalize_callback, - void* finalize_hint) - : TrackedStringResource(env, finalize_callback, string, finalize_hint), + JSVM_FINALIZE finalizeCallback, + void* finalizeHint) + : TrackedStringResource(env, finalizeCallback, string, finalizeHint), string_(reinterpret_cast(string)), length_(length) {} @@ -188,9 +188,9 @@ class ExternalStringResource : public v8::String::ExternalStringResource, const size_t length_; }; -inline napi_status V8NameFromPropertyDescriptor( - napi_env env, - const napi_property_descriptor* p, +inline JSVM_Status V8NameFromPropertyDescriptor( + JSVM_Env env, + const JSVM_PropertyDescriptor* p, v8::Local* result) { if (p->utf8name != nullptr) { CHECK_NEW_FROM_UTF8(env, *result, p->utf8name); @@ -198,42 +198,42 @@ inline napi_status V8NameFromPropertyDescriptor( v8::Local property_value = v8impl::V8LocalValueFromJsValue(p->name); - RETURN_STATUS_IF_FALSE(env, property_value->IsName(), napi_name_expected); + RETURN_STATUS_IF_FALSE(env, property_value->IsName(), JSVM_NAME_EXPECTED); *result = property_value.As(); } - return napi_ok; + return JSVM_OK; } // convert from n-api property attributes to v8::PropertyAttribute inline v8::PropertyAttribute V8PropertyAttributesFromDescriptor( - const napi_property_descriptor* descriptor) { + const JSVM_PropertyDescriptor* descriptor) { unsigned int attribute_flags = v8::PropertyAttribute::None; - // The napi_writable attribute is ignored for accessor descriptors, but + // The JSVM_WRITABLE attribute is ignored for accessor descriptors, but // V8 would throw `TypeError`s on assignment with nonexistence of a setter. if ((descriptor->getter == nullptr && descriptor->setter == nullptr) && - (descriptor->attributes & napi_writable) == 0) { + (descriptor->attributes & JSVM_WRITABLE) == 0) { attribute_flags |= v8::PropertyAttribute::ReadOnly; } - if ((descriptor->attributes & napi_enumerable) == 0) { + if ((descriptor->attributes & JSVM_ENUMERABLE) == 0) { attribute_flags |= v8::PropertyAttribute::DontEnum; } - if ((descriptor->attributes & napi_configurable) == 0) { + if ((descriptor->attributes & JSVM_CONFIGURABLE) == 0) { attribute_flags |= v8::PropertyAttribute::DontDelete; } return static_cast(attribute_flags); } -inline napi_deferred JsDeferredFromNodePersistent( +inline JSVM_Deferred JsDeferredFromNodePersistent( v8impl::Persistent* local) { - return reinterpret_cast(local); + return reinterpret_cast(local); } inline v8impl::Persistent* NodePersistentFromJsDeferred( - napi_deferred local) { + JSVM_Deferred local) { return reinterpret_cast*>(local); } @@ -274,23 +274,23 @@ inline HandleScopeWrapper* V8HandleScopeFromJsHandleScope(napi_handle_scope s) { return reinterpret_cast(s); } -inline napi_escapable_handle_scope +inline JSVM_EscapableHandleScope JsEscapableHandleScopeFromV8EscapableHandleScope( EscapableHandleScopeWrapper* s) { - return reinterpret_cast(s); + return reinterpret_cast(s); } inline EscapableHandleScopeWrapper* V8EscapableHandleScopeFromJsEscapableHandleScope( - napi_escapable_handle_scope s) { + JSVM_EscapableHandleScope s) { return reinterpret_cast(s); } -inline napi_status ConcludeDeferred(napi_env env, - napi_deferred deferred, - napi_value result, +inline JSVM_Status ConcludeDeferred(JSVM_Env env, + JSVM_Deferred deferred, + JSVM_Value result, bool is_resolved) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::Local context = env->context(); @@ -309,32 +309,32 @@ inline napi_status ConcludeDeferred(napi_env env, delete deferred_ref; - RETURN_STATUS_IF_FALSE(env, success.FromMaybe(false), napi_generic_failure); + RETURN_STATUS_IF_FALSE(env, success.FromMaybe(false), JSVM_GENERIC_FAILURE); return GET_RETURN_STATUS(env); } enum UnwrapAction { KeepWrap, RemoveWrap }; -inline napi_status Unwrap(napi_env env, - napi_value js_object, +inline JSVM_Status Unwrap(JSVM_Env env, + JSVM_Value jsObject, void** result, UnwrapAction action) { - NAPI_PREAMBLE(env); - CHECK_ARG(env, js_object); + JSVM_PREAMBLE(env); + CHECK_ARG(env, jsObject); if (action == KeepWrap) { CHECK_ARG(env, result); } v8::Local context = env->context(); - v8::Local value = v8impl::V8LocalValueFromJsValue(js_object); - RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg); + v8::Local value = v8impl::V8LocalValueFromJsValue(jsObject); + RETURN_STATUS_IF_FALSE(env, value->IsObject(), JSVM_INVALID_ARG); v8::Local obj = value.As(); - auto val = obj->GetPrivate(context, NAPI_PRIVATE_KEY(context, wrapper)) + auto val = obj->GetPrivate(context, JSVM_PRIVATE_KEY(context, wrapper)) .ToLocalChecked(); - RETURN_STATUS_IF_FALSE(env, val->IsExternal(), napi_invalid_arg); + RETURN_STATUS_IF_FALSE(env, val->IsExternal(), JSVM_INVALID_ARG); Reference* reference = static_cast(val.As()->Value()); @@ -343,7 +343,7 @@ inline napi_status Unwrap(napi_env env, } if (action == RemoveWrap) { - CHECK(obj->DeletePrivate(context, NAPI_PRIVATE_KEY(context, wrapper)) + CHECK(obj->DeletePrivate(context, JSVM_PRIVATE_KEY(context, wrapper)) .FromJust()); if (reference->ownership() == Ownership::kUserland) { // When the wrap is been removed, the finalizer should be reset. @@ -356,7 +356,7 @@ inline napi_status Unwrap(napi_env env, return GET_RETURN_STATUS(env); } -//=== Function napi_callback wrapper ================================= +//=== Function JSVM_Callback wrapper ================================= // Use this data structure to associate callback data with each N-API function // exposed to JavaScript. The structure is stored in a v8::External which gets @@ -368,8 +368,8 @@ class CallbackBundle { public: // Creates an object to be made available to the static function callback // wrapper, used to retrieve the native callback function and data pointer. - static inline v8::Local New(napi_env env, - napi_callback cb, + static inline v8::Local New(JSVM_Env env, + JSVM_Callback cb, void* data) { CallbackBundle* bundle = new CallbackBundle(); bundle->cb = cb; @@ -381,12 +381,12 @@ class CallbackBundle { env, cbdata, 0, Ownership::kRuntime, Delete, bundle, nullptr); return cbdata; } - napi_env env; // Necessary to invoke C++ NAPI callback + JSVM_Env env; // Necessary to invoke C++ NAPI callback void* cb_data; // The user provided callback data - napi_callback cb; + JSVM_Callback cb; private: - static void Delete(napi_env env, void* data, void* hint) { + static void Delete(JSVM_Env env, void* data, void* hint) { CallbackBundle* bundle = static_cast(data); delete bundle; } @@ -396,21 +396,21 @@ class CallbackBundle { // info. class CallbackWrapper { public: - inline CallbackWrapper(napi_value this_arg, size_t args_length, void* data) - : _this(this_arg), _args_length(args_length), _data(data) {} + inline CallbackWrapper(JSVM_Value thisArg, size_t args_length, void* data) + : _this(thisArg), _args_length(args_length), _data(data) {} - virtual napi_value GetNewTarget() = 0; - virtual void Args(napi_value* buffer, size_t bufferlength) = 0; - virtual void SetReturnValue(napi_value value) = 0; + virtual JSVM_Value GetNewTarget() = 0; + virtual void Args(JSVM_Value* buffer, size_t bufferlength) = 0; + virtual void SetReturnValue(JSVM_Value value) = 0; - napi_value This() { return _this; } + JSVM_Value This() { return _this; } size_t ArgsLength() { return _args_length; } void* Data() { return _data; } protected: - const napi_value _this; + const JSVM_Value _this; const size_t _args_length; void* _data; }; @@ -429,17 +429,17 @@ class CallbackWrapperBase : public CallbackWrapper { protected: inline void InvokeCallback() { - napi_callback_info cbinfo_wrapper = reinterpret_cast( + JSVM_CallbackInfo cbinfo_wrapper = reinterpret_cast( static_cast(this)); // All other pointers we need are stored in `_bundle` - napi_env env = _bundle->env; - napi_callback cb = _bundle->cb; + JSVM_Env env = _bundle->env; + JSVM_Callback cb = _bundle->cb; - napi_value result = nullptr; + JSVM_Value result = nullptr; bool exceptionOccurred = false; - env->CallIntoModule([&](napi_env env) { result = cb(env, cbinfo_wrapper); }, - [&](napi_env env, v8::Local value) { + env->CallIntoModule([&](JSVM_Env env) { result = cb(env, cbinfo_wrapper); }, + [&](JSVM_Env env, v8::Local value) { exceptionOccurred = true; if (env->terminatedOrTerminating()) { return; @@ -463,39 +463,39 @@ class FunctionCallbackWrapper : public CallbackWrapperBase { cbwrapper.InvokeCallback(); } - static inline napi_status NewFunction(napi_env env, - napi_callback cb, + static inline JSVM_Status NewFunction(JSVM_Env env, + JSVM_Callback cb, void* cb_data, v8::Local* result) { v8::Local cbdata = v8impl::CallbackBundle::New(env, cb, cb_data); - RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure); + RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), JSVM_GENERIC_FAILURE); v8::MaybeLocal maybe_function = v8::Function::New(env->context(), Invoke, cbdata); - CHECK_MAYBE_EMPTY(env, maybe_function, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, maybe_function, JSVM_GENERIC_FAILURE); *result = maybe_function.ToLocalChecked(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } - static inline napi_status NewTemplate( - napi_env env, - napi_callback cb, + static inline JSVM_Status NewTemplate( + JSVM_Env env, + JSVM_Callback cb, void* cb_data, v8::Local* result, v8::Local sig = v8::Local()) { v8::Local cbdata = v8impl::CallbackBundle::New(env, cb, cb_data); - RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure); + RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), JSVM_GENERIC_FAILURE); *result = v8::FunctionTemplate::New(env->isolate, Invoke, cbdata, sig); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } explicit FunctionCallbackWrapper( const v8::FunctionCallbackInfo& cbinfo) : CallbackWrapperBase(cbinfo, cbinfo.Length()) {} - napi_value GetNewTarget() override { + JSVM_Value GetNewTarget() override { if (_cbinfo.IsConstructCall()) { return v8impl::JsValueFromV8LocalValue(_cbinfo.NewTarget()); } else { @@ -504,7 +504,7 @@ class FunctionCallbackWrapper : public CallbackWrapperBase { } /*virtual*/ - void Args(napi_value* buffer, size_t buffer_length) override { + void Args(JSVM_Value* buffer, size_t buffer_length) override { size_t i = 0; size_t min = std::min(buffer_length, _args_length); @@ -513,7 +513,7 @@ class FunctionCallbackWrapper : public CallbackWrapperBase { } if (i < buffer_length) { - napi_value undefined = + JSVM_Value undefined = v8impl::JsValueFromV8LocalValue(v8::Undefined(_cbinfo.GetIsolate())); for (; i < buffer_length; i += 1) { buffer[i] = undefined; @@ -522,48 +522,48 @@ class FunctionCallbackWrapper : public CallbackWrapperBase { } /*virtual*/ - void SetReturnValue(napi_value value) override { + void SetReturnValue(JSVM_Value value) override { v8::Local val = v8impl::V8LocalValueFromJsValue(value); _cbinfo.GetReturnValue().Set(val); } }; -inline napi_status Wrap(napi_env env, - napi_value js_object, - void* native_object, - napi_finalize finalize_cb, - void* finalize_hint, - napi_ref* result) { - NAPI_PREAMBLE(env); - CHECK_ARG(env, js_object); +inline JSVM_Status Wrap(JSVM_Env env, + JSVM_Value jsObject, + void* nativeObject, + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Ref* result) { + JSVM_PREAMBLE(env); + CHECK_ARG(env, jsObject); v8::Local context = env->context(); - v8::Local value = v8impl::V8LocalValueFromJsValue(js_object); - RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg); + v8::Local value = v8impl::V8LocalValueFromJsValue(jsObject); + RETURN_STATUS_IF_FALSE(env, value->IsObject(), JSVM_INVALID_ARG); v8::Local obj = value.As(); // If we've already wrapped this object, we error out. RETURN_STATUS_IF_FALSE( env, - !obj->HasPrivate(context, NAPI_PRIVATE_KEY(context, wrapper)).FromJust(), - napi_invalid_arg); + !obj->HasPrivate(context, JSVM_PRIVATE_KEY(context, wrapper)).FromJust(), + JSVM_INVALID_ARG); v8impl::Reference* reference = nullptr; if (result != nullptr) { - // The returned reference should be deleted via napi_delete_reference() + // The returned reference should be deleted via OH_JSVM_DeleteReference() // ONLY in response to the finalize callback invocation. (If it is deleted // before then, then the finalize callback will never be invoked.) // Therefore a finalize callback is required when returning a reference. - CHECK_ARG(env, finalize_cb); + CHECK_ARG(env, finalizeCb); reference = v8impl::Reference::New(env, obj, 0, v8impl::Ownership::kUserland, - finalize_cb, - native_object, - finalize_hint); - *result = reinterpret_cast(reference); + finalizeCb, + nativeObject, + finalizeHint); + *result = reinterpret_cast(reference); } else { // Create a self-deleting reference. reference = v8impl::Reference::New( @@ -571,13 +571,13 @@ inline napi_status Wrap(napi_env env, obj, 0, v8impl::Ownership::kRuntime, - finalize_cb, - native_object, - finalize_cb == nullptr ? nullptr : finalize_hint); + finalizeCb, + nativeObject, + finalizeCb == nullptr ? nullptr : finalizeHint); } CHECK(obj->SetPrivate(context, - NAPI_PRIVATE_KEY(context, wrapper), + JSVM_PRIVATE_KEY(context, wrapper), v8::External::New(env->isolate, reference)) .FromJust()); @@ -605,16 +605,16 @@ void Finalizer::ResetFinalizer() { } // Wrapper around v8impl::Persistent that implements reference counting. -RefBase::RefBase(napi_env env, +RefBase::RefBase(JSVM_Env env, uint32_t initial_refcount, Ownership ownership, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint) - : Finalizer(env, finalize_callback, finalize_data, finalize_hint), + JSVM_FINALIZE finalizeCallback, + void* finalizeData, + void* finalizeHint) + : Finalizer(env, finalizeCallback, finalizeData, finalizeHint), refcount_(initial_refcount), ownership_(ownership) { - Link(finalize_callback == nullptr ? &env->reflist : &env->finalizing_reflist); + Link(finalizeCallback == nullptr ? &env->reflist : &env->finalizing_reflist); } // When a RefBase is being deleted, it may have been queued to call its @@ -626,18 +626,18 @@ RefBase::~RefBase() { env_->DequeueFinalizer(this); } -RefBase* RefBase::New(napi_env env, +RefBase* RefBase::New(JSVM_Env env, uint32_t initial_refcount, Ownership ownership, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint) { + JSVM_FINALIZE finalizeCallback, + void* finalizeData, + void* finalizeHint) { return new RefBase(env, initial_refcount, ownership, - finalize_callback, - finalize_data, - finalize_hint); + finalizeCallback, + finalizeData, + finalizeHint); } void* RefBase::Data() { @@ -661,23 +661,23 @@ uint32_t RefBase::RefCount() { void RefBase::Finalize() { Ownership ownership = ownership_; - // Swap out the field finalize_callback so that it can not be accidentally + // Swap out the field finalizeCallback so that it can not be accidentally // called more than once. - napi_finalize finalize_callback = finalize_callback_; - void* finalize_data = finalize_data_; - void* finalize_hint = finalize_hint_; + JSVM_FINALIZE finalizeCallback = finalizeCallback_; + void* finalizeData = finalizeData_; + void* finalizeHint = finalizeHint_; ResetFinalizer(); - // Either the RefBase is going to be deleted in the finalize_callback or not, + // Either the RefBase is going to be deleted in the finalizeCallback or not, // it should be removed from the tracked list. Unlink(); - // 1. If the finalize_callback is present, it should either delete the + // 1. If the finalizeCallback is present, it should either delete the // RefBase, or set ownership with Ownership::kRuntime. // 2. If the finalizer is not present, the RefBase can be deleted after the // call. - if (finalize_callback != nullptr) { - env_->CallFinalizer(finalize_callback, finalize_data, finalize_hint); - // No access to `this` after finalize_callback is called. + if (finalizeCallback != nullptr) { + env_->CallFinalizer(finalizeCallback, finalizeData, finalizeHint); + // No access to `this` after finalizeCallback is called. } // If the RefBase is not Ownership::kRuntime, userland code should delete it. @@ -688,7 +688,7 @@ void RefBase::Finalize() { } template -Reference::Reference(napi_env env, v8::Local value, Args&&... args) +Reference::Reference(JSVM_Env env, v8::Local value, Args&&... args) : RefBase(env, std::forward(args)...), persistent_(env->isolate, value), can_be_weak_(CanBeHeldWeakly(value)) { @@ -702,20 +702,20 @@ Reference::~Reference() { persistent_.Reset(); } -Reference* Reference::New(napi_env env, +Reference* Reference::New(JSVM_Env env, v8::Local value, uint32_t initial_refcount, Ownership ownership, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint) { + JSVM_FINALIZE finalizeCallback, + void* finalizeData, + void* finalizeHint) { return new Reference(env, value, initial_refcount, ownership, - finalize_callback, - finalize_data, - finalize_hint); + finalizeCallback, + finalizeData, + finalizeHint); } uint32_t Reference::Ref() { @@ -784,7 +784,7 @@ void Reference::WeakCallback(const v8::WeakCallbackInfo& data) { } // end of namespace v8impl -// Warning: Keep in-sync with napi_status enum +// Warning: Keep in-sync with JSVM_Status enum static const char* error_messages[] = { nullptr, "Invalid argument", @@ -798,7 +798,7 @@ static const char* error_messages[] = { "Unknown failure", "An exception is pending", "The async work item was cancelled", - "napi_escape_handle already called on scope", + "OH_JSVM_EscapeHandle already called on scope", "Invalid handle scope usage", "Invalid callback scope usage", "Thread-safe function queue is full", @@ -812,38 +812,38 @@ static const char* error_messages[] = { "Cannot run JavaScript", }; -napi_status NAPI_CDECL napi_get_last_error_info( - napi_env env, const napi_extended_error_info** result) { +JSVM_Status JSVM_CDECL OH_JSVM_GetLastErrorInfo( + JSVM_Env env, const napi_extended_error_info** result) { CHECK_ENV(env); CHECK_ARG(env, result); // The value of the constant below must be updated to reference the last - // message in the `napi_status` enum each time a new error message is added. + // message in the `JSVM_Status` enum each time a new error message is added. // We don't have a napi_status_last as this would result in an ABI // change each time a message was added. - const int last_status = napi_cannot_run_js; + const int last_status = JSVM_CANNOT_RUN_JS; static_assert(NAPI_ARRAYSIZE(error_messages) == last_status + 1, "Count of error messages must match count of error values"); - CHECK_LE(env->last_error.error_code, last_status); + CHECK_LE(env->last_error.errorCode, last_status); // Wait until someone requests the last error information to fetch the error // message string - env->last_error.error_message = error_messages[env->last_error.error_code]; + env->last_error.errorMessage = errorMessages[env->last_error.errorCode]; - if (env->last_error.error_code == napi_ok) { - napi_clear_last_error(env); + if (env->last_error.errorCode == JSVM_OK) { + jsvm_clear_last_error(env); } *result = &(env->last_error); - return napi_ok; + return JSVM_OK; } -napi_status NAPI_CDECL napi_create_function(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateFunction(JSVM_Env env, const char* utf8name, size_t length, - napi_callback cb, - void* callback_data, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_Callback cb, + void* callbackData, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); CHECK_ARG(env, cb); @@ -851,7 +851,7 @@ napi_status NAPI_CDECL napi_create_function(napi_env env, v8::EscapableHandleScope scope(env->isolate); v8::Local fn; STATUS_CALL(v8impl::FunctionCallbackWrapper::NewFunction( - env, cb, callback_data, &fn)); + env, cb, callbackData, &fn)); return_value = scope.Escape(fn); if (utf8name != nullptr) { @@ -865,20 +865,20 @@ napi_status NAPI_CDECL napi_create_function(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL -napi_define_class(napi_env env, +JSVM_Status JSVM_CDECL +OH_JSVM_DefineClass(JSVM_Env env, const char* utf8name, size_t length, - napi_callback constructor, - void* callback_data, - size_t property_count, - const napi_property_descriptor* properties, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_Callback constructor, + void* callbackData, + size_t propertyCount, + const JSVM_PropertyDescriptor* properties, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); CHECK_ARG(env, constructor); - if (property_count > 0) { + if (propertyCount > 0) { CHECK_ARG(env, properties); } @@ -887,17 +887,17 @@ napi_define_class(napi_env env, v8::EscapableHandleScope scope(isolate); v8::Local tpl; STATUS_CALL(v8impl::FunctionCallbackWrapper::NewTemplate( - env, constructor, callback_data, &tpl)); + env, constructor, callbackData, &tpl)); v8::Local name_string; CHECK_NEW_FROM_UTF8_LEN(env, name_string, utf8name, length); tpl->SetClassName(name_string); size_t static_property_count = 0; - for (size_t i = 0; i < property_count; i++) { - const napi_property_descriptor* p = properties + i; + for (size_t i = 0; i < propertyCount; i++) { + const JSVM_PropertyDescriptor* p = properties + i; - if ((p->attributes & napi_static) != 0) { + if ((p->attributes & JSVM_STATIC) != 0) { // Static properties are handled separately below. static_property_count++; continue; @@ -909,7 +909,7 @@ napi_define_class(napi_env env, v8::PropertyAttribute attributes = v8impl::V8PropertyAttributesFromDescriptor(p); - // This code is similar to that in napi_define_properties(); the + // This code is similar to that in OH_JSVM_DefineProperties(); the // difference is it applies to a template instead of an object, // and preferred PropertyAttribute for lack of PropertyDescriptor // support on ObjectTemplate. @@ -947,43 +947,43 @@ napi_define_class(napi_env env, scope.Escape(tpl->GetFunction(context).ToLocalChecked())); if (static_property_count > 0) { - std::vector static_descriptors; + std::vector static_descriptors; static_descriptors.reserve(static_property_count); - for (size_t i = 0; i < property_count; i++) { - const napi_property_descriptor* p = properties + i; - if ((p->attributes & napi_static) != 0) { + for (size_t i = 0; i < propertyCount; i++) { + const JSVM_PropertyDescriptor* p = properties + i; + if ((p->attributes & JSVM_STATIC) != 0) { static_descriptors.push_back(*p); } } - STATUS_CALL(napi_define_properties( + STATUS_CALL(OH_JSVM_DefineProperties( env, *result, static_descriptors.size(), static_descriptors.data())); } return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_get_property_names(napi_env env, - napi_value object, - napi_value* result) { - return napi_get_all_property_names( +JSVM_Status JSVM_CDECL OH_JSVM_GetPropertyNames(JSVM_Env env, + JSVM_Value object, + JSVM_Value* result) { + return OH_JSVM_GetAllPropertyNames( env, object, - napi_key_include_prototypes, - static_cast(napi_key_enumerable | napi_key_skip_symbols), - napi_key_numbers_to_strings, + JSVM_KEY_INCLUDE_PROTOTYPES, + static_cast(JSVM_KEY_ENUMERABLE | JSVM_KEY_SKIP_SYMBOLS), + JSVM_KEY_NUMBERS_TO_STRINGS, result); } -napi_status NAPI_CDECL -napi_get_all_property_names(napi_env env, - napi_value object, - napi_key_collection_mode key_mode, - napi_key_filter key_filter, - napi_key_conversion key_conversion, - napi_value* result) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL +OH_JSVM_GetAllPropertyNames(JSVM_Env env, + JSVM_Value object, + JSVM_KeyCollectionMode keyMode, + JSVM_KeyFilter keyFilter, + JSVM_KEY_ConVersion keyConversion, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::Local context = env->context(); @@ -991,49 +991,49 @@ napi_get_all_property_names(napi_env env, CHECK_TO_OBJECT(env, context, obj, object); v8::PropertyFilter filter = v8::PropertyFilter::ALL_PROPERTIES; - if (key_filter & napi_key_writable) { + if (keyFilter & JSVM_KEY_WRITABLE) { filter = static_cast(filter | v8::PropertyFilter::ONLY_WRITABLE); } - if (key_filter & napi_key_enumerable) { + if (keyFilter & JSVM_KEY_ENUMERABLE) { filter = static_cast( filter | v8::PropertyFilter::ONLY_ENUMERABLE); } - if (key_filter & napi_key_configurable) { + if (keyFilter & JSVM_KEY_CONFIGURABLE) { filter = static_cast( filter | v8::PropertyFilter::ONLY_CONFIGURABLE); } - if (key_filter & napi_key_skip_strings) { + if (keyFilter & JSVM_KEY_SKIP_STRINGS) { filter = static_cast(filter | v8::PropertyFilter::SKIP_STRINGS); } - if (key_filter & napi_key_skip_symbols) { + if (keyFilter & JSVM_KEY_SKIP_SYMBOLS) { filter = static_cast(filter | v8::PropertyFilter::SKIP_SYMBOLS); } v8::KeyCollectionMode collection_mode; v8::KeyConversionMode conversion_mode; - switch (key_mode) { - case napi_key_include_prototypes: + switch (keyMode) { + case JSVM_KEY_INCLUDE_PROTOTYPES: collection_mode = v8::KeyCollectionMode::kIncludePrototypes; break; - case napi_key_own_only: + case JSVM_KEY_OWN_ONLY: collection_mode = v8::KeyCollectionMode::kOwnOnly; break; default: - return napi_set_last_error(env, napi_invalid_arg); + return jsvm_set_last_error(env, JSVM_INVALID_ARG); } - switch (key_conversion) { - case napi_key_keep_numbers: + switch (keyConversion) { + case JSVM_KEY_KEEP_NUMBERS: conversion_mode = v8::KeyConversionMode::kKeepNumbers; break; - case napi_key_numbers_to_strings: + case JSVM_KEY_NUMBERS_TO_STRINGS: conversion_mode = v8::KeyConversionMode::kConvertToString; break; default: - return napi_set_last_error(env, napi_invalid_arg); + return jsvm_set_last_error(env, JSVM_INVALID_ARG); } v8::MaybeLocal maybe_all_propertynames = @@ -1044,18 +1044,18 @@ napi_get_all_property_names(napi_env env, conversion_mode); CHECK_MAYBE_EMPTY_WITH_PREAMBLE( - env, maybe_all_propertynames, napi_generic_failure); + env, maybe_all_propertynames, JSVM_GENERIC_FAILURE); *result = v8impl::JsValueFromV8LocalValue(maybe_all_propertynames.ToLocalChecked()); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_set_property(napi_env env, - napi_value object, - napi_value key, - napi_value value) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_SetProperty(JSVM_Env env, + JSVM_Value object, + JSVM_Value key, + JSVM_Value value) { + JSVM_PREAMBLE(env); CHECK_ARG(env, key); CHECK_ARG(env, value); @@ -1069,15 +1069,15 @@ napi_status NAPI_CDECL napi_set_property(napi_env env, v8::Maybe set_maybe = obj->Set(context, k, val); - RETURN_STATUS_IF_FALSE(env, set_maybe.FromMaybe(false), napi_generic_failure); + RETURN_STATUS_IF_FALSE(env, set_maybe.FromMaybe(false), JSVM_GENERIC_FAILURE); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_has_property(napi_env env, - napi_value object, - napi_value key, +JSVM_Status JSVM_CDECL OH_JSVM_HasProperty(JSVM_Env env, + JSVM_Value object, + JSVM_Value key, bool* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); CHECK_ARG(env, result); CHECK_ARG(env, key); @@ -1089,17 +1089,17 @@ napi_status NAPI_CDECL napi_has_property(napi_env env, v8::Local k = v8impl::V8LocalValueFromJsValue(key); v8::Maybe has_maybe = obj->Has(context, k); - CHECK_MAYBE_NOTHING(env, has_maybe, napi_generic_failure); + CHECK_MAYBE_NOTHING(env, has_maybe, JSVM_GENERIC_FAILURE); *result = has_maybe.FromMaybe(false); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_get_property(napi_env env, - napi_value object, - napi_value key, - napi_value* result) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_GetProperty(JSVM_Env env, + JSVM_Value object, + JSVM_Value key, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, key); CHECK_ARG(env, result); @@ -1111,18 +1111,18 @@ napi_status NAPI_CDECL napi_get_property(napi_env env, auto get_maybe = obj->Get(context, k); - CHECK_MAYBE_EMPTY(env, get_maybe, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, get_maybe, JSVM_GENERIC_FAILURE); v8::Local val = get_maybe.ToLocalChecked(); *result = v8impl::JsValueFromV8LocalValue(val); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_delete_property(napi_env env, - napi_value object, - napi_value key, +JSVM_Status JSVM_CDECL OH_JSVM_DeleteProperty(JSVM_Env env, + JSVM_Value object, + JSVM_Value key, bool* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); CHECK_ARG(env, key); v8::Local context = env->context(); @@ -1131,18 +1131,18 @@ napi_status NAPI_CDECL napi_delete_property(napi_env env, CHECK_TO_OBJECT(env, context, obj, object); v8::Maybe delete_maybe = obj->Delete(context, k); - CHECK_MAYBE_NOTHING(env, delete_maybe, napi_generic_failure); + CHECK_MAYBE_NOTHING(env, delete_maybe, JSVM_GENERIC_FAILURE); if (result != nullptr) *result = delete_maybe.FromMaybe(false); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_has_own_property(napi_env env, - napi_value object, - napi_value key, +JSVM_Status JSVM_CDECL OH_JSVM_HasOwnProperty(JSVM_Env env, + JSVM_Value object, + JSVM_Value key, bool* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); CHECK_ARG(env, key); CHECK_ARG(env, result); @@ -1151,19 +1151,19 @@ napi_status NAPI_CDECL napi_has_own_property(napi_env env, CHECK_TO_OBJECT(env, context, obj, object); v8::Local k = v8impl::V8LocalValueFromJsValue(key); - RETURN_STATUS_IF_FALSE(env, k->IsName(), napi_name_expected); + RETURN_STATUS_IF_FALSE(env, k->IsName(), JSVM_NAME_EXPECTED); v8::Maybe has_maybe = obj->HasOwnProperty(context, k.As()); - CHECK_MAYBE_NOTHING(env, has_maybe, napi_generic_failure); + CHECK_MAYBE_NOTHING(env, has_maybe, JSVM_GENERIC_FAILURE); *result = has_maybe.FromMaybe(false); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_set_named_property(napi_env env, - napi_value object, +JSVM_Status JSVM_CDECL OH_JSVM_SetNamedProperty(JSVM_Env env, + JSVM_Value object, const char* utf8name, - napi_value value) { - NAPI_PREAMBLE(env); + JSVM_Value value) { + JSVM_PREAMBLE(env); CHECK_ARG(env, value); v8::Local context = env->context(); @@ -1178,15 +1178,15 @@ napi_status NAPI_CDECL napi_set_named_property(napi_env env, v8::Maybe set_maybe = obj->Set(context, key, val); - RETURN_STATUS_IF_FALSE(env, set_maybe.FromMaybe(false), napi_generic_failure); + RETURN_STATUS_IF_FALSE(env, set_maybe.FromMaybe(false), JSVM_GENERIC_FAILURE); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_has_named_property(napi_env env, - napi_value object, +JSVM_Status JSVM_CDECL OH_JSVM_HasNamedProperty(JSVM_Env env, + JSVM_Value object, const char* utf8name, bool* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::Local context = env->context(); @@ -1199,17 +1199,17 @@ napi_status NAPI_CDECL napi_has_named_property(napi_env env, v8::Maybe has_maybe = obj->Has(context, key); - CHECK_MAYBE_NOTHING(env, has_maybe, napi_generic_failure); + CHECK_MAYBE_NOTHING(env, has_maybe, JSVM_GENERIC_FAILURE); *result = has_maybe.FromMaybe(false); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_get_named_property(napi_env env, - napi_value object, +JSVM_Status JSVM_CDECL OH_JSVM_GetNamedProperty(JSVM_Env env, + JSVM_Value object, const char* utf8name, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::Local context = env->context(); @@ -1223,18 +1223,18 @@ napi_status NAPI_CDECL napi_get_named_property(napi_env env, auto get_maybe = obj->Get(context, key); - CHECK_MAYBE_EMPTY(env, get_maybe, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, get_maybe, JSVM_GENERIC_FAILURE); v8::Local val = get_maybe.ToLocalChecked(); *result = v8impl::JsValueFromV8LocalValue(val); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_set_element(napi_env env, - napi_value object, +JSVM_Status JSVM_CDECL OH_JSVM_SetElement(JSVM_Env env, + JSVM_Value object, uint32_t index, - napi_value value) { - NAPI_PREAMBLE(env); + JSVM_Value value) { + JSVM_PREAMBLE(env); CHECK_ARG(env, value); v8::Local context = env->context(); @@ -1245,16 +1245,16 @@ napi_status NAPI_CDECL napi_set_element(napi_env env, v8::Local val = v8impl::V8LocalValueFromJsValue(value); auto set_maybe = obj->Set(context, index, val); - RETURN_STATUS_IF_FALSE(env, set_maybe.FromMaybe(false), napi_generic_failure); + RETURN_STATUS_IF_FALSE(env, set_maybe.FromMaybe(false), JSVM_GENERIC_FAILURE); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_has_element(napi_env env, - napi_value object, +JSVM_Status JSVM_CDECL OH_JSVM_HasElement(JSVM_Env env, + JSVM_Value object, uint32_t index, bool* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::Local context = env->context(); @@ -1264,17 +1264,17 @@ napi_status NAPI_CDECL napi_has_element(napi_env env, v8::Maybe has_maybe = obj->Has(context, index); - CHECK_MAYBE_NOTHING(env, has_maybe, napi_generic_failure); + CHECK_MAYBE_NOTHING(env, has_maybe, JSVM_GENERIC_FAILURE); *result = has_maybe.FromMaybe(false); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_get_element(napi_env env, - napi_value object, +JSVM_Status JSVM_CDECL OH_JSVM_GetElement(JSVM_Env env, + JSVM_Value object, uint32_t index, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::Local context = env->context(); @@ -1284,37 +1284,37 @@ napi_status NAPI_CDECL napi_get_element(napi_env env, auto get_maybe = obj->Get(context, index); - CHECK_MAYBE_EMPTY(env, get_maybe, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, get_maybe, JSVM_GENERIC_FAILURE); *result = v8impl::JsValueFromV8LocalValue(get_maybe.ToLocalChecked()); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_delete_element(napi_env env, - napi_value object, +JSVM_Status JSVM_CDECL OH_JSVM_DeleteElement(JSVM_Env env, + JSVM_Value object, uint32_t index, bool* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); v8::Local context = env->context(); v8::Local obj; CHECK_TO_OBJECT(env, context, obj, object); v8::Maybe delete_maybe = obj->Delete(context, index); - CHECK_MAYBE_NOTHING(env, delete_maybe, napi_generic_failure); + CHECK_MAYBE_NOTHING(env, delete_maybe, JSVM_GENERIC_FAILURE); if (result != nullptr) *result = delete_maybe.FromMaybe(false); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL -napi_define_properties(napi_env env, - napi_value object, - size_t property_count, - const napi_property_descriptor* properties) { - NAPI_PREAMBLE(env); - if (property_count > 0) { +JSVM_Status JSVM_CDECL +OH_JSVM_DefineProperties(JSVM_Env env, + JSVM_Value object, + size_t propertyCount, + const JSVM_PropertyDescriptor* properties) { + JSVM_PREAMBLE(env); + if (propertyCount > 0) { CHECK_ARG(env, properties); } @@ -1323,8 +1323,8 @@ napi_define_properties(napi_env env, v8::Local obj; CHECK_TO_OBJECT(env, context, obj, object); - for (size_t i = 0; i < property_count; i++) { - const napi_property_descriptor* p = &properties[i]; + for (size_t i = 0; i < propertyCount; i++) { + const JSVM_PropertyDescriptor* p = &properties[i]; v8::Local property_name; STATUS_CALL(v8impl::V8NameFromPropertyDescriptor(env, p, &property_name)); @@ -1343,46 +1343,46 @@ napi_define_properties(napi_env env, } v8::PropertyDescriptor descriptor(local_getter, local_setter); - descriptor.set_enumerable((p->attributes & napi_enumerable) != 0); - descriptor.set_configurable((p->attributes & napi_configurable) != 0); + descriptor.set_enumerable((p->attributes & JSVM_ENUMERABLE) != 0); + descriptor.set_configurable((p->attributes & JSVM_CONFIGURABLE) != 0); auto define_maybe = obj->DefineProperty(context, property_name, descriptor); if (!define_maybe.FromMaybe(false)) { - return napi_set_last_error(env, napi_invalid_arg); + return jsvm_set_last_error(env, JSVM_INVALID_ARG); } } else if (p->method != nullptr) { v8::Local method; STATUS_CALL(v8impl::FunctionCallbackWrapper::NewFunction( env, p->method, p->data, &method)); v8::PropertyDescriptor descriptor(method, - (p->attributes & napi_writable) != 0); - descriptor.set_enumerable((p->attributes & napi_enumerable) != 0); - descriptor.set_configurable((p->attributes & napi_configurable) != 0); + (p->attributes & JSVM_WRITABLE) != 0); + descriptor.set_enumerable((p->attributes & JSVM_ENUMERABLE) != 0); + descriptor.set_configurable((p->attributes & JSVM_CONFIGURABLE) != 0); auto define_maybe = obj->DefineProperty(context, property_name, descriptor); if (!define_maybe.FromMaybe(false)) { - return napi_set_last_error(env, napi_generic_failure); + return jsvm_set_last_error(env, JSVM_GENERIC_FAILURE); } } else { v8::Local value = v8impl::V8LocalValueFromJsValue(p->value); bool defined_successfully = false; - if ((p->attributes & napi_enumerable) && - (p->attributes & napi_writable) && - (p->attributes & napi_configurable)) { + if ((p->attributes & JSVM_ENUMERABLE) && + (p->attributes & JSVM_WRITABLE) && + (p->attributes & JSVM_CONFIGURABLE)) { // Use a fast path for this type of data property. auto define_maybe = obj->CreateDataProperty(context, property_name, value); defined_successfully = define_maybe.FromMaybe(false); } else { v8::PropertyDescriptor descriptor(value, - (p->attributes & napi_writable) != 0); - descriptor.set_enumerable((p->attributes & napi_enumerable) != 0); - descriptor.set_configurable((p->attributes & napi_configurable) != 0); + (p->attributes & JSVM_WRITABLE) != 0); + descriptor.set_enumerable((p->attributes & JSVM_ENUMERABLE) != 0); + descriptor.set_configurable((p->attributes & JSVM_CONFIGURABLE) != 0); auto define_maybe = obj->DefineProperty(context, property_name, descriptor); @@ -1390,7 +1390,7 @@ napi_define_properties(napi_env env, } if (!defined_successfully) { - return napi_set_last_error(env, napi_invalid_arg); + return jsvm_set_last_error(env, JSVM_INVALID_ARG); } } } @@ -1398,8 +1398,8 @@ napi_define_properties(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_object_freeze(napi_env env, napi_value object) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_ObjectFreeze(JSVM_Env env, JSVM_Value object) { + JSVM_PREAMBLE(env); v8::Local context = env->context(); v8::Local obj; @@ -1410,13 +1410,13 @@ napi_status NAPI_CDECL napi_object_freeze(napi_env env, napi_value object) { obj->SetIntegrityLevel(context, v8::IntegrityLevel::kFrozen); RETURN_STATUS_IF_FALSE_WITH_PREAMBLE( - env, set_frozen.FromMaybe(false), napi_generic_failure); + env, set_frozen.FromMaybe(false), JSVM_GENERIC_FAILURE); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_object_seal(napi_env env, napi_value object) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_ObjectSeal(JSVM_Env env, JSVM_Value object) { + JSVM_PREAMBLE(env); v8::Local context = env->context(); v8::Local obj; @@ -1427,13 +1427,13 @@ napi_status NAPI_CDECL napi_object_seal(napi_env env, napi_value object) { obj->SetIntegrityLevel(context, v8::IntegrityLevel::kSealed); RETURN_STATUS_IF_FALSE_WITH_PREAMBLE( - env, set_sealed.FromMaybe(false), napi_generic_failure); + env, set_sealed.FromMaybe(false), JSVM_GENERIC_FAILURE); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_is_array(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_IsArray(JSVM_Env env, + JSVM_Value value, bool* result) { CHECK_ENV(env); CHECK_ARG(env, value); @@ -1442,18 +1442,18 @@ napi_status NAPI_CDECL napi_is_array(napi_env env, v8::Local val = v8impl::V8LocalValueFromJsValue(value); *result = val->IsArray(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_array_length(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetArrayLength(JSVM_Env env, + JSVM_Value value, uint32_t* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); CHECK_ARG(env, value); CHECK_ARG(env, result); v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsArray(), napi_array_expected); + RETURN_STATUS_IF_FALSE(env, val->IsArray(), JSVM_ARRAY_EXPECTED); v8::Local arr = val.As(); *result = arr->Length(); @@ -1461,11 +1461,11 @@ napi_status NAPI_CDECL napi_get_array_length(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_strict_equals(napi_env env, - napi_value lhs, - napi_value rhs, +JSVM_Status JSVM_CDECL OH_JSVM_StrictEquals(JSVM_Env env, + JSVM_Value lhs, + JSVM_Value rhs, bool* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); CHECK_ARG(env, lhs); CHECK_ARG(env, rhs); CHECK_ARG(env, result); @@ -1477,10 +1477,10 @@ napi_status NAPI_CDECL napi_strict_equals(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_get_prototype(napi_env env, - napi_value object, - napi_value* result) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_GetPrototype(JSVM_Env env, + JSVM_Value object, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::Local context = env->context(); @@ -1493,40 +1493,40 @@ napi_status NAPI_CDECL napi_get_prototype(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_create_object(napi_env env, napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_CreateObject(JSVM_Env env, JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue(v8::Object::New(env->isolate)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_array(napi_env env, napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_CreateArray(JSVM_Env env, JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue(v8::Array::New(env->isolate)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_array_with_length(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateArrayWithLength(JSVM_Env env, size_t length, - napi_value* result) { + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue(v8::Array::New(env->isolate, length)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_string_latin1(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateStringLatin1(JSVM_Env env, const char* str, size_t length, - napi_value* result) { + JSVM_Value* result) { return v8impl::NewString(env, str, length, result, [&](v8::Isolate* isolate) { return v8::String::NewFromOneByte(isolate, reinterpret_cast(str), @@ -1535,20 +1535,20 @@ napi_status NAPI_CDECL napi_create_string_latin1(napi_env env, }); } -napi_status NAPI_CDECL napi_create_string_utf8(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateStringUtf8(JSVM_Env env, const char* str, size_t length, - napi_value* result) { + JSVM_Value* result) { return v8impl::NewString(env, str, length, result, [&](v8::Isolate* isolate) { return v8::String::NewFromUtf8( isolate, str, v8::NewStringType::kNormal, static_cast(length)); }); } -napi_status NAPI_CDECL napi_create_string_utf16(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateStringUtf16(JSVM_Env env, const char16_t* str, size_t length, - napi_value* result) { + JSVM_Value* result) { return v8impl::NewString(env, str, length, result, [&](v8::Isolate* isolate) { return v8::String::NewFromTwoByte(isolate, reinterpret_cast(str), @@ -1557,157 +1557,157 @@ napi_status NAPI_CDECL napi_create_string_utf16(napi_env env, }); } -napi_status NAPI_CDECL -node_api_create_external_string_latin1(napi_env env, +JSVM_Status JSVM_CDECL +node_api_create_external_string_latin1(JSVM_Env env, char* str, size_t length, - napi_finalize finalize_callback, - void* finalize_hint, - napi_value* result, + JSVM_FINALIZE finalizeCallback, + void* finalizeHint, + JSVM_Value* result, bool* copied) { return v8impl::NewExternalString( env, str, length, - finalize_callback, - finalize_hint, + finalizeCallback, + finalizeHint, result, copied, - napi_create_string_latin1, + OH_JSVM_CreateStringLatin1, [&](v8::Isolate* isolate) { - if (length == NAPI_AUTO_LENGTH) { + if (length == JSVM_AUTO_LENGTH) { length = (std::string_view(str)).length(); } auto resource = new v8impl::ExternalOneByteStringResource( - env, str, length, finalize_callback, finalize_hint); + env, str, length, finalizeCallback, finalizeHint); return v8::String::NewExternalOneByte(isolate, resource); }); } -napi_status NAPI_CDECL -node_api_create_external_string_utf16(napi_env env, +JSVM_Status JSVM_CDECL +node_api_create_external_string_utf16(JSVM_Env env, char16_t* str, size_t length, - napi_finalize finalize_callback, - void* finalize_hint, - napi_value* result, + JSVM_FINALIZE finalizeCallback, + void* finalizeHint, + JSVM_Value* result, bool* copied) { return v8impl::NewExternalString( env, str, length, - finalize_callback, - finalize_hint, + finalizeCallback, + finalizeHint, result, copied, - napi_create_string_utf16, + OH_JSVM_CreateStringUtf16, [&](v8::Isolate* isolate) { - if (length == NAPI_AUTO_LENGTH) { + if (length == JSVM_AUTO_LENGTH) { length = (std::u16string_view(str)).length(); } auto resource = new v8impl::ExternalStringResource( - env, str, length, finalize_callback, finalize_hint); + env, str, length, finalizeCallback, finalizeHint); return v8::String::NewExternalTwoByte(isolate, resource); }); } -napi_status NAPI_CDECL napi_create_double(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateDouble(JSVM_Env env, double value, - napi_value* result) { + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue(v8::Number::New(env->isolate, value)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_int32(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateInt32(JSVM_Env env, int32_t value, - napi_value* result) { + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue(v8::Integer::New(env->isolate, value)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_uint32(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateUint32(JSVM_Env env, uint32_t value, - napi_value* result) { + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue( v8::Integer::NewFromUnsigned(env->isolate, value)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_int64(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateInt64(JSVM_Env env, int64_t value, - napi_value* result) { + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue( v8::Number::New(env->isolate, static_cast(value))); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_bigint_int64(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateBigintInt64(JSVM_Env env, int64_t value, - napi_value* result) { + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue(v8::BigInt::New(env->isolate, value)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_bigint_uint64(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateBigintUint64(JSVM_Env env, uint64_t value, - napi_value* result) { + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue( v8::BigInt::NewFromUnsigned(env->isolate, value)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_bigint_words(napi_env env, - int sign_bit, - size_t word_count, +JSVM_Status JSVM_CDECL OH_JSVM_CreateBigintWords(JSVM_Env env, + int signBit, + size_t wordCount, const uint64_t* words, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, words); CHECK_ARG(env, result); v8::Local context = env->context(); - RETURN_STATUS_IF_FALSE(env, word_count <= INT_MAX, napi_invalid_arg); + RETURN_STATUS_IF_FALSE(env, wordCount <= INT_MAX, JSVM_INVALID_ARG); v8::MaybeLocal b = - v8::BigInt::NewFromWords(context, sign_bit, word_count, words); + v8::BigInt::NewFromWords(context, signBit, wordCount, words); - CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, b, napi_generic_failure); + CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, b, JSVM_GENERIC_FAILURE); *result = v8impl::JsValueFromV8LocalValue(b.ToLocalChecked()); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_get_boolean(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_GetBoolean(JSVM_Env env, bool value, - napi_value* result) { + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); @@ -1719,12 +1719,12 @@ napi_status NAPI_CDECL napi_get_boolean(napi_env env, *result = v8impl::JsValueFromV8LocalValue(v8::False(isolate)); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_symbol(napi_env env, - napi_value description, - napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_CreateSymbol(JSVM_Env env, + JSVM_Value description, + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); @@ -1734,24 +1734,24 @@ napi_status NAPI_CDECL napi_create_symbol(napi_env env, *result = v8impl::JsValueFromV8LocalValue(v8::Symbol::New(isolate)); } else { v8::Local desc = v8impl::V8LocalValueFromJsValue(description); - RETURN_STATUS_IF_FALSE(env, desc->IsString(), napi_string_expected); + RETURN_STATUS_IF_FALSE(env, desc->IsString(), JSVM_STRING_EXPECTED); *result = v8impl::JsValueFromV8LocalValue( v8::Symbol::New(isolate, desc.As())); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL node_api_symbol_for(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_SymbolFor(JSVM_Env env, const char* utf8description, size_t length, - napi_value* result) { + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); - napi_value js_description_string; - STATUS_CALL(napi_create_string_utf8( + JSVM_Value js_description_string; + STATUS_CALL(OH_JSVM_CreateStringUtf8( env, utf8description, length, &js_description_string)); v8::Local description_string = v8impl::V8LocalValueFromJsValue(js_description_string).As(); @@ -1759,12 +1759,12 @@ napi_status NAPI_CDECL node_api_symbol_for(napi_env env, *result = v8impl::JsValueFromV8LocalValue( v8::Symbol::For(env->isolate, description_string)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -static inline napi_status set_error_code(napi_env env, +static inline JSVM_Status set_error_code(JSVM_Env env, v8::Local error, - napi_value code, + JSVM_Value code, const char* code_cstring) { if ((code != nullptr) || (code_cstring != nullptr)) { v8::Local context = env->context(); @@ -1773,7 +1773,7 @@ static inline napi_status set_error_code(napi_env env, v8::Local code_value = v8impl::V8LocalValueFromJsValue(code); if (code != nullptr) { code_value = v8impl::V8LocalValueFromJsValue(code); - RETURN_STATUS_IF_FALSE(env, code_value->IsString(), napi_string_expected); + RETURN_STATUS_IF_FALSE(env, code_value->IsString(), JSVM_STRING_EXPECTED); } else { CHECK_NEW_FROM_UTF8(env, code_value, code_cstring); } @@ -1783,21 +1783,21 @@ static inline napi_status set_error_code(napi_env env, v8::Maybe set_maybe = err_object->Set(context, code_key, code_value); RETURN_STATUS_IF_FALSE( - env, set_maybe.FromMaybe(false), napi_generic_failure); + env, set_maybe.FromMaybe(false), JSVM_GENERIC_FAILURE); } - return napi_ok; + return JSVM_OK; } -napi_status NAPI_CDECL napi_create_error(napi_env env, - napi_value code, - napi_value msg, - napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_CreateError(JSVM_Env env, + JSVM_Value code, + JSVM_Value msg, + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, msg); CHECK_ARG(env, result); v8::Local message_value = v8impl::V8LocalValueFromJsValue(msg); - RETURN_STATUS_IF_FALSE(env, message_value->IsString(), napi_string_expected); + RETURN_STATUS_IF_FALSE(env, message_value->IsString(), JSVM_STRING_EXPECTED); v8::Local error_obj = v8::Exception::Error(message_value.As()); @@ -1805,19 +1805,19 @@ napi_status NAPI_CDECL napi_create_error(napi_env env, *result = v8impl::JsValueFromV8LocalValue(error_obj); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_type_error(napi_env env, - napi_value code, - napi_value msg, - napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_CreateTypeError(JSVM_Env env, + JSVM_Value code, + JSVM_Value msg, + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, msg); CHECK_ARG(env, result); v8::Local message_value = v8impl::V8LocalValueFromJsValue(msg); - RETURN_STATUS_IF_FALSE(env, message_value->IsString(), napi_string_expected); + RETURN_STATUS_IF_FALSE(env, message_value->IsString(), JSVM_STRING_EXPECTED); v8::Local error_obj = v8::Exception::TypeError(message_value.As()); @@ -1825,19 +1825,19 @@ napi_status NAPI_CDECL napi_create_type_error(napi_env env, *result = v8impl::JsValueFromV8LocalValue(error_obj); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_range_error(napi_env env, - napi_value code, - napi_value msg, - napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_CreateRangeError(JSVM_Env env, + JSVM_Value code, + JSVM_Value msg, + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, msg); CHECK_ARG(env, result); v8::Local message_value = v8impl::V8LocalValueFromJsValue(msg); - RETURN_STATUS_IF_FALSE(env, message_value->IsString(), napi_string_expected); + RETURN_STATUS_IF_FALSE(env, message_value->IsString(), JSVM_STRING_EXPECTED); v8::Local error_obj = v8::Exception::RangeError(message_value.As()); @@ -1845,19 +1845,19 @@ napi_status NAPI_CDECL napi_create_range_error(napi_env env, *result = v8impl::JsValueFromV8LocalValue(error_obj); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL node_api_create_syntax_error(napi_env env, - napi_value code, - napi_value msg, - napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_CreateSyntaxError(JSVM_Env env, + JSVM_Value code, + JSVM_Value msg, + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, msg); CHECK_ARG(env, result); v8::Local message_value = v8impl::V8LocalValueFromJsValue(msg); - RETURN_STATUS_IF_FALSE(env, message_value->IsString(), napi_string_expected); + RETURN_STATUS_IF_FALSE(env, message_value->IsString(), JSVM_STRING_EXPECTED); v8::Local error_obj = v8::Exception::SyntaxError(message_value.As()); @@ -1865,13 +1865,13 @@ napi_status NAPI_CDECL node_api_create_syntax_error(napi_env env, *result = v8impl::JsValueFromV8LocalValue(error_obj); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_typeof(napi_env env, - napi_value value, - napi_valuetype* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw +JSVM_Status JSVM_CDECL OH_JSVM_Typeof(JSVM_Env env, + JSVM_Value value, + JSVM_ValueType* result) { + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, value); @@ -1880,63 +1880,63 @@ napi_status NAPI_CDECL napi_typeof(napi_env env, v8::Local v = v8impl::V8LocalValueFromJsValue(value); if (v->IsNumber()) { - *result = napi_number; + *result = JSVM_NUMBER; } else if (v->IsBigInt()) { - *result = napi_bigint; + *result = JSVM_BIGINT; } else if (v->IsString()) { - *result = napi_string; + *result = JSVM_STRING; } else if (v->IsFunction()) { // This test has to come before IsObject because IsFunction // implies IsObject - *result = napi_function; + *result = JSVM_FUNCTION; } else if (v->IsExternal()) { // This test has to come before IsObject because IsExternal // implies IsObject - *result = napi_external; + *result = JSVM_EXTERNAL; } else if (v->IsObject()) { - *result = napi_object; + *result = JSVM_OBJECT; } else if (v->IsBoolean()) { - *result = napi_boolean; + *result = JSVM_BOOLEAN; } else if (v->IsUndefined()) { - *result = napi_undefined; + *result = JSVM_UNDEFINED; } else if (v->IsSymbol()) { - *result = napi_symbol; + *result = JSVM_SYMBOL; } else if (v->IsNull()) { - *result = napi_null; + *result = JSVM_NULL; } else { // Should not get here unless V8 has added some new kind of value. - return napi_set_last_error(env, napi_invalid_arg); + return jsvm_set_last_error(env, JSVM_INVALID_ARG); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_undefined(napi_env env, napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_GetUndefined(JSVM_Env env, JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue(v8::Undefined(env->isolate)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_null(napi_env env, napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_GetNull(JSVM_Env env, JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue(v8::Null(env->isolate)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } // Gets all callback info in a single call. (Ugly, but faster.) -napi_status NAPI_CDECL napi_get_cb_info( - napi_env env, // [in] NAPI environment handle - napi_callback_info cbinfo, // [in] Opaque callback-info handle +JSVM_Status JSVM_CDECL OH_JSVM_GetCbInfo( + JSVM_Env env, // [in] NAPI environment handle + JSVM_CallbackInfo cbinfo, // [in] Opaque callback-info handle size_t* argc, // [in-out] Specifies the size of the provided argv array // and receives the actual count of args. - napi_value* argv, // [out] Array of values - napi_value* this_arg, // [out] Receives the JS 'this' arg for the call + JSVM_Value* argv, // [out] Array of values + JSVM_Value* thisArg, // [out] Receives the JS 'this' arg for the call void** data) { // [out] Receives the data pointer for the callback. CHECK_ENV(env); CHECK_ARG(env, cbinfo); @@ -1951,19 +1951,19 @@ napi_status NAPI_CDECL napi_get_cb_info( if (argc != nullptr) { *argc = info->ArgsLength(); } - if (this_arg != nullptr) { - *this_arg = info->This(); + if (thisArg != nullptr) { + *thisArg = info->This(); } if (data != nullptr) { *data = info->Data(); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_new_target(napi_env env, - napi_callback_info cbinfo, - napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_GetNewTarget(JSVM_Env env, + JSVM_CallbackInfo cbinfo, + JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, cbinfo); CHECK_ARG(env, result); @@ -1972,16 +1972,16 @@ napi_status NAPI_CDECL napi_get_new_target(napi_env env, reinterpret_cast(cbinfo); *result = info->GetNewTarget(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_call_function(napi_env env, - napi_value recv, - napi_value func, +JSVM_Status JSVM_CDECL OH_JSVM_CallFunction(JSVM_Env env, + JSVM_Value recv, + JSVM_Value func, size_t argc, - const napi_value* argv, - napi_value* result) { - NAPI_PREAMBLE(env); + const JSVM_Value* argv, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, recv); if (argc > 0) { CHECK_ARG(env, argv); @@ -1998,30 +1998,30 @@ napi_status NAPI_CDECL napi_call_function(napi_env env, context, v8recv, argc, - reinterpret_cast*>(const_cast(argv))); + reinterpret_cast*>(const_cast(argv))); if (try_catch.HasCaught()) { - return napi_set_last_error(env, napi_pending_exception); + return jsvm_set_last_error(env, JSVM_PENDING_EXCEPTION); } else { if (result != nullptr) { - CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, maybe, JSVM_GENERIC_FAILURE); *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked()); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } } -napi_status NAPI_CDECL napi_get_global(napi_env env, napi_value* result) { +JSVM_Status JSVM_CDECL OH_JSVM_GetGlobal(JSVM_Env env, JSVM_Value* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = v8impl::JsValueFromV8LocalValue(env->context()->Global()); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_throw(napi_env env, napi_value error) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_Throw(JSVM_Env env, JSVM_Value error) { + JSVM_PREAMBLE(env); CHECK_ARG(env, error); v8::Isolate* isolate = env->isolate; @@ -2029,13 +2029,13 @@ napi_status NAPI_CDECL napi_throw(napi_env env, napi_value error) { isolate->ThrowException(v8impl::V8LocalValueFromJsValue(error)); // any VM calls after this point and before returning // to the javascript invoker will fail - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_throw_error(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_ThrowError(JSVM_Env env, const char* code, const char* msg) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); v8::Isolate* isolate = env->isolate; v8::Local str; @@ -2047,13 +2047,13 @@ napi_status NAPI_CDECL napi_throw_error(napi_env env, isolate->ThrowException(error_obj); // any VM calls after this point and before returning // to the javascript invoker will fail - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_throw_type_error(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_ThrowTypeError(JSVM_Env env, const char* code, const char* msg) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); v8::Isolate* isolate = env->isolate; v8::Local str; @@ -2065,13 +2065,13 @@ napi_status NAPI_CDECL napi_throw_type_error(napi_env env, isolate->ThrowException(error_obj); // any VM calls after this point and before returning // to the javascript invoker will fail - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_throw_range_error(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_ThrowRangeError(JSVM_Env env, const char* code, const char* msg) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); v8::Isolate* isolate = env->isolate; v8::Local str; @@ -2083,13 +2083,13 @@ napi_status NAPI_CDECL napi_throw_range_error(napi_env env, isolate->ThrowException(error_obj); // any VM calls after this point and before returning // to the javascript invoker will fail - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL node_api_throw_syntax_error(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_ThrowSyntaxError(JSVM_Env env, const char* code, const char* msg) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); v8::Isolate* isolate = env->isolate; v8::Local str; @@ -2101,13 +2101,13 @@ napi_status NAPI_CDECL node_api_throw_syntax_error(napi_env env, isolate->ThrowException(error_obj); // any VM calls after this point and before returning // to the javascript invoker will fail - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_is_error(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_IsError(JSVM_Env env, + JSVM_Value value, bool* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot // throw JS exceptions. CHECK_ENV(env); CHECK_ARG(env, value); @@ -2116,30 +2116,30 @@ napi_status NAPI_CDECL napi_is_error(napi_env env, v8::Local val = v8impl::V8LocalValueFromJsValue(value); *result = val->IsNativeError(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_value_double(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetValueDouble(JSVM_Env env, + JSVM_Value value, double* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, value); CHECK_ARG(env, result); v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected); + RETURN_STATUS_IF_FALSE(env, val->IsNumber(), JSVM_NUMBER_EXPECTED); *result = val.As()->Value(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_value_int32(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetValueInt32(JSVM_Env env, + JSVM_Value value, int32_t* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, value); @@ -2150,20 +2150,20 @@ napi_status NAPI_CDECL napi_get_value_int32(napi_env env, if (val->IsInt32()) { *result = val.As()->Value(); } else { - RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected); + RETURN_STATUS_IF_FALSE(env, val->IsNumber(), JSVM_NUMBER_EXPECTED); // Empty context: https://github.com/nodejs/node/issues/14379 v8::Local context; *result = val->Int32Value(context).FromJust(); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_value_uint32(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetValueUint32(JSVM_Env env, + JSVM_Value value, uint32_t* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, value); @@ -2174,20 +2174,20 @@ napi_status NAPI_CDECL napi_get_value_uint32(napi_env env, if (val->IsUint32()) { *result = val.As()->Value(); } else { - RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected); + RETURN_STATUS_IF_FALSE(env, val->IsNumber(), JSVM_NUMBER_EXPECTED); // Empty context: https://github.com/nodejs/node/issues/14379 v8::Local context; *result = val->Uint32Value(context).FromJust(); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_value_int64(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetValueInt64(JSVM_Env env, + JSVM_Value value, int64_t* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, value); @@ -2198,10 +2198,10 @@ napi_status NAPI_CDECL napi_get_value_int64(napi_env env, // This is still a fast path very likely to be taken. if (val->IsInt32()) { *result = val.As()->Value(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } - RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected); + RETURN_STATUS_IF_FALSE(env, val->IsNumber(), JSVM_NUMBER_EXPECTED); // v8::Value::IntegerValue() converts NaN, +Inf, and -Inf to INT64_MIN, // inconsistent with v8::Value::Int32Value() which converts those values to 0. @@ -2215,11 +2215,11 @@ napi_status NAPI_CDECL napi_get_value_int64(napi_env env, *result = 0; } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_value_bigint_int64(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetValueBigintInt64(JSVM_Env env, + JSVM_Value value, int64_t* result, bool* lossless) { CHECK_ENV(env); @@ -2229,15 +2229,15 @@ napi_status NAPI_CDECL napi_get_value_bigint_int64(napi_env env, v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsBigInt(), napi_bigint_expected); + RETURN_STATUS_IF_FALSE(env, val->IsBigInt(), JSVM_BIGINT_EXPECTED); *result = val.As()->Int64Value(lossless); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_value_bigint_uint64(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetValueBigintUint64(JSVM_Env env, + JSVM_Value value, uint64_t* result, bool* lossless) { CHECK_ENV(env); @@ -2247,58 +2247,58 @@ napi_status NAPI_CDECL napi_get_value_bigint_uint64(napi_env env, v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsBigInt(), napi_bigint_expected); + RETURN_STATUS_IF_FALSE(env, val->IsBigInt(), JSVM_BIGINT_EXPECTED); *result = val.As()->Uint64Value(lossless); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_value_bigint_words(napi_env env, - napi_value value, - int* sign_bit, - size_t* word_count, +JSVM_Status JSVM_CDECL OH_JSVM_GetValueBigintWords(JSVM_Env env, + JSVM_Value value, + int* signBit, + size_t* wordCount, uint64_t* words) { CHECK_ENV(env); CHECK_ARG(env, value); - CHECK_ARG(env, word_count); + CHECK_ARG(env, wordCount); v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsBigInt(), napi_bigint_expected); + RETURN_STATUS_IF_FALSE(env, val->IsBigInt(), JSVM_BIGINT_EXPECTED); v8::Local big = val.As(); - int word_count_int = *word_count; + int wordCount_int = *wordCount; - if (sign_bit == nullptr && words == nullptr) { + if (signBit == nullptr && words == nullptr) { word_count_int = big->WordCount(); } else { - CHECK_ARG(env, sign_bit); + CHECK_ARG(env, signBit); CHECK_ARG(env, words); - big->ToWordsArray(sign_bit, &word_count_int, words); + big->ToWordsArray(signBit, &word_count_int, words); } - *word_count = word_count_int; + *wordCount = wordCount_int; - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_value_bool(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetValueBool(JSVM_Env env, + JSVM_Value value, bool* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, value); CHECK_ARG(env, result); v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsBoolean(), napi_boolean_expected); + RETURN_STATUS_IF_FALSE(env, val->IsBoolean(), JSVM_BOOL_EXPECTED); *result = val.As()->Value(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } // Copies a JavaScript string into a LATIN-1 string buffer. The result is the @@ -2309,13 +2309,13 @@ napi_status NAPI_CDECL napi_get_value_bool(napi_env env, // If buf is NULL, this method returns the length of the string (in bytes) // via the result parameter. // The result argument is optional unless buf is NULL. -napi_status NAPI_CDECL napi_get_value_string_latin1( - napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result) { +JSVM_Status JSVM_CDECL OH_JSVM_GetValueStringLatin1( + JSVM_Env env, JSVM_Value value, char* buf, size_t bufsize, size_t* result) { CHECK_ENV(env); CHECK_ARG(env, value); v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected); + RETURN_STATUS_IF_FALSE(env, val->IsString(), JSVM_STRING_EXPECTED); if (!buf) { CHECK_ARG(env, result); @@ -2336,7 +2336,7 @@ napi_status NAPI_CDECL napi_get_value_string_latin1( *result = 0; } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } // Copies a JavaScript string into a UTF-8 string buffer. The result is the @@ -2347,13 +2347,13 @@ napi_status NAPI_CDECL napi_get_value_string_latin1( // If buf is NULL, this method returns the length of the string (in bytes) // via the result parameter. // The result argument is optional unless buf is NULL. -napi_status NAPI_CDECL napi_get_value_string_utf8( - napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result) { +JSVM_Status JSVM_CDECL OH_JSVM_GetValueStringUtf8( + JSVM_Env env, JSVM_Value value, char* buf, size_t bufsize, size_t* result) { CHECK_ENV(env); CHECK_ARG(env, value); v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected); + RETURN_STATUS_IF_FALSE(env, val->IsString(), JSVM_STRING_EXPECTED); if (!buf) { CHECK_ARG(env, result); @@ -2374,7 +2374,7 @@ napi_status NAPI_CDECL napi_get_value_string_utf8( *result = 0; } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } // Copies a JavaScript string into a UTF-16 string buffer. The result is the @@ -2385,8 +2385,8 @@ napi_status NAPI_CDECL napi_get_value_string_utf8( // If buf is NULL, this method returns the length of the string (in 2-byte // code units) via the result parameter. // The result argument is optional unless buf is NULL. -napi_status NAPI_CDECL napi_get_value_string_utf16(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetValueStringUtf16(JSVM_Env env, + JSVM_Value value, char16_t* buf, size_t bufsize, size_t* result) { @@ -2394,7 +2394,7 @@ napi_status NAPI_CDECL napi_get_value_string_utf16(napi_env env, CHECK_ARG(env, value); v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected); + RETURN_STATUS_IF_FALSE(env, val->IsString(), JSVM_STRING_EXPECTED); if (!buf) { CHECK_ARG(env, result); @@ -2415,13 +2415,13 @@ napi_status NAPI_CDECL napi_get_value_string_utf16(napi_env env, *result = 0; } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_coerce_to_bool(napi_env env, - napi_value value, - napi_value* result) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_CoerceToBool(JSVM_Env env, + JSVM_Value value, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, value); CHECK_ARG(env, result); @@ -2433,9 +2433,9 @@ napi_status NAPI_CDECL napi_coerce_to_bool(napi_env env, } #define GEN_COERCE_FUNCTION(UpperCaseName, MixedCaseName, LowerCaseName) \ - napi_status NAPI_CDECL napi_coerce_to_##LowerCaseName( \ - napi_env env, napi_value value, napi_value* result) { \ - NAPI_PREAMBLE(env); \ + JSVM_Status JSVM_CDECL napi_coerce_to_##LowerCaseName( \ + JSVM_Env env, JSVM_Value value, JSVM_Value* result) { \ + JSVM_PREAMBLE(env); \ CHECK_ARG(env, value); \ CHECK_ARG(env, result); \ \ @@ -2454,98 +2454,98 @@ GEN_COERCE_FUNCTION(STRING, String, string) #undef GEN_COERCE_FUNCTION -napi_status NAPI_CDECL napi_wrap(napi_env env, - napi_value js_object, - void* native_object, - napi_finalize finalize_cb, - void* finalize_hint, - napi_ref* result) { +JSVM_Status JSVM_CDECL OH_JSVM_Wrap(JSVM_Env env, + JSVM_Value jsObject, + void* nativeObject, + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Ref* result) { return v8impl::Wrap( - env, js_object, native_object, finalize_cb, finalize_hint, result); + env, jsObject, nativeObject, finalizeCb, finalizeHint, result); } -napi_status NAPI_CDECL napi_unwrap(napi_env env, - napi_value obj, +JSVM_Status JSVM_CDECL OH_JSVM_Unwrap(JSVM_Env env, + JSVM_Value obj, void** result) { return v8impl::Unwrap(env, obj, result, v8impl::KeepWrap); } -napi_status NAPI_CDECL napi_remove_wrap(napi_env env, - napi_value obj, +JSVM_Status JSVM_CDECL OH_JSVM_RemoveWrap(JSVM_Env env, + JSVM_Value obj, void** result) { return v8impl::Unwrap(env, obj, result, v8impl::RemoveWrap); } -napi_status NAPI_CDECL napi_create_external(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateExternal(JSVM_Env env, void* data, - napi_finalize finalize_cb, - void* finalize_hint, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::Isolate* isolate = env->isolate; v8::Local external_value = v8::External::New(isolate, data); - if (finalize_cb) { + if (finalizeCb) { // The Reference object will delete itself after invoking the finalizer // callback. v8impl::Reference::New(env, external_value, 0, v8impl::Ownership::kRuntime, - finalize_cb, + finalizeCb, data, - finalize_hint); + finalizeHint); } *result = v8impl::JsValueFromV8LocalValue(external_value); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_type_tag_object(napi_env env, - napi_value object, - const napi_type_tag* type_tag) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_TypeTagObject(JSVM_Env env, + JSVM_Value object, + const napi_typeTag* typeTag) { + JSVM_PREAMBLE(env); v8::Local context = env->context(); v8::Local obj; CHECK_TO_OBJECT_WITH_PREAMBLE(env, context, obj, object); - CHECK_ARG_WITH_PREAMBLE(env, type_tag); + CHECK_ARG_WITH_PREAMBLE(env, typeTag); - auto key = NAPI_PRIVATE_KEY(context, type_tag); + auto key = JSVM_PRIVATE_KEY(context, typeTag); auto maybe_has = obj->HasPrivate(context, key); - CHECK_MAYBE_NOTHING_WITH_PREAMBLE(env, maybe_has, napi_generic_failure); + CHECK_MAYBE_NOTHING_WITH_PREAMBLE(env, maybe_has, JSVM_GENERIC_FAILURE); RETURN_STATUS_IF_FALSE_WITH_PREAMBLE( - env, !maybe_has.FromJust(), napi_invalid_arg); + env, !maybe_has.FromJust(), JSVM_INVALID_ARG); auto tag = v8::BigInt::NewFromWords( - context, 0, 2, reinterpret_cast(type_tag)); - CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, tag, napi_generic_failure); + context, 0, 2, reinterpret_cast(typeTag)); + CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, tag, JSVM_GENERIC_FAILURE); auto maybe_set = obj->SetPrivate(context, key, tag.ToLocalChecked()); - CHECK_MAYBE_NOTHING_WITH_PREAMBLE(env, maybe_set, napi_generic_failure); + CHECK_MAYBE_NOTHING_WITH_PREAMBLE(env, maybe_set, JSVM_GENERIC_FAILURE); RETURN_STATUS_IF_FALSE_WITH_PREAMBLE( - env, maybe_set.FromJust(), napi_generic_failure); + env, maybe_set.FromJust(), JSVM_GENERIC_FAILURE); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_check_object_type_tag(napi_env env, - napi_value object, - const napi_type_tag* type_tag, +JSVM_Status JSVM_CDECL OH_JSVM_CheckObjectTypeTag(JSVM_Env env, + JSVM_Value object, + const napi_typeTag* typeTag, bool* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); v8::Local context = env->context(); v8::Local obj; CHECK_TO_OBJECT_WITH_PREAMBLE(env, context, obj, object); - CHECK_ARG_WITH_PREAMBLE(env, type_tag); + CHECK_ARG_WITH_PREAMBLE(env, typeTag); CHECK_ARG_WITH_PREAMBLE(env, result); auto maybe_value = - obj->GetPrivate(context, NAPI_PRIVATE_KEY(context, type_tag)); - CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, maybe_value, napi_generic_failure); + obj->GetPrivate(context, JSVM_PRIVATE_KEY(context, typeTag)); + CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, maybe_value, JSVM_GENERIC_FAILURE); v8::Local val = maybe_value.ToLocalChecked(); // We consider the type check to have failed unless we reach the line below @@ -2561,11 +2561,11 @@ napi_status NAPI_CDECL napi_check_object_type_tag(napi_env env, if (sign == 0) { if (size == 2) { *result = - (tag.lower == type_tag->lower && tag.upper == type_tag->upper); + (tag.lower == typeTag->lower && tag.upper == typeTag->upper); } else if (size == 1) { - *result = (tag.lower == type_tag->lower && 0 == type_tag->upper); + *result = (tag.lower == typeTag->lower && 0 == typeTag->upper); } else if (size == 0) { - *result = (0 == type_tag->lower && 0 == type_tag->upper); + *result = (0 == typeTag->lower && 0 == typeTag->upper); } } } @@ -2573,59 +2573,59 @@ napi_status NAPI_CDECL napi_check_object_type_tag(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_get_value_external(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetValueExternal(JSVM_Env env, + JSVM_Value value, void** result) { CHECK_ENV(env); CHECK_ARG(env, value); CHECK_ARG(env, result); v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsExternal(), napi_invalid_arg); + RETURN_STATUS_IF_FALSE(env, val->IsExternal(), JSVM_INVALID_ARG); v8::Local external_value = val.As(); *result = external_value->Value(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } // Set initial_refcount to 0 for a weak reference, >0 for a strong reference. -napi_status NAPI_CDECL napi_create_reference(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_CreateReference(JSVM_Env env, + JSVM_Value value, uint32_t initial_refcount, - napi_ref* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw + JSVM_Ref* result) { + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, value); CHECK_ARG(env, result); v8::Local v8_value = v8impl::V8LocalValueFromJsValue(value); - if (env->module_api_version != NAPI_VERSION_EXPERIMENTAL) { + if (env->module_api_version != JSVM_VERSION_EXPERIMENTAL) { if (!(v8_value->IsObject() || v8_value->IsFunction() || v8_value->IsSymbol())) { - return napi_set_last_error(env, napi_invalid_arg); + return jsvm_set_last_error(env, JSVM_INVALID_ARG); } } v8impl::Reference* reference = v8impl::Reference::New( env, v8_value, initial_refcount, v8impl::Ownership::kUserland); - *result = reinterpret_cast(reference); - return napi_clear_last_error(env); + *result = reinterpret_cast(reference); + return jsvm_clear_last_error(env); } // Deletes a reference. The referenced value is released, and may be GC'd unless // there are other references to it. -napi_status NAPI_CDECL napi_delete_reference(napi_env env, napi_ref ref) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw +JSVM_Status JSVM_CDECL OH_JSVM_DeleteReference(JSVM_Env env, JSVM_Ref ref) { + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, ref); delete reinterpret_cast(ref); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } // Increments the reference count, optionally returning the resulting count. @@ -2633,10 +2633,10 @@ napi_status NAPI_CDECL napi_delete_reference(napi_env env, napi_ref ref) { // refcount is >0, and the referenced object is effectively "pinned". // Calling this when the refcount is 0 and the object is unavailable // results in an error. -napi_status NAPI_CDECL napi_reference_ref(napi_env env, - napi_ref ref, +JSVM_Status JSVM_CDECL OH_JSVM_ReferenceRef(JSVM_Env env, + JSVM_Ref ref, uint32_t* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, ref); @@ -2648,17 +2648,17 @@ napi_status NAPI_CDECL napi_reference_ref(napi_env env, *result = count; } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } // Decrements the reference count, optionally returning the resulting count. If // the result is 0 the reference is now weak and the object may be GC'd at any // time if there are no other references. Calling this when the refcount is // already 0 results in an error. -napi_status NAPI_CDECL napi_reference_unref(napi_env env, - napi_ref ref, +JSVM_Status JSVM_CDECL OH_JSVM_ReferenceUnref(JSVM_Env env, + JSVM_Ref ref, uint32_t* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, ref); @@ -2666,7 +2666,7 @@ napi_status NAPI_CDECL napi_reference_unref(napi_env env, v8impl::Reference* reference = reinterpret_cast(ref); if (reference->RefCount() == 0) { - return napi_set_last_error(env, napi_generic_failure); + return jsvm_set_last_error(env, JSVM_GENERIC_FAILURE); } uint32_t count = reference->Unref(); @@ -2675,16 +2675,16 @@ napi_status NAPI_CDECL napi_reference_unref(napi_env env, *result = count; } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } // Attempts to get a referenced value. If the reference is weak, the value might // no longer be available, in that case the call is still successful but the // result is NULL. -napi_status NAPI_CDECL napi_get_reference_value(napi_env env, - napi_ref ref, - napi_value* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw +JSVM_Status JSVM_CDECL OH_JSVM_GetReferenceValue(JSVM_Env env, + JSVM_Ref ref, + JSVM_Value* result) { + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, ref); @@ -2693,12 +2693,12 @@ napi_status NAPI_CDECL napi_get_reference_value(napi_env env, v8impl::Reference* reference = reinterpret_cast(ref); *result = v8impl::JsValueFromV8LocalValue(reference->Get()); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_open_handle_scope(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_OpenHandleScope(JSVM_Env env, napi_handle_scope* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, result); @@ -2706,27 +2706,27 @@ napi_status NAPI_CDECL napi_open_handle_scope(napi_env env, *result = v8impl::JsHandleScopeFromV8HandleScope( new v8impl::HandleScopeWrapper(env->isolate)); env->open_handle_scopes++; - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_close_handle_scope(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CloseHandleScope(JSVM_Env env, napi_handle_scope scope) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, scope); if (env->open_handle_scopes == 0) { - return napi_handle_scope_mismatch; + return JSVM_HANDLE_SCOPE_MISMATCH; } env->open_handle_scopes--; delete v8impl::V8HandleScopeFromJsHandleScope(scope); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_open_escapable_handle_scope( - napi_env env, napi_escapable_handle_scope* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw +JSVM_Status JSVM_CDECL OH_JSVM_OpenEscapableHandleScope( + JSVM_Env env, JSVM_EscapableHandleScope* result) { + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, result); @@ -2734,29 +2734,29 @@ napi_status NAPI_CDECL napi_open_escapable_handle_scope( *result = v8impl::JsEscapableHandleScopeFromV8EscapableHandleScope( new v8impl::EscapableHandleScopeWrapper(env->isolate)); env->open_handle_scopes++; - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_close_escapable_handle_scope( - napi_env env, napi_escapable_handle_scope scope) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw +JSVM_Status JSVM_CDECL OH_JSVM_CloseEscapableHandleScope( + JSVM_Env env, JSVM_EscapableHandleScope scope) { + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, scope); if (env->open_handle_scopes == 0) { - return napi_handle_scope_mismatch; + return JSVM_HANDLE_SCOPE_MISMATCH; } delete v8impl::V8EscapableHandleScopeFromJsEscapableHandleScope(scope); env->open_handle_scopes--; - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_escape_handle(napi_env env, - napi_escapable_handle_scope scope, - napi_value escapee, - napi_value* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw +JSVM_Status JSVM_CDECL OH_JSVM_EscapeHandle(JSVM_Env env, + JSVM_EscapableHandleScope scope, + JSVM_Value escapee, + JSVM_Value* result) { + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, scope); @@ -2768,17 +2768,17 @@ napi_status NAPI_CDECL napi_escape_handle(napi_env env, if (!s->escape_called()) { *result = v8impl::JsValueFromV8LocalValue( s->Escape(v8impl::V8LocalValueFromJsValue(escapee))); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } - return napi_set_last_error(env, napi_escape_called_twice); + return jsvm_set_last_error(env, JSVM_ESCAPE_CALLED_TWICE); } -napi_status NAPI_CDECL napi_new_instance(napi_env env, - napi_value constructor, +JSVM_Status JSVM_CDECL OH_JSVM_NewInstance(JSVM_Env env, + JSVM_Value constructor, size_t argc, - const napi_value* argv, - napi_value* result) { - NAPI_PREAMBLE(env); + const JSVM_Value* argv, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, constructor); if (argc > 0) { CHECK_ARG(env, argv); @@ -2793,19 +2793,19 @@ napi_status NAPI_CDECL napi_new_instance(napi_env env, auto maybe = ctor->NewInstance( context, argc, - reinterpret_cast*>(const_cast(argv))); + reinterpret_cast*>(const_cast(argv))); - CHECK_MAYBE_EMPTY(env, maybe, napi_pending_exception); + CHECK_MAYBE_EMPTY(env, maybe, JSVM_PENDING_EXCEPTION); *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked()); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_instanceof(napi_env env, - napi_value object, - napi_value constructor, +JSVM_Status JSVM_CDECL OH_JSVM_Instanceof(JSVM_Env env, + JSVM_Value object, + JSVM_Value constructor, bool* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); CHECK_ARG(env, object); CHECK_ARG(env, result); @@ -2817,13 +2817,13 @@ napi_status NAPI_CDECL napi_instanceof(napi_env env, CHECK_TO_OBJECT(env, context, ctor, constructor); if (!ctor->IsFunction()) { - napi_throw_type_error( + OH_JSVM_ThrowTypeError( env, "ERR_NAPI_CONS_FUNCTION", "Constructor must be a function"); - return napi_set_last_error(env, napi_function_expected); + return jsvm_set_last_error(env, JSVM_FUNCTION_EXPECTED); } - napi_status status = napi_generic_failure; + JSVM_Status status = JSVM_GENERIC_FAILURE; v8::Local val = v8impl::V8LocalValueFromJsValue(object); auto maybe_result = val->InstanceOf(context, ctor); @@ -2833,36 +2833,36 @@ napi_status NAPI_CDECL napi_instanceof(napi_env env, } // Methods to support catching exceptions -napi_status NAPI_CDECL napi_is_exception_pending(napi_env env, bool* result) { - // NAPI_PREAMBLE is not used here: this function must execute when there is a +JSVM_Status JSVM_CDECL OH_JSVM_IsExceptionPending(JSVM_Env env, bool* result) { + // JSVM_PREAMBLE is not used here: this function must execute when there is a // pending exception. CHECK_ENV(env); CHECK_ARG(env, result); *result = !env->last_exception.IsEmpty(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_and_clear_last_exception(napi_env env, - napi_value* result) { - // NAPI_PREAMBLE is not used here: this function must execute when there is a +JSVM_Status JSVM_CDECL OH_JSVM_GetAndClearLastException(JSVM_Env env, + JSVM_Value* result) { + // JSVM_PREAMBLE is not used here: this function must execute when there is a // pending exception. CHECK_ENV(env); CHECK_ARG(env, result); if (env->last_exception.IsEmpty()) { - return napi_get_undefined(env, result); + return OH_JSVM_GetUndefined(env, result); } else { *result = v8impl::JsValueFromV8LocalValue( v8::Local::New(env->isolate, env->last_exception)); env->last_exception.Reset(); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_is_arraybuffer(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_IsArraybuffer(JSVM_Env env, + JSVM_Value value, bool* result) { CHECK_ENV(env); CHECK_ARG(env, value); @@ -2871,19 +2871,19 @@ napi_status NAPI_CDECL napi_is_arraybuffer(napi_env env, v8::Local val = v8impl::V8LocalValueFromJsValue(value); *result = val->IsArrayBuffer(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_arraybuffer(napi_env env, - size_t byte_length, +JSVM_Status JSVM_CDECL OH_JSVM_CreateArraybuffer(JSVM_Env env, + size_t byteLength, void** data, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::Isolate* isolate = env->isolate; v8::Local buffer = - v8::ArrayBuffer::New(isolate, byte_length); + v8::ArrayBuffer::New(isolate, byteLength); // Optionally return a pointer to the buffer's data, to avoid another call to // retrieve it. @@ -2895,32 +2895,32 @@ napi_status NAPI_CDECL napi_create_arraybuffer(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL -napi_create_external_arraybuffer(napi_env env, - void* external_data, - size_t byte_length, - napi_finalize finalize_cb, - void* finalize_hint, - napi_value* result) { +JSVM_Status JSVM_CDECL +OH_JSVM_CreateExternalArraybuffer(JSVM_Env env, + void* externalData, + size_t byteLength, + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Value* result) { // The API contract here is that the cleanup function runs on the JS thread, - // and is able to use napi_env. Implementing that properly is hard, so use the + // and is able to use JSVM_Env. Implementing that properly is hard, so use the // `Buffer` variant for easier implementation. - napi_value buffer; - STATUS_CALL(napi_create_external_buffer( - env, byte_length, external_data, finalize_cb, finalize_hint, &buffer)); - return napi_get_typedarray_info( + JSVM_Value buffer; + STATUS_CALL(OH_JSVM_CreateExternal_buffer( + env, byteLength, externalData, finalizeCb, finalizeHint, &buffer)); + return OH_JSVM_GetTypedarrayInfo( env, buffer, nullptr, nullptr, nullptr, result, nullptr); } -napi_status NAPI_CDECL napi_get_arraybuffer_info(napi_env env, - napi_value arraybuffer, +JSVM_Status JSVM_CDECL OH_JSVM_GetArraybufferInfo(JSVM_Env env, + JSVM_Value arraybuffer, void** data, - size_t* byte_length) { + size_t* byteLength) { CHECK_ENV(env); CHECK_ARG(env, arraybuffer); v8::Local value = v8impl::V8LocalValueFromJsValue(arraybuffer); - RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg); + RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), JSVM_INVALID_ARG); v8::Local ab = value.As(); @@ -2928,15 +2928,15 @@ napi_status NAPI_CDECL napi_get_arraybuffer_info(napi_env env, *data = ab->Data(); } - if (byte_length != nullptr) { - *byte_length = ab->ByteLength(); + if (byteLength != nullptr) { + *byteLength = ab->ByteLength(); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_is_typedarray(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_IsTypedarray(JSVM_Env env, + JSVM_Value value, bool* result) { CHECK_ENV(env); CHECK_ARG(env, value); @@ -2945,116 +2945,116 @@ napi_status NAPI_CDECL napi_is_typedarray(napi_env env, v8::Local val = v8impl::V8LocalValueFromJsValue(value); *result = val->IsTypedArray(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_typedarray(napi_env env, - napi_typedarray_type type, +JSVM_Status JSVM_CDECL OH_JSVM_CreateTypedarray(JSVM_Env env, + JSVM_TypedarrayType type, size_t length, - napi_value arraybuffer, - size_t byte_offset, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_Value arraybuffer, + size_t byteOffset, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, arraybuffer); CHECK_ARG(env, result); v8::Local value = v8impl::V8LocalValueFromJsValue(arraybuffer); - RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg); + RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), JSVM_INVALID_ARG); v8::Local buffer = value.As(); v8::Local typedArray; switch (type) { - case napi_int8_array: + case JSVM_INT8_ARRAY: CREATE_TYPED_ARRAY( - env, Int8Array, 1, buffer, byte_offset, length, typedArray); + env, Int8Array, 1, buffer, byteOffset, length, typedArray); break; - case napi_uint8_array: + case JSVM_UINT8_ARRAY: CREATE_TYPED_ARRAY( - env, Uint8Array, 1, buffer, byte_offset, length, typedArray); + env, Uint8Array, 1, buffer, byteOffset, length, typedArray); break; - case napi_uint8_clamped_array: + case JSVM_UINT8_CLAMPED_ARRAY: CREATE_TYPED_ARRAY( - env, Uint8ClampedArray, 1, buffer, byte_offset, length, typedArray); + env, Uint8ClampedArray, 1, buffer, byteOffset, length, typedArray); break; - case napi_int16_array: + case JSVM_INT16_ARRAY: CREATE_TYPED_ARRAY( - env, Int16Array, 2, buffer, byte_offset, length, typedArray); + env, Int16Array, 2, buffer, byteOffset, length, typedArray); break; - case napi_uint16_array: + case JAVM_UINT16_ARRAY: CREATE_TYPED_ARRAY( - env, Uint16Array, 2, buffer, byte_offset, length, typedArray); + env, Uint16Array, 2, buffer, byteOffset, length, typedArray); break; - case napi_int32_array: + case JSVM_INT32_ARRAY: CREATE_TYPED_ARRAY( - env, Int32Array, 4, buffer, byte_offset, length, typedArray); + env, Int32Array, 4, buffer, byteOffset, length, typedArray); break; - case napi_uint32_array: + case JSVM_UINT32_ARRAY: CREATE_TYPED_ARRAY( - env, Uint32Array, 4, buffer, byte_offset, length, typedArray); + env, Uint32Array, 4, buffer, byteOffset, length, typedArray); break; - case napi_float32_array: + case JSVM_FLOAT32_ARRAY: CREATE_TYPED_ARRAY( - env, Float32Array, 4, buffer, byte_offset, length, typedArray); + env, Float32Array, 4, buffer, byteOffset, length, typedArray); break; - case napi_float64_array: + case JSVM_FLOAT64_ARRAY: CREATE_TYPED_ARRAY( - env, Float64Array, 8, buffer, byte_offset, length, typedArray); + env, Float64Array, 8, buffer, byteOffset, length, typedArray); break; - case napi_bigint64_array: + case JSVM_BIGINT64_ARRAY: CREATE_TYPED_ARRAY( - env, BigInt64Array, 8, buffer, byte_offset, length, typedArray); + env, BigInt64Array, 8, buffer, byteOffset, length, typedArray); break; - case napi_biguint64_array: + case JSVM_BIGUINT64_ARRAY: CREATE_TYPED_ARRAY( - env, BigUint64Array, 8, buffer, byte_offset, length, typedArray); + env, BigUint64Array, 8, buffer, byteOffset, length, typedArray); break; default: - return napi_set_last_error(env, napi_invalid_arg); + return jsvm_set_last_error(env, JSVM_INVALID_ARG); } *result = v8impl::JsValueFromV8LocalValue(typedArray); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_get_typedarray_info(napi_env env, - napi_value typedarray, - napi_typedarray_type* type, +JSVM_Status JSVM_CDECL OH_JSVM_GetTypedarrayInfo(JSVM_Env env, + JSVM_Value typedarray, + JSVM_TypedarrayType* type, size_t* length, void** data, - napi_value* arraybuffer, - size_t* byte_offset) { + JSVM_Value* arraybuffer, + size_t* byteOffset) { CHECK_ENV(env); CHECK_ARG(env, typedarray); v8::Local value = v8impl::V8LocalValueFromJsValue(typedarray); - RETURN_STATUS_IF_FALSE(env, value->IsTypedArray(), napi_invalid_arg); + RETURN_STATUS_IF_FALSE(env, value->IsTypedArray(), JSVM_INVALID_ARG); v8::Local array = value.As(); if (type != nullptr) { if (value->IsInt8Array()) { - *type = napi_int8_array; + *type = JSVM_INT8_ARRAY; } else if (value->IsUint8Array()) { - *type = napi_uint8_array; + *type = JSVM_UINT8_ARRAY; } else if (value->IsUint8ClampedArray()) { - *type = napi_uint8_clamped_array; + *type = JSVM_UINT8_CLAMPED_ARRAY; } else if (value->IsInt16Array()) { - *type = napi_int16_array; + *type = JSVM_INT16_ARRAY; } else if (value->IsUint16Array()) { - *type = napi_uint16_array; + *type = JAVM_UINT16_ARRAY; } else if (value->IsInt32Array()) { - *type = napi_int32_array; + *type = JSVM_INT32_ARRAY; } else if (value->IsUint32Array()) { - *type = napi_uint32_array; + *type = JSVM_UINT32_ARRAY; } else if (value->IsFloat32Array()) { - *type = napi_float32_array; + *type = JSVM_FLOAT32_ARRAY; } else if (value->IsFloat64Array()) { - *type = napi_float64_array; + *type = JSVM_FLOAT64_ARRAY; } else if (value->IsBigInt64Array()) { - *type = napi_bigint64_array; + *type = JSVM_BIGINT64_ARRAY; } else if (value->IsBigUint64Array()) { - *type = napi_biguint64_array; + *type = JSVM_BIGUINT64_ARRAY; } } @@ -3077,42 +3077,42 @@ napi_status NAPI_CDECL napi_get_typedarray_info(napi_env env, *arraybuffer = v8impl::JsValueFromV8LocalValue(buffer); } - if (byte_offset != nullptr) { - *byte_offset = array->ByteOffset(); + if (byteOffset != nullptr) { + *byteOffset = array->ByteOffset(); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_dataview(napi_env env, - size_t byte_length, - napi_value arraybuffer, - size_t byte_offset, - napi_value* result) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_CreateDataview(JSVM_Env env, + size_t byteLength, + JSVM_Value arraybuffer, + size_t byteOffset, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, arraybuffer); CHECK_ARG(env, result); v8::Local value = v8impl::V8LocalValueFromJsValue(arraybuffer); - RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg); + RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), JSVM_INVALID_ARG); v8::Local buffer = value.As(); - if (byte_length + byte_offset > buffer->ByteLength()) { - napi_throw_range_error(env, - "ERR_NAPI_INVALID_DATAVIEW_ARGS", - "byte_offset + byte_length should be less than or " + if (byteLength + byteOffset > buffer->ByteLength()) { + OH_JSVM_ThrowRangeError(env, + "ERR_JSVM_INVALID_DATAVIEW_ARGS", + "byteOffset + byteLength should be less than or " "equal to the size in bytes of the array passed in"); - return napi_set_last_error(env, napi_pending_exception); + return jsvm_set_last_error(env, JSVM_PENDING_EXCEPTION); } v8::Local DataView = - v8::DataView::New(buffer, byte_offset, byte_length); + v8::DataView::New(buffer, byteOffset, byteLength); *result = v8impl::JsValueFromV8LocalValue(DataView); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_is_dataview(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_IsDataview(JSVM_Env env, + JSVM_Value value, bool* result) { CHECK_ENV(env); CHECK_ARG(env, value); @@ -3121,25 +3121,25 @@ napi_status NAPI_CDECL napi_is_dataview(napi_env env, v8::Local val = v8impl::V8LocalValueFromJsValue(value); *result = val->IsDataView(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_dataview_info(napi_env env, - napi_value dataview, - size_t* byte_length, +JSVM_Status JSVM_CDECL OH_JSVM_GetDataviewInfo(JSVM_Env env, + JSVM_Value dataview, + size_t* byteLength, void** data, - napi_value* arraybuffer, - size_t* byte_offset) { + JSVM_Value* arraybuffer, + size_t* byteOffset) { CHECK_ENV(env); CHECK_ARG(env, dataview); v8::Local value = v8impl::V8LocalValueFromJsValue(dataview); - RETURN_STATUS_IF_FALSE(env, value->IsDataView(), napi_invalid_arg); + RETURN_STATUS_IF_FALSE(env, value->IsDataView(), JSVM_INVALID_ARG); v8::Local array = value.As(); - if (byte_length != nullptr) { - *byte_length = array->ByteLength(); + if (byteLength != nullptr) { + *byteLength = array->ByteLength(); } v8::Local buffer; @@ -3157,29 +3157,29 @@ napi_status NAPI_CDECL napi_get_dataview_info(napi_env env, *arraybuffer = v8impl::JsValueFromV8LocalValue(buffer); } - if (byte_offset != nullptr) { - *byte_offset = array->ByteOffset(); + if (byteOffset != nullptr) { + *byteOffset = array->ByteOffset(); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_version(napi_env env, uint32_t* result) { +JSVM_Status JSVM_CDECL OH_JSVM_GetVersion(JSVM_Env env, uint32_t* result) { CHECK_ENV(env); CHECK_ARG(env, result); *result = NAPI_VERSION; - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_promise(napi_env env, - napi_deferred* deferred, - napi_value* promise) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_CreatePromise(JSVM_Env env, + JSVM_Deferred* deferred, + JSVM_Value* promise) { + JSVM_PREAMBLE(env); CHECK_ARG(env, deferred); CHECK_ARG(env, promise); auto maybe = v8::Promise::Resolver::New(env->context()); - CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, maybe, JSVM_GENERIC_FAILURE); auto v8_resolver = maybe.ToLocalChecked(); auto v8_deferred = new v8impl::Persistent(); @@ -3190,20 +3190,20 @@ napi_status NAPI_CDECL napi_create_promise(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_resolve_deferred(napi_env env, - napi_deferred deferred, - napi_value resolution) { +JSVM_Status JSVM_CDECL OH_JSVM_ResolveDeferred(JSVM_Env env, + JSVM_Deferred deferred, + JSVM_Value resolution) { return v8impl::ConcludeDeferred(env, deferred, resolution, true); } -napi_status NAPI_CDECL napi_reject_deferred(napi_env env, - napi_deferred deferred, - napi_value resolution) { +JSVM_Status JSVM_CDECL OH_JSVM_RejectDeferred(JSVM_Env env, + JSVM_Deferred deferred, + JSVM_Value resolution) { return v8impl::ConcludeDeferred(env, deferred, resolution, false); } -napi_status NAPI_CDECL napi_is_promise(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_IsPromise(JSVM_Env env, + JSVM_Value value, bool* is_promise) { CHECK_ENV(env); CHECK_ARG(env, value); @@ -3211,44 +3211,44 @@ napi_status NAPI_CDECL napi_is_promise(napi_env env, *is_promise = v8impl::V8LocalValueFromJsValue(value)->IsPromise(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_create_date(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateDate(JSVM_Env env, double time, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::MaybeLocal maybe_date = v8::Date::New(env->context(), time); - CHECK_MAYBE_EMPTY(env, maybe_date, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, maybe_date, JSVM_GENERIC_FAILURE); *result = v8impl::JsValueFromV8LocalValue(maybe_date.ToLocalChecked()); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_is_date(napi_env env, - napi_value value, - bool* is_date) { +JSVM_Status JSVM_CDECL OH_JSVM_IsDate(JSVM_Env env, + JSVM_Value value, + bool* isDate) { CHECK_ENV(env); CHECK_ARG(env, value); - CHECK_ARG(env, is_date); + CHECK_ARG(env, isDate); - *is_date = v8impl::V8LocalValueFromJsValue(value)->IsDate(); + *isDate = v8impl::V8LocalValueFromJsValue(value)->IsDate(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_date_value(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL OH_JSVM_GetDateValue(JSVM_Env env, + JSVM_Value value, double* result) { - NAPI_PREAMBLE(env); + JSVM_PREAMBLE(env); CHECK_ARG(env, value); CHECK_ARG(env, result); v8::Local val = v8impl::V8LocalValueFromJsValue(value); - RETURN_STATUS_IF_FALSE(env, val->IsDate(), napi_date_expected); + RETURN_STATUS_IF_FALSE(env, val->IsDate(), JSVM_DATA_EXPECTED); v8::Local date = val.As(); *result = date->ValueOf(); @@ -3256,45 +3256,45 @@ napi_status NAPI_CDECL napi_get_date_value(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_run_script(napi_env env, - napi_value script, - napi_value* result) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL OH_JSVM_RunScript(JSVM_Env env, + JSVM_Value script, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, script); CHECK_ARG(env, result); v8::Local v8_script = v8impl::V8LocalValueFromJsValue(script); if (!v8_script->IsString()) { - return napi_set_last_error(env, napi_string_expected); + return jsvm_set_last_error(env, JSVM_STRING_EXPECTED); } v8::Local context = env->context(); auto maybe_script = v8::Script::Compile(context, v8_script.As()); - CHECK_MAYBE_EMPTY(env, maybe_script, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, maybe_script, JSVM_GENERIC_FAILURE); auto script_result = maybe_script.ToLocalChecked()->Run(context); - CHECK_MAYBE_EMPTY(env, script_result, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, script_result, JSVM_GENERIC_FAILURE); *result = v8impl::JsValueFromV8LocalValue(script_result.ToLocalChecked()); return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_add_finalizer(napi_env env, - napi_value js_object, - void* finalize_data, - napi_finalize finalize_cb, - void* finalize_hint, - napi_ref* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw +JSVM_Status JSVM_CDECL OH_JSVM_AddFinalizer(JSVM_Env env, + JSVM_Value jsObject, + void* finalizeData, + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Ref* result) { + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); - CHECK_ARG(env, js_object); - CHECK_ARG(env, finalize_cb); + CHECK_ARG(env, jsObject); + CHECK_ARG(env, finalizeCb); - v8::Local v8_value = v8impl::V8LocalValueFromJsValue(js_object); - RETURN_STATUS_IF_FALSE(env, v8_value->IsObject(), napi_invalid_arg); + v8::Local v8_value = v8impl::V8LocalValueFromJsValue(jsObject); + RETURN_STATUS_IF_FALSE(env, v8_value->IsObject(), JSVM_INVALID_ARG); // Create a self-deleting reference if the optional out-param result is not // set. @@ -3302,30 +3302,30 @@ napi_status NAPI_CDECL napi_add_finalizer(napi_env env, ? v8impl::Ownership::kRuntime : v8impl::Ownership::kUserland; v8impl::Reference* reference = v8impl::Reference::New( - env, v8_value, 0, ownership, finalize_cb, finalize_data, finalize_hint); + env, v8_value, 0, ownership, finalizeCb, finalizeData, finalizeHint); if (result != nullptr) { - *result = reinterpret_cast(reference); + *result = reinterpret_cast(reference); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_adjust_external_memory(napi_env env, - int64_t change_in_bytes, - int64_t* adjusted_value) { +JSVM_Status JSVM_CDECL OH_JSVM_AdjustExternalMemory(JSVM_Env env, + int64_t changeInBytes, + int64_t* adjustedValue) { CHECK_ENV(env); - CHECK_ARG(env, adjusted_value); + CHECK_ARG(env, adjustedValue); - *adjusted_value = - env->isolate->AdjustAmountOfExternalAllocatedMemory(change_in_bytes); + *adjustedValue = + env->isolate->AdjustAmountOfExternalAllocatedMemory(changeInBytes); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_set_instance_data(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_SetInstanceData(JSVM_Env env, void* data, - napi_finalize finalize_cb, - void* finalize_hint) { + JSVM_FINALIZE finalizeCb, + void* finalizeHint) { CHECK_ENV(env); v8impl::RefBase* old_data = static_cast(env->instance_data); @@ -3336,12 +3336,12 @@ napi_status NAPI_CDECL napi_set_instance_data(napi_env env, } env->instance_data = v8impl::RefBase::New( - env, 0, v8impl::Ownership::kRuntime, finalize_cb, data, finalize_hint); + env, 0, v8impl::Ownership::kRuntime, finalizeCb, data, finalizeHint); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_instance_data(napi_env env, void** data) { +JSVM_Status JSVM_CDECL OH_JSVM_GetInstanceData(JSVM_Env env, void** data) { CHECK_ENV(env); CHECK_ARG(env, data); @@ -3349,29 +3349,29 @@ napi_status NAPI_CDECL napi_get_instance_data(napi_env env, void** data) { *data = (idata == nullptr ? nullptr : idata->Data()); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_detach_arraybuffer(napi_env env, - napi_value arraybuffer) { +JSVM_Status JSVM_CDECL OH_JSVM_DetachArraybuffer(JSVM_Env env, + JSVM_Value arraybuffer) { CHECK_ENV(env); CHECK_ARG(env, arraybuffer); v8::Local value = v8impl::V8LocalValueFromJsValue(arraybuffer); RETURN_STATUS_IF_FALSE( - env, value->IsArrayBuffer(), napi_arraybuffer_expected); + env, value->IsArrayBuffer(), JSVM_CALLBACK_SCOPE_MISMATCH); v8::Local it = value.As(); RETURN_STATUS_IF_FALSE( - env, it->IsDetachable(), napi_detachable_arraybuffer_expected); + env, it->IsDetachable(), JSVM_DETACHABLE_ARRAYBUFFER_EXPECTED); it->Detach(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_is_detached_arraybuffer(napi_env env, - napi_value arraybuffer, +JSVM_Status JSVM_CDECL OH_JSVM_IsDetachedArraybuffer(JSVM_Env env, + JSVM_Value arraybuffer, bool* result) { CHECK_ENV(env); CHECK_ARG(env, arraybuffer); @@ -3382,5 +3382,5 @@ napi_status NAPI_CDECL napi_is_detached_arraybuffer(napi_env env, *result = value->IsArrayBuffer() && value.As()->WasDetached(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } diff --git a/src/js_native_api_v8.h b/src/js_native_api_v8.h index f76467783..21e801acb 100644 --- a/src/js_native_api_v8.h +++ b/src/js_native_api_v8.h @@ -4,7 +4,7 @@ #include "js_native_api_types.h" #include "js_native_api_v8_internals.h" -inline napi_status napi_clear_last_error(napi_env env); +inline JSVM_Status jsvm_clear_last_error(JSVM_Env env); namespace v8impl { @@ -50,13 +50,13 @@ class RefTracker { class Finalizer; } // end of namespace v8impl -struct napi_env__ { - explicit napi_env__(v8::Local context, +struct JSVM_Env__ { + explicit JSVM_Env__(v8::Local context, int32_t module_api_version) : isolate(context->GetIsolate()), context_persistent(isolate, context), module_api_version(module_api_version) { - napi_clear_last_error(this); + jsvm_clear_last_error(this); } inline v8::Local context() const { @@ -70,7 +70,7 @@ struct napi_env__ { virtual bool can_call_into_js() const { return true; } - static inline void HandleThrow(napi_env env, v8::Local value) { + static inline void HandleThrow(JSVM_Env env, v8::Local value) { if (env->terminatedOrTerminating()) { return; } @@ -89,7 +89,7 @@ struct napi_env__ { inline void CallIntoModule(T&& call, U&& handle_exception = HandleThrow) { int open_handle_scopes_before = open_handle_scopes; int open_callback_scopes_before = open_callback_scopes; - napi_clear_last_error(this); + jsvm_clear_last_error(this); call(this); CHECK_EQ(open_handle_scopes, open_handle_scopes_before); CHECK_EQ(open_callback_scopes, open_callback_scopes_before); @@ -100,12 +100,12 @@ struct napi_env__ { } // Call finalizer immediately. - virtual void CallFinalizer(napi_finalize cb, void* data, void* hint) { + virtual void CallFinalizer(JSVM_FINALIZE cb, void* data, void* hint) { v8::HandleScope handle_scope(isolate); - CallIntoModule([&](napi_env env) { cb(env, data, hint); }); + CallIntoModule([&](JSVM_Env env) { cb(env, data, hint); }); } - // Enqueue the finalizer to the napi_env's own queue of the second pass + // Enqueue the finalizer to the JSVM_Env's own queue of the second pass // weak callback. // Implementation should drain the queue at the time it is safe to call // into JavaScript. @@ -120,11 +120,11 @@ struct napi_env__ { } virtual void DeleteMe() { - // First we must finalize those references that have `napi_finalizer` + // First we must finalize those references that have `jsvm_finalizer` // callbacks. The reason is that addons might store other references which - // they delete during their `napi_finalizer` callbacks. If we deleted such + // they delete during their `jsvm_finalizer` callbacks. If we deleted such // references here first, they would be doubly deleted when the - // `napi_finalizer` deleted them subsequently. + // `jsvm_finalizer` deleted them subsequently. v8impl::RefTracker::FinalizeAll(&finalizing_reflist); v8impl::RefTracker::FinalizeAll(&reflist); delete this; @@ -136,8 +136,8 @@ struct napi_env__ { v8impl::Persistent last_exception; // We store references in two different lists, depending on whether they have - // `napi_finalizer` callbacks, because we must first finalize the ones that - // have such a callback. See `~napi_env__()` above for details. + // `jsvm_finalizer` callbacks, because we must first finalize the ones that + // have such a callback. See `~JSVM_Env__()` above for details. v8impl::RefTracker::RefList reflist; v8impl::RefTracker::RefList finalizing_reflist; // The invocation order of the finalizers is not determined. @@ -150,57 +150,57 @@ struct napi_env__ { int32_t module_api_version = NODE_API_DEFAULT_MODULE_API_VERSION; protected: - // Should not be deleted directly. Delete with `napi_env__::DeleteMe()` + // Should not be deleted directly. Delete with `JSVM_Env__::DeleteMe()` // instead. - virtual ~napi_env__() = default; + virtual ~JSVM_Env__() = default; }; -inline napi_status napi_clear_last_error(napi_env env) { - env->last_error.error_code = napi_ok; - env->last_error.engine_error_code = 0; - env->last_error.engine_reserved = nullptr; - env->last_error.error_message = nullptr; - return napi_ok; +inline JSVM_Status jsvm_clear_last_error(JSVM_Env env) { + env->last_error.errorCode = JSVM_OK; + env->last_error.engineErrorCode = 0; + env->last_error.engineReserved = nullptr; + env->last_error.errorMessage = nullptr; + return JSVM_OK; } -inline napi_status napi_set_last_error(napi_env env, - napi_status error_code, - uint32_t engine_error_code = 0, - void* engine_reserved = nullptr) { - env->last_error.error_code = error_code; - env->last_error.engine_error_code = engine_error_code; - env->last_error.engine_reserved = engine_reserved; - return error_code; +inline JSVM_Status jsvm_set_last_error(JSVM_Env env, + JSVM_Status errorCode, + uint32_t engineErrorCode = 0, + void* engineReserved = nullptr) { + env->last_error.errorCode = errorCode; + env->last_error.engineErrorCode = engineErrorCode; + env->last_error.engineReserved = engineReserved; + return errorCode; } #define RETURN_STATUS_IF_FALSE(env, condition, status) \ do { \ if (!(condition)) { \ - return napi_set_last_error((env), (status)); \ + return jsvm_set_last_error((env), (status)); \ } \ } while (0) #define RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(env, condition, status) \ do { \ if (!(condition)) { \ - return napi_set_last_error( \ - (env), try_catch.HasCaught() ? napi_pending_exception : (status)); \ + return jsvm_set_last_error( \ + (env), try_catch.HasCaught() ? JSVM_PENDING_EXCEPTION : (status)); \ } \ } while (0) #define CHECK_ENV(env) \ do { \ if ((env) == nullptr) { \ - return napi_invalid_arg; \ + return JSVM_INVALID_ARG; \ } \ } while (0) #define CHECK_ARG(env, arg) \ - RETURN_STATUS_IF_FALSE((env), ((arg) != nullptr), napi_invalid_arg) + RETURN_STATUS_IF_FALSE((env), ((arg) != nullptr), JSVM_INVALID_ARG) #define CHECK_ARG_WITH_PREAMBLE(env, arg) \ RETURN_STATUS_IF_FALSE_WITH_PREAMBLE( \ - (env), ((arg) != nullptr), napi_invalid_arg) + (env), ((arg) != nullptr), JSVM_INVALID_ARG) #define CHECK_MAYBE_EMPTY(env, maybe, status) \ RETURN_STATUS_IF_FALSE((env), !((maybe).IsEmpty()), (status)) @@ -208,17 +208,17 @@ inline napi_status napi_set_last_error(napi_env env, #define CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, maybe, status) \ RETURN_STATUS_IF_FALSE_WITH_PREAMBLE((env), !((maybe).IsEmpty()), (status)) -// NAPI_PREAMBLE is not wrapped in do..while: try_catch must have function scope -#define NAPI_PREAMBLE(env) \ +// JSVM_PREAMBLE is not wrapped in do..while: try_catch must have function scope +#define JSVM_PREAMBLE(env) \ CHECK_ENV((env)); \ RETURN_STATUS_IF_FALSE( \ - (env), (env)->last_exception.IsEmpty(), napi_pending_exception); \ + (env), (env)->last_exception.IsEmpty(), JSVM_PENDING_EXCEPTION); \ RETURN_STATUS_IF_FALSE((env), \ (env)->can_call_into_js(), \ - (env->module_api_version == NAPI_VERSION_EXPERIMENTAL \ - ? napi_cannot_run_js \ - : napi_pending_exception)); \ - napi_clear_last_error((env)); \ + (env->module_api_version == JSVM_VERSION_EXPERIMENTAL \ + ? JSVM_CANNOT_RUN_JS \ + : JSVM_PENDING_EXCEPTION)); \ + jsvm_clear_last_error((env)); \ v8impl::TryCatch try_catch((env)) #define CHECK_TO_TYPE(env, type, context, result, src, status) \ @@ -241,38 +241,38 @@ inline napi_status napi_set_last_error(napi_env env, do { \ CHECK_ARG((env), (src)); \ v8::Local v8value = v8impl::V8LocalValueFromJsValue((src)); \ - RETURN_STATUS_IF_FALSE((env), v8value->IsFunction(), napi_invalid_arg); \ + RETURN_STATUS_IF_FALSE((env), v8value->IsFunction(), JSVM_INVALID_ARG); \ (result) = v8value.As(); \ } while (0) #define CHECK_TO_OBJECT(env, context, result, src) \ - CHECK_TO_TYPE((env), Object, (context), (result), (src), napi_object_expected) + CHECK_TO_TYPE((env), Object, (context), (result), (src), JSVM_OBJECT_EXPECTED) #define CHECK_TO_OBJECT_WITH_PREAMBLE(env, context, result, src) \ CHECK_TO_TYPE_WITH_PREAMBLE( \ - (env), Object, (context), (result), (src), napi_object_expected) + (env), Object, (context), (result), (src), JSVM_OBJECT_EXPECTED) #define CHECK_TO_STRING(env, context, result, src) \ - CHECK_TO_TYPE((env), String, (context), (result), (src), napi_string_expected) + CHECK_TO_TYPE((env), String, (context), (result), (src), JSVM_STRING_EXPECTED) #define GET_RETURN_STATUS(env) \ (!try_catch.HasCaught() \ - ? napi_ok \ - : napi_set_last_error((env), napi_pending_exception)) + ? JSVM_OK \ + : jsvm_set_last_error((env), JSVM_PENDING_EXCEPTION)) #define THROW_RANGE_ERROR_IF_FALSE(env, condition, error, message) \ do { \ if (!(condition)) { \ - napi_throw_range_error((env), (error), (message)); \ - return napi_set_last_error((env), napi_generic_failure); \ + OH_JSVM_ThrowRangeError((env), (error), (message)); \ + return jsvm_set_last_error((env), JSVM_GENERIC_FAILURE); \ } \ } while (0) #define RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(env, condition, status) \ do { \ if (!(condition)) { \ - return napi_set_last_error( \ - (env), try_catch.HasCaught() ? napi_pending_exception : (status)); \ + return jsvm_set_last_error( \ + (env), try_catch.HasCaught() ? JSVM_PENDING_EXCEPTION : (status)); \ } \ } while (0) @@ -281,67 +281,67 @@ inline napi_status napi_set_last_error(napi_env env, #define STATUS_CALL(call) \ do { \ - napi_status status = (call); \ - if (status != napi_ok) return status; \ + JSVM_Status status = (call); \ + if (status != JSVM_OK) return status; \ } while (0) namespace v8impl { -//=== Conversion between V8 Handles and napi_value ======================== +//=== Conversion between V8 Handles and JSVM_Value ======================== // This asserts v8::Local<> will always be implemented with a single // pointer field so that we can pass it around as a void*. -static_assert(sizeof(v8::Local) == sizeof(napi_value), - "Cannot convert between v8::Local and napi_value"); +static_assert(sizeof(v8::Local) == sizeof(JSVM_Value), + "Cannot convert between v8::Local and JSVM_Value"); -inline napi_value JsValueFromV8LocalValue(v8::Local local) { - return reinterpret_cast(*local); +inline JSVM_Value JsValueFromV8LocalValue(v8::Local local) { + return reinterpret_cast(*local); } -inline v8::Local V8LocalValueFromJsValue(napi_value v) { +inline v8::Local V8LocalValueFromJsValue(JSVM_Value v) { v8::Local local; memcpy(static_cast(&local), &v, sizeof(v)); return local; } -// Adapter for napi_finalize callbacks. +// Adapter for JSVM_FINALIZE callbacks. class Finalizer { protected: - Finalizer(napi_env env, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint) + Finalizer(JSVM_Env env, + JSVM_FINALIZE finalizeCallback, + void* finalizeData, + void* finalizeHint) : env_(env), - finalize_callback_(finalize_callback), - finalize_data_(finalize_data), - finalize_hint_(finalize_hint) {} + finalizeCallback_(finalizeCallback), + finalizeData_(finalizeData), + finalizeHint_(finalizeHint) {} virtual ~Finalizer() = default; public: - static Finalizer* New(napi_env env, - napi_finalize finalize_callback = nullptr, - void* finalize_data = nullptr, - void* finalize_hint = nullptr) { - return new Finalizer(env, finalize_callback, finalize_data, finalize_hint); + static Finalizer* New(JSVM_Env env, + JSVM_FINALIZE finalizeCallback = nullptr, + void* finalizeData = nullptr, + void* finalizeHint = nullptr) { + return new Finalizer(env, finalizeCallback, finalizeData, finalizeHint); } - napi_finalize callback() { return finalize_callback_; } + JSVM_FINALIZE callback() { return finalize_callback_; } void* data() { return finalize_data_; } void* hint() { return finalize_hint_; } void ResetFinalizer(); protected: - napi_env env_; - napi_finalize finalize_callback_; + JSVM_Env env_; + JSVM_FINALIZE finalize_callback_; void* finalize_data_; void* finalize_hint_; }; class TryCatch : public v8::TryCatch { public: - explicit TryCatch(napi_env env) : v8::TryCatch(env->isolate), _env(env) {} + explicit TryCatch(JSVM_Env env) : v8::TryCatch(env->isolate), _env(env) {} ~TryCatch() { if (HasCaught()) { @@ -350,7 +350,7 @@ class TryCatch : public v8::TryCatch { } private: - napi_env _env; + JSVM_Env _env; }; // Ownership of a reference. @@ -366,20 +366,20 @@ enum class Ownership { // Wrapper around Finalizer that implements reference counting. class RefBase : public Finalizer, public RefTracker { protected: - RefBase(napi_env env, + RefBase(JSVM_Env env, uint32_t initial_refcount, Ownership ownership, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint); + JSVM_FINALIZE finalizeCallback, + void* finalizeData, + void* finalizeHint); public: - static RefBase* New(napi_env env, + static RefBase* New(JSVM_Env env, uint32_t initial_refcount, Ownership ownership, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint); + JSVM_FINALIZE finalizeCallback, + void* finalizeData, + void* finalizeHint); virtual ~RefBase(); void* Data(); @@ -401,16 +401,16 @@ class RefBase : public Finalizer, public RefTracker { class Reference : public RefBase { protected: template - Reference(napi_env env, v8::Local value, Args&&... args); + Reference(JSVM_Env env, v8::Local value, Args&&... args); public: - static Reference* New(napi_env env, + static Reference* New(JSVM_Env env, v8::Local value, uint32_t initial_refcount, Ownership ownership, - napi_finalize finalize_callback = nullptr, - void* finalize_data = nullptr, - void* finalize_hint = nullptr); + JSVM_FINALIZE finalizeCallback = nullptr, + void* finalizeData = nullptr, + void* finalizeHint = nullptr); virtual ~Reference(); uint32_t Ref(); diff --git a/src/js_native_api_v8_internals.h b/src/js_native_api_v8_internals.h index 4f1b94d3d..691125128 100644 --- a/src/js_native_api_v8_internals.h +++ b/src/js_native_api_v8_internals.h @@ -21,10 +21,10 @@ #define NAPI_ARRAYSIZE(array) node::arraysize((array)) -#define NAPI_FIXED_ONE_BYTE_STRING(isolate, string) \ +#define JSVM_FIXED_ONE_BYTE_STRING(isolate, string) \ node::FIXED_ONE_BYTE_STRING((isolate), (string)) -#define NAPI_PRIVATE_KEY(context, suffix) \ +#define JSVM_PRIVATE_KEY(context, suffix) \ (node::Environment::GetCurrent((context))->napi_##suffix()) namespace v8impl { diff --git a/src/jsvm.h b/src/jsvm.h new file mode 100644 index 000000000..138a711be --- /dev/null +++ b/src/jsvm.h @@ -0,0 +1,561 @@ +#ifndef SRC_JS_NATIVE_API_H_ +#define SRC_JS_NATIVE_API_H_ + +// This file needs to be compatible with C compilers. +#include // NOLINT(modernize-deprecated-headers) +#include // NOLINT(modernize-deprecated-headers) + +// Use INT_MAX, this should only be consumed by the pre-processor anyway. +#define JSVM_VERSION_EXPERIMENTAL 2147483647 +#ifndef NAPI_VERSION +#ifdef JSVM_EXPERIMENTAL +#define NAPI_VERSION JSVM_VERSION_EXPERIMENTAL +#else +// The baseline version for N-API. +// The NAPI_VERSION controls which version will be used by default when +// compilling a native addon. If the addon developer specifically wants to use +// functions available in a new version of N-API that is not yet ported in all +// LTS versions, they can set NAPI_VERSION knowing that they have specifically +// depended on that version. +#define NAPI_VERSION 8 +#endif +#endif + +#include "js_native_api_types.h" + +// If you need __declspec(dllimport), either include instead, or +// define JSVM_EXTERN as __declspec(dllimport) on the compiler's command line. +#ifndef JSVM_EXTERN + #ifdef _WIN32 + #define JSVM_EXTERN __declspec(dllexport) + #elif defined(__wasm32__) + #define JSVM_EXTERN __attribute__((visibility("default"))) \ + __attribute__((__import_module__("napi"))) + #else + #define JSVM_EXTERN __attribute__((visibility("default"))) + #endif +#endif + +#define JSVM_AUTO_LENGTH SIZE_MAX + +#ifdef __cplusplus +#define EXTERN_C_START extern "C" { +#define EXTERN_C_END } +#else +#define EXTERN_C_START +#define EXTERN_C_END +#endif + +EXTERN_C_START + +JSVM_EXTERN JSVM_Status +OH_JSVM_GetLastErrorInfo(JSVM_Env env, + const napi_extended_error_info** result); + +// Getters for defined singletons +JSVM_EXTERN JSVM_Status OH_JSVM_GetUndefined(JSVM_Env env, JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetNull(JSVM_Env env, JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetGlobal(JSVM_Env env, JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetBoolean(JSVM_Env env, + bool value, + JSVM_Value* result); + +// Methods to create Primitive types/Objects +JSVM_EXTERN JSVM_Status OH_JSVM_CreateObject(JSVM_Env env, JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateArray(JSVM_Env env, JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateArrayWithLength(JSVM_Env env, + size_t length, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateDouble(JSVM_Env env, + double value, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateInt32(JSVM_Env env, + int32_t value, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateUint32(JSVM_Env env, + uint32_t value, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateInt64(JSVM_Env env, + int64_t value, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateStringLatin1(JSVM_Env env, + const char* str, + size_t length, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateStringUtf8(JSVM_Env env, + const char* str, + size_t length, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateStringUtf16(JSVM_Env env, + const char16_t* str, + size_t length, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateSymbol(JSVM_Env env, + JSVM_Value description, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateFunction(JSVM_Env env, + const char* utf8name, + size_t length, + JSVM_Callback cb, + void* data, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateError(JSVM_Env env, + JSVM_Value code, + JSVM_Value msg, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateTypeError(JSVM_Env env, + JSVM_Value code, + JSVM_Value msg, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateRangeError(JSVM_Env env, + JSVM_Value code, + JSVM_Value msg, + JSVM_Value* result); + +// Methods to get the native JSVM_Value from Primitive type +JSVM_EXTERN JSVM_Status OH_JSVM_Typeof(JSVM_Env env, + JSVM_Value value, + JSVM_ValueType* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueDouble(JSVM_Env env, + JSVM_Value value, + double* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueInt32(JSVM_Env env, + JSVM_Value value, + int32_t* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueUint32(JSVM_Env env, + JSVM_Value value, + uint32_t* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueInt64(JSVM_Env env, + JSVM_Value value, + int64_t* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueBool(JSVM_Env env, + JSVM_Value value, + bool* result); + +// Copies LATIN-1 encoded bytes from a string into a buffer. +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueStringLatin1(JSVM_Env env, + JSVM_Value value, + char* buf, + size_t bufsize, + size_t* result); + +// Copies UTF-8 encoded bytes from a string into a buffer. +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueStringUtf8(JSVM_Env env, + JSVM_Value value, + char* buf, + size_t bufsize, + size_t* result); + +// Copies UTF-16 encoded bytes from a string into a buffer. +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueStringUtf16(JSVM_Env env, + JSVM_Value value, + char16_t* buf, + size_t bufsize, + size_t* result); + +// Methods to coerce values +// These APIs may execute user scripts +JSVM_EXTERN JSVM_Status OH_JSVM_CoerceToBool(JSVM_Env env, + JSVM_Value value, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CoerceToNumber(JSVM_Env env, + JSVM_Value value, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CoerceToObject(JSVM_Env env, + JSVM_Value value, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CoerceToString(JSVM_Env env, + JSVM_Value value, + JSVM_Value* result); + +// Methods to work with Objects +JSVM_EXTERN JSVM_Status OH_JSVM_GetPrototype(JSVM_Env env, + JSVM_Value object, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetPropertyNames(JSVM_Env env, + JSVM_Value object, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_SetProperty(JSVM_Env env, + JSVM_Value object, + JSVM_Value key, + JSVM_Value value); +JSVM_EXTERN JSVM_Status OH_JSVM_HasProperty(JSVM_Env env, + JSVM_Value object, + JSVM_Value key, + bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetProperty(JSVM_Env env, + JSVM_Value object, + JSVM_Value key, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_DeleteProperty(JSVM_Env env, + JSVM_Value object, + JSVM_Value key, + bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_HasOwnProperty(JSVM_Env env, + JSVM_Value object, + JSVM_Value key, + bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_SetNamedProperty(JSVM_Env env, + JSVM_Value object, + const char* utf8name, + JSVM_Value value); +JSVM_EXTERN JSVM_Status OH_JSVM_HasNamedProperty(JSVM_Env env, + JSVM_Value object, + const char* utf8name, + bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetNamedProperty(JSVM_Env env, + JSVM_Value object, + const char* utf8name, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_SetElement(JSVM_Env env, + JSVM_Value object, + uint32_t index, + JSVM_Value value); +JSVM_EXTERN JSVM_Status OH_JSVM_HasElement(JSVM_Env env, + JSVM_Value object, + uint32_t index, + bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetElement(JSVM_Env env, + JSVM_Value object, + uint32_t index, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_DeleteElement(JSVM_Env env, + JSVM_Value object, + uint32_t index, + bool* result); +JSVM_EXTERN JSVM_Status +OH_JSVM_DefineProperties(JSVM_Env env, + JSVM_Value object, + size_t propertyCount, + const JSVM_PropertyDescriptor* properties); + +// Methods to work with Arrays +JSVM_EXTERN JSVM_Status OH_JSVM_IsArray(JSVM_Env env, + JSVM_Value value, + bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetArrayLength(JSVM_Env env, + JSVM_Value value, + uint32_t* result); + +// Methods to compare values +JSVM_EXTERN JSVM_Status OH_JSVM_StrictEquals(JSVM_Env env, + JSVM_Value lhs, + JSVM_Value rhs, + bool* result); + +// Methods to work with Functions +JSVM_EXTERN JSVM_Status OH_JSVM_CallFunction(JSVM_Env env, + JSVM_Value recv, + JSVM_Value func, + size_t argc, + const JSVM_Value* argv, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_NewInstance(JSVM_Env env, + JSVM_Value constructor, + size_t argc, + const JSVM_Value* argv, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_Instanceof(JSVM_Env env, + JSVM_Value object, + JSVM_Value constructor, + bool* result); + +// Methods to work with napi_callbacks + +// Gets all callback info in a single call. (Ugly, but faster.) +JSVM_EXTERN JSVM_Status OH_JSVM_GetCbInfo( + JSVM_Env env, // [in] NAPI environment handle + JSVM_CallbackInfo cbinfo, // [in] Opaque callback-info handle + size_t* argc, // [in-out] Specifies the size of the provided argv array + // and receives the actual count of args. + JSVM_Value* argv, // [out] Array of values + JSVM_Value* thisArg, // [out] Receives the JS 'this' arg for the call + void** data); // [out] Receives the data pointer for the callback. + +JSVM_EXTERN JSVM_Status OH_JSVM_GetNewTarget(JSVM_Env env, + JSVM_CallbackInfo cbinfo, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status +OH_JSVM_DefineClass(JSVM_Env env, + const char* utf8name, + size_t length, + JSVM_Callback constructor, + void* data, + size_t propertyCount, + const JSVM_PropertyDescriptor* properties, + JSVM_Value* result); + +// Methods to work with external data objects +JSVM_EXTERN JSVM_Status OH_JSVM_Wrap(JSVM_Env env, + JSVM_Value jsObject, + void* nativeObject, + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Ref* result); +JSVM_EXTERN JSVM_Status OH_JSVM_Unwrap(JSVM_Env env, + JSVM_Value jsObject, + void** result); +JSVM_EXTERN JSVM_Status OH_JSVM_RemoveWrap(JSVM_Env env, + JSVM_Value jsObject, + void** result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateExternal(JSVM_Env env, + void* data, + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueExternal(JSVM_Env env, + JSVM_Value value, + void** result); + +// Methods to control object lifespan + +// Set initial_refcount to 0 for a weak reference, >0 for a strong reference. +JSVM_EXTERN JSVM_Status OH_JSVM_CreateReference(JSVM_Env env, + JSVM_Value value, + uint32_t initial_refcount, + JSVM_Ref* result); + +// Deletes a reference. The referenced value is released, and may +// be GC'd unless there are other references to it. +JSVM_EXTERN JSVM_Status OH_JSVM_DeleteReference(JSVM_Env env, JSVM_Ref ref); + +// Increments the reference count, optionally returning the resulting count. +// After this call the reference will be a strong reference because its +// refcount is >0, and the referenced object is effectively "pinned". +// Calling this when the refcount is 0 and the object is unavailable +// results in an error. +JSVM_EXTERN JSVM_Status OH_JSVM_ReferenceRef(JSVM_Env env, + JSVM_Ref ref, + uint32_t* result); + +// Decrements the reference count, optionally returning the resulting count. +// If the result is 0 the reference is now weak and the object may be GC'd +// at any time if there are no other references. Calling this when the +// refcount is already 0 results in an error. +JSVM_EXTERN JSVM_Status OH_JSVM_ReferenceUnref(JSVM_Env env, + JSVM_Ref ref, + uint32_t* result); + +// Attempts to get a referenced value. If the reference is weak, +// the value might no longer be available, in that case the call +// is still successful but the result is NULL. +JSVM_EXTERN JSVM_Status OH_JSVM_GetReferenceValue(JSVM_Env env, + JSVM_Ref ref, + JSVM_Value* result); + +JSVM_EXTERN JSVM_Status OH_JSVM_OpenHandleScope(JSVM_Env env, + napi_handle_scope* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CloseHandleScope(JSVM_Env env, + napi_handle_scope scope); +JSVM_EXTERN JSVM_Status +OH_JSVM_OpenEscapableHandleScope(JSVM_Env env, + JSVM_EscapableHandleScope* result); +JSVM_EXTERN JSVM_Status +OH_JSVM_CloseEscapableHandleScope(JSVM_Env env, + JSVM_EscapableHandleScope scope); + +JSVM_EXTERN JSVM_Status OH_JSVM_EscapeHandle(JSVM_Env env, + JSVM_EscapableHandleScope scope, + JSVM_Value escapee, + JSVM_Value* result); + +// Methods to support error handling +JSVM_EXTERN JSVM_Status OH_JSVM_Throw(JSVM_Env env, JSVM_Value error); +JSVM_EXTERN JSVM_Status OH_JSVM_ThrowError(JSVM_Env env, + const char* code, + const char* msg); +JSVM_EXTERN JSVM_Status OH_JSVM_ThrowTypeError(JSVM_Env env, + const char* code, + const char* msg); +JSVM_EXTERN JSVM_Status OH_JSVM_ThrowRangeError(JSVM_Env env, + const char* code, + const char* msg); +JSVM_EXTERN JSVM_Status OH_JSVM_IsError(JSVM_Env env, + JSVM_Value value, + bool* result); + +// Methods to support catching exceptions +JSVM_EXTERN JSVM_Status OH_JSVM_IsExceptionPending(JSVM_Env env, bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetAndClearLastException(JSVM_Env env, + JSVM_Value* result); + +// Methods to work with array buffers and typed arrays +JSVM_EXTERN JSVM_Status OH_JSVM_IsArraybuffer(JSVM_Env env, + JSVM_Value value, + bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateArraybuffer(JSVM_Env env, + size_t byteLength, + void** data, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status +OH_JSVM_CreateExternalArraybuffer(JSVM_Env env, + void* externalData, + size_t byteLength, + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetArraybufferInfo(JSVM_Env env, + JSVM_Value arraybuffer, + void** data, + size_t* byteLength); +JSVM_EXTERN JSVM_Status OH_JSVM_IsTypedarray(JSVM_Env env, + JSVM_Value value, + bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateTypedarray(JSVM_Env env, + JSVM_TypedarrayType type, + size_t length, + JSVM_Value arraybuffer, + size_t byteOffset, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetTypedarrayInfo(JSVM_Env env, + JSVM_Value typedarray, + JSVM_TypedarrayType* type, + size_t* length, + void** data, + JSVM_Value* arraybuffer, + size_t* byteOffset); + +JSVM_EXTERN JSVM_Status OH_JSVM_CreateDataview(JSVM_Env env, + size_t length, + JSVM_Value arraybuffer, + size_t byteOffset, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_IsDataview(JSVM_Env env, + JSVM_Value value, + bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetDataviewInfo(JSVM_Env env, + JSVM_Value dataview, + size_t* bytelength, + void** data, + JSVM_Value* arraybuffer, + size_t* byteOffset); + +// version management +JSVM_EXTERN JSVM_Status OH_JSVM_GetVersion(JSVM_Env env, uint32_t* result); + +// Promises +JSVM_EXTERN JSVM_Status OH_JSVM_CreatePromise(JSVM_Env env, + JSVM_Deferred* deferred, + JSVM_Value* promise); +JSVM_EXTERN JSVM_Status OH_JSVM_ResolveDeferred(JSVM_Env env, + JSVM_Deferred deferred, + JSVM_Value resolution); +JSVM_EXTERN JSVM_Status OH_JSVM_RejectDeferred(JSVM_Env env, + JSVM_Deferred deferred, + JSVM_Value rejection); +JSVM_EXTERN JSVM_Status OH_JSVM_IsPromise(JSVM_Env env, + JSVM_Value value, + bool* is_promise); + +// Running a script +JSVM_EXTERN JSVM_Status OH_JSVM_RunScript(JSVM_Env env, + JSVM_Value script, + JSVM_Value* result); + +// Memory management +JSVM_EXTERN JSVM_Status OH_JSVM_AdjustExternalMemory(JSVM_Env env, + int64_t changeInBytes, + int64_t* adjustedValue); + +#if NAPI_VERSION >= 5 + +// Dates +JSVM_EXTERN JSVM_Status OH_JSVM_CreateDate(JSVM_Env env, + double time, + JSVM_Value* result); + +JSVM_EXTERN JSVM_Status OH_JSVM_IsDate(JSVM_Env env, + JSVM_Value value, + bool* isDate); + +JSVM_EXTERN JSVM_Status OH_JSVM_GetDateValue(JSVM_Env env, + JSVM_Value value, + double* result); + +// Add finalizer for pointer +JSVM_EXTERN JSVM_Status OH_JSVM_AddFinalizer(JSVM_Env env, + JSVM_Value jsObject, + void* nativeObject, + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Ref* result); + +#endif // NAPI_VERSION >= 5 + +#if NAPI_VERSION >= 6 + +// BigInt +JSVM_EXTERN JSVM_Status OH_JSVM_CreateBigintInt64(JSVM_Env env, + int64_t value, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateBigintUint64(JSVM_Env env, + uint64_t value, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateBigintWords(JSVM_Env env, + int signBit, + size_t wordCount, + const uint64_t* words, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueBigintInt64(JSVM_Env env, + JSVM_Value value, + int64_t* result, + bool* lossless); +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueBigintUint64(JSVM_Env env, + JSVM_Value value, + uint64_t* result, + bool* lossless); +JSVM_EXTERN JSVM_Status OH_JSVM_GetValueBigintWords(JSVM_Env env, + JSVM_Value value, + int* signBit, + size_t* wordCount, + uint64_t* words); + +// Object +JSVM_EXTERN JSVM_Status +OH_JSVM_GetAllPropertyNames(JSVM_Env env, + JSVM_Value object, + JSVM_KeyCollectionMode keyMode, + JSVM_KeyFilter keyFilter, + JSVM_KEY_ConVersion keyConversion, + JSVM_Value* result); + +// Instance data +JSVM_EXTERN JSVM_Status OH_JSVM_SetInstanceData(JSVM_Env env, + void* data, + JSVM_FINALIZE finalizeCb, + void* finalizeHint); + +JSVM_EXTERN JSVM_Status OH_JSVM_GetInstanceData(JSVM_Env env, + void** data); +#endif // NAPI_VERSION >= 6 + +#if NAPI_VERSION >= 7 +// ArrayBuffer detaching +JSVM_EXTERN JSVM_Status OH_JSVM_DetachArraybuffer(JSVM_Env env, + JSVM_Value arraybuffer); + +JSVM_EXTERN JSVM_Status OH_JSVM_IsDetachedArraybuffer(JSVM_Env env, + JSVM_Value value, + bool* result); +#endif // NAPI_VERSION >= 7 + +#if NAPI_VERSION >= 8 +// Type tagging +JSVM_EXTERN JSVM_Status OH_JSVM_TypeTagObject(JSVM_Env env, + JSVM_Value value, + const napi_typeTag* typeTag); + +JSVM_EXTERN JSVM_Status +OH_JSVM_CheckObjectTypeTag(JSVM_Env env, + JSVM_Value value, + const napi_typeTag* typeTag, + bool* result); +JSVM_EXTERN JSVM_Status OH_JSVM_ObjectFreeze(JSVM_Env env, + JSVM_Value object); +JSVM_EXTERN JSVM_Status OH_JSVM_ObjectSeal(JSVM_Env env, + JSVM_Value object); +#endif // NAPI_VERSION >= 8 + +EXTERN_C_END + +#endif // SRC_JS_NATIVE_API_H_ diff --git a/src/jsvm_node_api.h b/src/jsvm_node_api.h new file mode 100644 index 000000000..a07939c87 --- /dev/null +++ b/src/jsvm_node_api.h @@ -0,0 +1,275 @@ +#ifndef SRC_NODE_API_H_ +#define SRC_NODE_API_H_ + +#ifdef BUILDING_NODE_EXTENSION + #ifdef _WIN32 + // Building native module against node + #define JSVM_EXTERN __declspec(dllimport) + #elif defined(__wasm32__) + #define JSVM_EXTERN __attribute__((__import_module__("napi"))) + #endif +#endif +#include "js_native_api.h" +#include "node_api_types.h" + +struct uv_loop_s; // Forward declaration. + +#ifdef _WIN32 +# define JSVM_MODULE_EXPORT __declspec(dllexport) +#else +# define JSVM_MODULE_EXPORT __attribute__((visibility("default"))) +#endif + +#if defined(__GNUC__) +# define JSVM_NO_RETURN __attribute__((noreturn)) +#elif defined(_WIN32) +# define JSVM_NO_RETURN __declspec(noreturn) +#else +# define JSVM_NO_RETURN +#endif + +typedef JSVM_Value (*jsvm_addon_register_func)(JSVM_Env env, + JSVM_Value exports); + +typedef struct jsvm_module { + int nm_version; + unsigned int nm_flags; + const char* nm_filename; + jsvm_addon_register_func nm_register_func; + const char* nm_modname; + void* nm_priv; + void* reserved[4]; +} jsvm_module; + +#define JSVM_MODULE_VERSION 1 + +#if defined(_MSC_VER) +#pragma section(".CRT$XCU", read) +#define NAPI_C_CTOR(fn) \ + static void __cdecl fn(void); \ + __declspec(dllexport, allocate(".CRT$XCU")) void(__cdecl * fn##_)(void) = \ + fn; \ + static void __cdecl fn(void) +#else +#define NAPI_C_CTOR(fn) \ + static void fn(void) __attribute__((constructor)); \ + static void fn(void) +#endif + +#define JSVM_MODULE_X(modname, regfunc, priv, flags) \ + EXTERN_C_START \ + static jsvm_module _module = \ + { \ + JSVM_MODULE_VERSION, \ + flags, \ + __FILE__, \ + regfunc, \ + #modname, \ + priv, \ + {0}, \ + }; \ + NAPI_C_CTOR(_register_ ## modname) { \ + jsvm_module_register(&_module); \ + } \ + EXTERN_C_END + +#define JSVM_MODULE_INITIALIZER_X(base, version) \ + JSVM_MODULE_INITIALIZER_X_HELPER(base, version) +#define JSVM_MODULE_INITIALIZER_X_HELPER(base, version) base##version + +#ifdef __wasm32__ +#define NAPI_WASM_INITIALIZER \ + JSVM_MODULE_INITIALIZER_X(jsvm_register_wasm_v, JSVM_MODULE_VERSION) +#define JSVM_MODULE(modname, regfunc) \ + EXTERN_C_START \ + JSVM_MODULE_EXPORT JSVM_Value NAPI_WASM_INITIALIZER(JSVM_Env env, \ + JSVM_Value exports) { \ + return regfunc(env, exports); \ + } \ + EXTERN_C_END +#else +#define JSVM_MODULE(modname, regfunc) \ + JSVM_MODULE_X(modname, regfunc, NULL, 0) // NOLINT (readability/null_usage) +#endif + +#define JSVM_MODULE_INITIALIZER_BASE jsvm_register_module_v + +#define JSVM_MODULE_INITIALIZER \ + JSVM_MODULE_INITIALIZER_X(JSVM_MODULE_INITIALIZER_BASE, \ + JSVM_MODULE_VERSION) + +#define JSVM_MODULE_INIT() \ + EXTERN_C_START \ + JSVM_MODULE_EXPORT JSVM_Value \ + JSVM_MODULE_INITIALIZER(JSVM_Env env, JSVM_Value exports); \ + EXTERN_C_END \ + JSVM_MODULE(NODE_GYP_MODULE_NAME, JSVM_MODULE_INITIALIZER) \ + JSVM_Value JSVM_MODULE_INITIALIZER(JSVM_Env env, \ + JSVM_Value exports) + +EXTERN_C_START + +JSVM_EXTERN void jsvm_module_register(jsvm_module* mod); + +JSVM_EXTERN JSVM_NO_RETURN void jsvm_fatal_error(const char* location, + size_t location_len, + const char* message, + size_t message_len); + +// Methods for custom handling of async operations +JSVM_EXTERN JSVM_Status jsvm_async_init(JSVM_Env env, + JSVM_Value async_resource, + JSVM_Value async_resource_name, + jsvm_async_context* result); + +JSVM_EXTERN JSVM_Status napi_async_destroy(JSVM_Env env, + jsvm_async_context async_context); + +JSVM_EXTERN JSVM_Status jsvm_make_callback(JSVM_Env env, + jsvm_async_context async_context, + JSVM_Value recv, + JSVM_Value func, + size_t argc, + const JSVM_Value* argv, + JSVM_Value* result); + +// Methods to provide node::Buffer functionality with napi types +JSVM_EXTERN JSVM_Status jsvm_create_buffer(JSVM_Env env, + size_t length, + void** data, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status OH_JSVM_CreateExternal_buffer(JSVM_Env env, + size_t length, + void* data, + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status jsvm_create_buffer_copy(JSVM_Env env, + size_t length, + const void* data, + void** result_data, + JSVM_Value* result); +JSVM_EXTERN JSVM_Status jsvm_is_buffer(JSVM_Env env, + JSVM_Value value, + bool* result); +JSVM_EXTERN JSVM_Status jsvm_get_buffer_info(JSVM_Env env, + JSVM_Value value, + void** data, + size_t* length); + +// Methods to manage simple async operations +JSVM_EXTERN +JSVM_Status jsvm_create_async_work(JSVM_Env env, + JSVM_Value async_resource, + JSVM_Value async_resource_name, + jsvm_async_execute_callback execute, + jsvm_async_complete_callback complete, + void* data, + jsvm_async_work* result); +JSVM_EXTERN JSVM_Status jsvm_delete_async_work(JSVM_Env env, + jsvm_async_work work); +JSVM_EXTERN JSVM_Status jsvm_queue_async_work(JSVM_Env env, + jsvm_async_work work); +JSVM_EXTERN JSVM_Status jsvm_cancel_async_work(JSVM_Env env, + jsvm_async_work work); + +// version management +JSVM_EXTERN +JSVM_Status jsvm_get_node_version(JSVM_Env env, + const jsvm_node_version** version); + +#if NAPI_VERSION >= 2 + +// Return the current libuv event loop for a given environment +JSVM_EXTERN JSVM_Status jsvm_get_uv_event_loop(JSVM_Env env, + struct uv_loop_s** loop); + +#endif // NAPI_VERSION >= 2 + +#if NAPI_VERSION >= 3 + +JSVM_EXTERN JSVM_Status jsvm_fatal_exception(JSVM_Env env, JSVM_Value err); + +JSVM_EXTERN JSVM_Status jsvm_add_env_cleanup_hook(JSVM_Env env, + void (*fun)(void* arg), + void* arg); + +JSVM_EXTERN JSVM_Status jsvm_remove_env_cleanup_hook(JSVM_Env env, + void (*fun)(void* arg), + void* arg); + +JSVM_EXTERN JSVM_Status jsvm_open_callback_scope(JSVM_Env env, + JSVM_Value resource_object, + jsvm_async_context context, + jsvm_callback_scope* result); + +JSVM_EXTERN JSVM_Status jsvm_close_callback_scope(JSVM_Env env, + jsvm_callback_scope scope); + +#endif // NAPI_VERSION >= 3 + +#if NAPI_VERSION >= 4 + +#ifndef __wasm32__ +// Calling into JS from other threads +JSVM_EXTERN JSVM_Status +jsvm_create_threadsafe_function(JSVM_Env env, + JSVM_Value func, + JSVM_Value async_resource, + JSVM_Value async_resource_name, + size_t max_queue_size, + size_t initial_thread_count, + void* thread_finalize_data, + JSVM_FINALIZE thread_finalize_cb, + void* context, + jsvm_threadsafe_function_call_js call_js_cb, + napi_threadsafe_function* result); + +JSVM_EXTERN JSVM_Status +jsvm_get_threadsafe_function_context(napi_threadsafe_function func, + void** result); + +JSVM_EXTERN JSVM_Status +jsvm_call_threadsafe_function(napi_threadsafe_function func, + void* data, + jsvm_threadsafe_function_call_mode is_blocking); + +JSVM_EXTERN JSVM_Status +jsvm_acquire_threadsafe_function(napi_threadsafe_function func); + +JSVM_EXTERN JSVM_Status +jsvm_release_threadsafe_function(napi_threadsafe_function func, + jsvm_threadsafe_function_release_mode mode); + +JSVM_EXTERN JSVM_Status +jsvm_unref_threadsafe_function(JSVM_Env env, napi_threadsafe_function func); + +JSVM_EXTERN JSVM_Status +jsvm_ref_threadsafe_function(JSVM_Env env, napi_threadsafe_function func); +#endif // __wasm32__ + +#endif // NAPI_VERSION >= 4 + +#if NAPI_VERSION >= 8 + +JSVM_EXTERN JSVM_Status jsvm_add_async_cleanup_hook( + JSVM_Env env, + jsvm_async_cleanup_hook hook, + void* arg, + jsvm_async_cleanup_hook_handle* remove_handle); + +JSVM_EXTERN JSVM_Status jsvm_remove_async_cleanup_hook( + jsvm_async_cleanup_hook_handle remove_handle); + +#endif // NAPI_VERSION >= 8 + +#ifdef JSVM_EXPERIMENTAL + +JSVM_EXTERN JSVM_Status +node_api_get_module_file_name(JSVM_Env env, const char** result); + +#endif // JSVM_EXPERIMENTAL + +EXTERN_C_END + +#endif // SRC_NODE_API_H_ diff --git a/src/jsvm_node_api_types.h b/src/jsvm_node_api_types.h new file mode 100644 index 000000000..80b12490b --- /dev/null +++ b/src/jsvm_node_api_types.h @@ -0,0 +1,50 @@ +#ifndef SRC_NODE_API_TYPES_H_ +#define SRC_NODE_API_TYPES_H_ + +#include "js_native_api_types.h" + +typedef struct jsvm_callback_scope__* jsvm_callback_scope; +typedef struct jsvm_async_context__* jsvm_async_context; +typedef struct jsvm_async_work__* jsvm_async_work; +#if NAPI_VERSION >= 4 +typedef struct napi_threadsafe_function__* napi_threadsafe_function; +#endif // NAPI_VERSION >= 4 + +#if NAPI_VERSION >= 4 +typedef enum { + jsvm_tsfn_release, + jsvm_tsfn_abort +} jsvm_threadsafe_function_release_mode; + +typedef enum { + jsvm_tsfn_nonblocking, + napi_tsfn_blocking +} jsvm_threadsafe_function_call_mode; +#endif // NAPI_VERSION >= 4 + +typedef void (*jsvm_async_execute_callback)(JSVM_Env env, + void* data); +typedef void (*jsvm_async_complete_callback)(JSVM_Env env, + JSVM_Status status, + void* data); +#if NAPI_VERSION >= 4 +typedef void (*jsvm_threadsafe_function_call_js)(JSVM_Env env, + JSVM_Value js_callback, + void* context, + void* data); +#endif // NAPI_VERSION >= 4 + +typedef struct { + uint32_t major; + uint32_t minor; + uint32_t patch; + const char* release; +} jsvm_node_version; + +#if NAPI_VERSION >= 8 +typedef struct jsvm_async_cleanup_hook_handle__* jsvm_async_cleanup_hook_handle; +typedef void (*jsvm_async_cleanup_hook)(jsvm_async_cleanup_hook_handle handle, + void* data); +#endif // NAPI_VERSION >= 8 + +#endif // SRC_NODE_API_TYPES_H_ diff --git a/src/jsvm_type.h b/src/jsvm_type.h new file mode 100644 index 000000000..9638e5c89 --- /dev/null +++ b/src/jsvm_type.h @@ -0,0 +1,160 @@ +#ifndef ARK_RUNTIME_JSVM_JSVM_TYPE_H +#define ARK_RUNTIME_JSVM_JSVM_TYPE_H + +// This file needs to be compatible with C compilers. +// This is a public include file, and these includes have essentially +// became part of it's API. +#include // NOLINT(modernize-deprecated-headers) +#include // NOLINT(modernize-deprecated-headers) + +#if !defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900) + typedef uint16_t char16_t; +#endif + +// JSVM API types are all opaque pointers for ABI stability +// typedef undefined structs instead of void* for compile time type safety +typedef struct JSVM_Env__* JSVM_Env; +typedef struct JSVM_Value__* JSVM_Value; +typedef struct JSVM_Ref__* JSVM_Ref; +typedef struct napi_handle_scope__* napi_handle_scope; +typedef struct JSVM_EscapableHandleScope__* JSVM_EscapableHandleScope; +typedef struct JSVM_CallbackInfo__* JSVM_CallbackInfo; +typedef struct JSVM_Deferred__* JSVM_Deferred; + +typedef enum { + JSVM_DEFAULT = 0, + JSVM_WRITABLE = 1 << 0, + JSVM_ENUMERABLE = 1 << 1, + JSVM_CONFIGURABLE = 1 << 2, + + // Used with OH_JSVM_DefineClass to distinguish static properties + // from instance properties. Ignored by OH_JSVM_DefineProperties. + JSVM_STATIC = 1 << 10, + +#if NAPI_VERSION >= 8 + // Default for class methods. + JSVM_DEFAULT_METHOD = JSVM_WRITABLE | JSVM_CONFIGURABLE, + + // Default for object properties, like in JS obj[prop]. + JSVM_DEFAULT_JSPROPERTY = JSVM_WRITABLE | + JSVM_ENUMERABLE | + JSVM_CONFIGURABLE, +#endif // NAPI_VERSION >= 8 +} JSVM_PropertyAttributes; + +typedef enum { + // ES6 types (corresponds to typeof) + JSVM_UNDEFINED, + JSVM_NULL, + JSVM_BOOLEAN, + JSVM_NUMBER, + JSVM_STRING, + JSVM_SYMBOL, + JSVM_OBJECT, + JSVM_FUNCTION, + JSVM_EXTERNAL, + JSVM_BIGINT, +} JSVM_ValueType; + +typedef enum { + JSVM_INT8_ARRAY, + JSVM_UINT8_ARRAY, + JSVM_UINT8_CLAMPED_ARRAY, + JSVM_INT16_ARRAY, + JAVM_UINT16_ARRAY, + JSVM_INT32_ARRAY, + JSVM_UINT32_ARRAY, + JSVM_FLOAT32_ARRAY, + JSVM_FLOAT64_ARRAY, + JSVM_BIGINT64_ARRAY, + JSVM_BIGUINT64_ARRAY, +} JSVM_TypedarrayType; + +typedef enum { + JSVM_OK, + JSVM_INVALID_ARG, + JSVM_OBJECT_EXPECTED, + JSVM_STRING_EXPECTED, + JSVM_NAME_EXPECTED, + JSVM_FUNCTION_EXPECTED, + JSVM_NUMBER_EXPECTED, + JSVM_BOOL_EXPECTED, + JSVM_ARRAY_EXPECTED, + JSVM_GENERIC_FAILURE, + JSVM_PENDING_EXCEPTION, + JSVM_CENCELLED, + JSVM_ESCAPE_CALLED_TWICE, + JSVM_HANDLE_SCOPE_MISMATCH, + JSVM_CALLBACK_SCOPE_MISMATCH, + JSVM_QUEUE_FULL, + JSVM_CLOSING, + JSVM_BIGINT_EXPECTED, + JSVM_DATA_EXPECTED, + JSVM_CALLBACK_SCOPE_MISMATCH, + JSVM_DETACHABLE_ARRAYBUFFER_EXPECTED, + JSVM_WOULD_DEADLOCK // unused +} JSVM_Status; +// Note: when adding a new enum value to `JSVM_Status`, please also update +// * `const int last_status` in the definition of `OH_JSVM_GetLastErrorInfo()' +// in file js_native_api_v8.cc. +// * `const char* error_messages[]` in file js_native_api_v8.cc with a brief +// message explaining the error. +// * the definition of `JSVM_Status` in doc/api/n-api.md to reflect the newly +// added value(s). + +typedef JSVM_Value (*JSVM_Callback)(JSVM_Env env, + JSVM_CallbackInfo info); +typedef void (*JSVM_FINALIZE)(JSVM_Env env, + void* finalizeData, + void* finalizeHint); + +typedef struct { + // One of utf8name or name should be NULL. + const char* utf8name; + JSVM_Value name; + + JSVM_Callback method; + JSVM_Callback getter; + JSVM_Callback setter; + JSVM_Value value; + + JSVM_PropertyAttributes attributes; + void* data; +} JSVM_PropertyDescriptor; + +typedef struct { + const char* errorMessage; + void* engineReserved; + uint32_t engineErrorCode; + JSVM_Status errorCode; +} napi_extended_error_info; + +#if NAPI_VERSION >= 6 +typedef enum { + JSVM_KEY_INCLUDE_PROTOTYPES, + JSVM_KEY_OWN_ONLY +} JSVM_KeyCollectionMode; + +typedef enum { + JSVM_KEY_ALL_PROPERTIES = 0, + JSVM_KEY_WRITABLE = 1, + JSVM_KEY_ENUMERABLE = 1 << 1, + JSVM_KEY_CONFIGURABLE = 1 << 2, + JSVM_KEY_SKIP_STRINGS = 1 << 3, + JSVM_KEY_SKIP_SYMBOLS = 1 << 4 +} JSVM_KeyFilter; + +typedef enum { + JSVM_KEY_KEEP_NUMBERS, + JSVM_KEY_NUMBERS_TO_STRINGS +} JSVM_KEY_ConVersion; +#endif // NAPI_VERSION >= 6 + +#if NAPI_VERSION >= 8 +typedef struct { + uint64_t lower; + uint64_t upper; +} napi_type_tag; +#endif // NAPI_VERSION >= 8 + +#endif // ARK_RUNTIME_JSVM_JSVM_TYPE_H diff --git a/src/node.h b/src/node.h index ac9bce58f..3d8ccfed6 100644 --- a/src/node.h +++ b/src/node.h @@ -75,7 +75,7 @@ #include "v8-platform.h" // NOLINT(build/include_order) #include "node_version.h" // NODE_MODULE_VERSION -#define NAPI_EXPERIMENTAL +#define JSVM_EXPERIMENTAL #include "node_api.h" #include @@ -1093,7 +1093,7 @@ extern "C" NODE_EXTERN void node_module_register(void* mod); // the time during which the Environment exists. NODE_EXTERN void AddLinkedBinding(Environment* env, const node_module& mod); NODE_EXTERN void AddLinkedBinding(Environment* env, - const struct napi_module& mod); + const struct jsvm_module& mod); NODE_EXTERN void AddLinkedBinding(Environment* env, const char* name, addon_context_register_func fn, @@ -1101,7 +1101,7 @@ NODE_EXTERN void AddLinkedBinding(Environment* env, NODE_EXTERN void AddLinkedBinding( Environment* env, const char* name, - napi_addon_register_func fn, + jsvm_addon_register_func fn, int32_t module_api_version = NODE_API_DEFAULT_MODULE_API_VERSION); /* Registers a callback with the passed-in Environment instance. The callback diff --git a/src/node_api.cc b/src/node_api.cc index 7537dc20b..1a6cc46a5 100644 --- a/src/node_api.cc +++ b/src/node_api.cc @@ -1,6 +1,6 @@ #include "async_wrap-inl.h" #include "env-inl.h" -#define NAPI_EXPERIMENTAL +#define JSVM_EXPERIMENTAL #include "js_native_api_v8.h" #include "memory_tracker-inl.h" #include "node_api.h" @@ -22,34 +22,34 @@ node_napi_env__::node_napi_env__(v8::Local context, const std::string& module_filename, int32_t module_api_version) - : napi_env__(context, module_api_version), filename(module_filename) { + : JSVM_Env__(context, module_api_version), filename(module_filename) { CHECK_NOT_NULL(node_env()); } void node_napi_env__::DeleteMe() { destructing = true; DrainFinalizerQueue(); - napi_env__::DeleteMe(); + JSVM_Env__::DeleteMe(); } bool node_napi_env__::can_call_into_js() const { return node_env()->can_call_into_js(); } -void node_napi_env__::CallFinalizer(napi_finalize cb, void* data, void* hint) { +void node_napi_env__::CallFinalizer(JSVM_FINALIZE cb, void* data, void* hint) { CallFinalizer(cb, data, hint); } template -void node_napi_env__::CallFinalizer(napi_finalize cb, void* data, void* hint) { +void node_napi_env__::CallFinalizer(JSVM_FINALIZE cb, void* data, void* hint) { v8::HandleScope handle_scope(isolate); v8::Context::Scope context_scope(context()); CallbackIntoModule( - [&](napi_env env) { cb(env, data, hint); }); + [&](JSVM_Env env) { cb(env, data, hint); }); } void node_napi_env__::EnqueueFinalizer(v8impl::RefTracker* finalizer) { - napi_env__::EnqueueFinalizer(finalizer); + JSVM_Env__::EnqueueFinalizer(finalizer); // Schedule a second pass only when it has not been scheduled, and not // destructing the env. // When the env is being destructed, queued finalizers are drained in the @@ -87,7 +87,7 @@ void node_napi_env__::trigger_fatal_exception(v8::Local local_err) { // release. template void node_napi_env__::CallbackIntoModule(T&& call) { - CallIntoModule(call, [](napi_env env_, v8::Local local_err) { + CallIntoModule(call, [](JSVM_Env env_, v8::Local local_err) { node_napi_env__* env = static_cast(env_); if (env->terminatedOrTerminating()) { return; @@ -116,12 +116,12 @@ namespace { class BufferFinalizer : private Finalizer { public: - static BufferFinalizer* New(napi_env env, - napi_finalize finalize_callback = nullptr, - void* finalize_data = nullptr, - void* finalize_hint = nullptr) { + static BufferFinalizer* New(JSVM_Env env, + JSVM_FINALIZE finalizeCallback = nullptr, + void* finalizeData = nullptr, + void* finalizeHint = nullptr) { return new BufferFinalizer( - env, finalize_callback, finalize_data, finalize_hint); + env, finalizeCallback, finalizeData, finalizeHint); } // node::Buffer::FreeCallback static void FinalizeBufferCallback(char* data, void* hint) { @@ -141,11 +141,11 @@ class BufferFinalizer : private Finalizer { }; private: - BufferFinalizer(napi_env env, - napi_finalize finalize_callback, - void* finalize_data, - void* finalize_hint) - : Finalizer(env, finalize_callback, finalize_data, finalize_hint) { + BufferFinalizer(JSVM_Env env, + JSVM_FINALIZE finalizeCallback, + void* finalizeData, + void* finalizeHint) + : Finalizer(env, finalizeCallback, finalizeData, finalizeHint) { env_->Ref(); } @@ -155,25 +155,25 @@ class BufferFinalizer : private Finalizer { void ThrowNodeApiVersionError(node::Environment* node_env, const char* module_name, int32_t module_api_version) { - std::string error_message; - error_message += module_name; - error_message += " requires Node-API version "; - error_message += std::to_string(module_api_version); - error_message += ", but this version of Node.js only supports version "; - error_message += NODE_STRINGIFY(NAPI_VERSION) " add-ons."; - node_env->ThrowError(error_message.c_str()); + std::string errorMessage; + errorMessage += module_name; + errorMessage += " requires Node-API version "; + errorMessage += std::to_string(module_api_version); + errorMessage += ", but this version of Node.js only supports version "; + errorMessage += NODE_STRINGIFY(NAPI_VERSION) " add-ons."; + node_env->ThrowError(errorMessage.c_str()); } -inline napi_env NewEnv(v8::Local context, +inline JSVM_Env NewEnv(v8::Local context, const std::string& module_filename, int32_t module_api_version) { - node_napi_env result; + node_jsvm_env result; // Validate module_api_version. if (module_api_version < NODE_API_DEFAULT_MODULE_API_VERSION) { module_api_version = NODE_API_DEFAULT_MODULE_API_VERSION; } else if (module_api_version > NAPI_VERSION && - module_api_version != NAPI_VERSION_EXPERIMENTAL) { + module_api_version != JSVM_VERSION_EXPERIMENTAL) { node::Environment* node_env = node::Environment::GetCurrent(context); CHECK_NOT_NULL(node_env); ThrowNodeApiVersionError( @@ -183,14 +183,14 @@ inline napi_env NewEnv(v8::Local context, result = new node_napi_env__(context, module_filename, module_api_version); // TODO(addaleax): There was previously code that tried to delete the - // napi_env when its v8::Context was garbage collected; - // However, as long as N-API addons using this napi_env are in place, + // JSVM_Env when its v8::Context was garbage collected; + // However, as long as N-API addons using this JSVM_Env are in place, // the Context needs to be accessible and alive. // Ideally, we'd want an on-addon-unload hook that takes care of this - // once all N-API addons using this napi_env are unloaded. + // once all N-API addons using this JSVM_Env are unloaded. // For now, a per-Environment cleanup hook is the best we can do. result->node_env()->AddCleanupHook( - [](void* arg) { static_cast(arg)->Unref(); }, + [](void* arg) { static_cast(arg)->Unref(); }, static_cast(result)); return result; @@ -204,10 +204,10 @@ class ThreadSafeFunction : public node::AsyncResource { size_t thread_count_, void* context_, size_t max_queue_size_, - node_napi_env env_, + node_jsvm_env env_, void* finalize_data_, - napi_finalize finalize_cb_, - napi_threadsafe_function_call_js call_js_cb_) + JSVM_FINALIZE finalize_cb_, + jsvm_threadsafe_function_call_js call_js_cb_) : AsyncResource(env_->isolate, resource, *v8::String::Utf8Value(env_->isolate, name)), @@ -217,8 +217,8 @@ class ThreadSafeFunction : public node::AsyncResource { context(context_), max_queue_size(max_queue_size_), env(env_), - finalize_data(finalize_data_), - finalize_cb(finalize_cb_), + finalizeData(finalizeData_), + finalizeCb(finalizeCb_), call_js_cb(call_js_cb_ == nullptr ? CallJs : call_js_cb_), handles_closing(false) { ref.Reset(env->isolate, func); @@ -233,55 +233,55 @@ class ThreadSafeFunction : public node::AsyncResource { // These methods can be called from any thread. - napi_status Push(void* data, napi_threadsafe_function_call_mode mode) { + JSVM_Status Push(void* data, jsvm_threadsafe_function_call_mode mode) { node::Mutex::ScopedLock lock(this->mutex); while (queue.size() >= max_queue_size && max_queue_size > 0 && !is_closing) { - if (mode == napi_tsfn_nonblocking) { - return napi_queue_full; + if (mode == jsvm_tsfn_nonblocking) { + return JSVM_QUEUE_FULL; } cond->Wait(lock); } if (is_closing) { if (thread_count == 0) { - return napi_invalid_arg; + return JSVM_INVALID_ARG; } else { thread_count--; - return napi_closing; + return JSVM_CLOSING; } } else { queue.push(data); Send(); - return napi_ok; + return JSVM_OK; } } - napi_status Acquire() { + JSVM_Status Acquire() { node::Mutex::ScopedLock lock(this->mutex); if (is_closing) { - return napi_closing; + return JSVM_CLOSING; } thread_count++; - return napi_ok; + return JSVM_OK; } - napi_status Release(napi_threadsafe_function_release_mode mode) { + JSVM_Status Release(jsvm_threadsafe_function_release_mode mode) { node::Mutex::ScopedLock lock(this->mutex); if (thread_count == 0) { - return napi_invalid_arg; + return JSVM_INVALID_ARG; } thread_count--; - if (thread_count == 0 || mode == napi_tsfn_abort) { + if (thread_count == 0 || mode == jsvm_tsfn_abort) { if (!is_closing) { - is_closing = (mode == napi_tsfn_abort); + is_closing = (mode == jsvm_tsfn_abort); if (is_closing && max_queue_size > 0) { cond->Signal(lock); } @@ -289,7 +289,7 @@ class ThreadSafeFunction : public node::AsyncResource { } } - return napi_ok; + return JSVM_OK; } void EmptyQueueAndDelete() { @@ -301,7 +301,7 @@ class ThreadSafeFunction : public node::AsyncResource { // These methods must only be called from the loop thread. - napi_status Init() { + JSVM_Status Init() { ThreadSafeFunction* ts_fn = this; uv_loop_t* loop = env->node_env()->event_loop(); @@ -310,7 +310,7 @@ class ThreadSafeFunction : public node::AsyncResource { cond = std::make_unique(); } if (max_queue_size == 0 || cond) { - return napi_ok; + return JSVM_OK; } env->node_env()->CloseHandle( @@ -329,19 +329,19 @@ class ThreadSafeFunction : public node::AsyncResource { delete ts_fn; - return napi_generic_failure; + return JSVM_GENERIC_FAILURE; } - napi_status Unref() { + JSVM_Status Unref() { uv_unref(reinterpret_cast(&async)); - return napi_ok; + return JSVM_OK; } - napi_status Ref() { + JSVM_Status Ref() { uv_ref(reinterpret_cast(&async)); - return napi_ok; + return JSVM_OK; } inline void* Context() { return context; } @@ -406,14 +406,14 @@ class ThreadSafeFunction : public node::AsyncResource { if (popped_value) { v8::HandleScope scope(env->isolate); CallbackScope cb_scope(this); - napi_value js_callback = nullptr; + JSVM_Value js_callback = nullptr; if (!ref.IsEmpty()) { v8::Local js_cb = v8::Local::New(env->isolate, ref); js_callback = v8impl::JsValueFromV8LocalValue(js_cb); } env->CallbackIntoModule( - [&](napi_env env) { call_js_cb(env, js_callback, context, data); }); + [&](JSVM_Env env) { call_js_cb(env, js_callback, context, data); }); } return has_more; @@ -421,9 +421,9 @@ class ThreadSafeFunction : public node::AsyncResource { void Finalize() { v8::HandleScope scope(env->isolate); - if (finalize_cb) { + if (finalizeCb) { CallbackScope cb_scope(this); - env->CallFinalizer(finalize_cb, finalize_data, context); + env->CallFinalizer(finalizeCb, finalizeData, context); } EmptyQueueAndDelete(); } @@ -463,23 +463,23 @@ class ThreadSafeFunction : public node::AsyncResource { // Default way of calling into JavaScript. Used when ThreadSafeFunction is // without a call_js_cb_. - static void CallJs(napi_env env, napi_value cb, void* context, void* data) { + static void CallJs(JSVM_Env env, JSVM_Value cb, void* context, void* data) { if (!(env == nullptr || cb == nullptr)) { - napi_value recv; - napi_status status; + JSVM_Value recv; + JSVM_Status status; - status = napi_get_undefined(env, &recv); - if (status != napi_ok) { - napi_throw_error(env, - "ERR_NAPI_TSFN_GET_UNDEFINED", + status = OH_JSVM_GetUndefined(env, &recv); + if (status != JSVM_OK) { + OH_JSVM_ThrowError(env, + "ERR_JSVM_TSFN_GET_UNDEFINED", "Failed to retrieve undefined value"); return; } - status = napi_call_function(env, recv, cb, 0, nullptr, nullptr); - if (status != napi_ok && status != napi_pending_exception) { - napi_throw_error( - env, "ERR_NAPI_TSFN_CALL_JS", "Failed to call JS callback"); + status = OH_JSVM_CallFunction(env, recv, cb, 0, nullptr, nullptr); + if (status != JSVM_OK && status != JSVM_PENDING_EXCEPTION) { + OH_JSVM_ThrowError( + env, "ERR_JSVM_TSFN_CALL_JS", "Failed to call JS callback"); return; } } @@ -519,10 +519,10 @@ class ThreadSafeFunction : public node::AsyncResource { // These are variables accessed only from the loop thread. v8impl::Persistent ref; - node_napi_env env; - void* finalize_data; - napi_finalize finalize_cb; - napi_threadsafe_function_call_js call_js_cb; + node_jsvm_env env; + void* finalizeData; + JSVM_FINALIZE finalizeCb; + jsvm_threadsafe_function_call_js call_js_cb; bool handles_closing; }; @@ -534,7 +534,7 @@ class ThreadSafeFunction : public node::AsyncResource { */ class AsyncContext { public: - AsyncContext(node_napi_env env, + AsyncContext(node_jsvm_env env, v8::Local resource_object, const v8::Local resource_name, bool externally_managed_resource) @@ -576,10 +576,10 @@ class AsyncContext { {async_id_, trigger_async_id_}); } - inline napi_callback_scope OpenCallbackScope() { + inline jsvm_callback_scope OpenCallbackScope() { EnsureReference(); - napi_callback_scope it = - reinterpret_cast(new CallbackScope(this)); + jsvm_callback_scope it = + reinterpret_cast(new CallbackScope(this)); env_->open_callback_scopes++; return it; } @@ -601,8 +601,8 @@ class AsyncContext { return {async_id_, trigger_async_id_}; } - static inline void CloseCallbackScope(node_napi_env env, - napi_callback_scope s) { + static inline void CloseCallbackScope(node_jsvm_env env, + jsvm_callback_scope s) { CallbackScope* callback_scope = reinterpret_cast(s); delete callback_scope; env->open_callback_scopes--; @@ -624,7 +624,7 @@ class AsyncContext { async_context->async_context()) {} }; - node_napi_env env_; + node_jsvm_env env_; double async_id_; double trigger_async_id_; v8::Global resource_; @@ -638,15 +638,15 @@ class AsyncContext { // Intercepts the Node-V8 module registration callback. Converts parameters // to NAPI equivalents and then calls the registration callback specified // by the NAPI module. -static void napi_module_register_cb(v8::Local exports, +static void jsvm_module_register_cb(v8::Local exports, v8::Local module, v8::Local context, void* priv) { - napi_module_register_by_symbol( + jsvm_module_register_by_symbol( exports, module, context, - static_cast(priv)->nm_register_func); + static_cast(priv)->nm_register_func); } template @@ -654,11 +654,11 @@ static void node_api_context_register_func(v8::Local exports, v8::Local module, v8::Local context, void* priv) { - napi_module_register_by_symbol( + jsvm_module_register_by_symbol( exports, module, context, - reinterpret_cast(priv), + reinterpret_cast(priv), module_api_version); } @@ -680,18 +680,18 @@ node::addon_context_register_func get_node_api_context_register_func( return node_api_context_register_func; } else if (module_api_version == 9) { return node_api_context_register_func<9>; - } else if (module_api_version == NAPI_VERSION_EXPERIMENTAL) { - return node_api_context_register_func; + } else if (module_api_version == JSVM_VERSION_EXPERIMENTAL) { + return node_api_context_register_func; } else { v8impl::ThrowNodeApiVersionError(node_env, module_name, module_api_version); return nullptr; } } -void napi_module_register_by_symbol(v8::Local exports, +void jsvm_module_register_by_symbol(v8::Local exports, v8::Local module, v8::Local context, - napi_addon_register_func init, + jsvm_addon_register_func init, int32_t module_api_version) { node::Environment* node_env = node::Environment::GetCurrent(context); std::string module_filename = ""; @@ -719,11 +719,11 @@ void napi_module_register_by_symbol(v8::Local exports, module_filename = node::url::FromFilePath(filename.ToStringView()); } - // Create a new napi_env for this specific module. - napi_env env = v8impl::NewEnv(context, module_filename, module_api_version); + // Create a new JSVM_Env for this specific module. + JSVM_Env env = v8impl::NewEnv(context, module_filename, module_api_version); - napi_value _exports = nullptr; - env->CallIntoModule([&](napi_env env) { + JSVM_Value _exports = nullptr; + env->CallIntoModule([&](JSVM_Env env) { _exports = init(env, v8impl::JsValueFromV8LocalValue(exports)); }); @@ -732,140 +732,140 @@ void napi_module_register_by_symbol(v8::Local exports, // the module. if (_exports != nullptr && _exports != v8impl::JsValueFromV8LocalValue(exports)) { - napi_value _module = v8impl::JsValueFromV8LocalValue(module); - napi_set_named_property(env, _module, "exports", _exports); + JSVM_Value _module = v8impl::JsValueFromV8LocalValue(module); + OH_JSVM_SetNamedProperty(env, _module, "exports", _exports); } } namespace node { -node_module napi_module_to_node_module(const napi_module* mod) { +node_module jsvm_module_to_node_module(const jsvm_module* mod) { return { -1, mod->nm_flags | NM_F_DELETEME, nullptr, mod->nm_filename, nullptr, - napi_module_register_cb, + jsvm_module_register_cb, mod->nm_modname, - const_cast(mod), // priv + const_cast(mod), // priv nullptr, }; } } // namespace node // Registers a NAPI module. -void NAPI_CDECL napi_module_register(napi_module* mod) { +void JSVM_CDECL jsvm_module_register(jsvm_module* mod) { node::node_module* nm = new node::node_module(node::napi_module_to_node_module(mod)); node::node_module_register(nm); } -napi_status NAPI_CDECL napi_add_env_cleanup_hook(napi_env env, - napi_cleanup_hook fun, +JSVM_Status JSVM_CDECL jsvm_add_env_cleanup_hook(JSVM_Env env, + jsvm_cleanup_hook fun, void* arg) { CHECK_ENV(env); CHECK_ARG(env, fun); node::AddEnvironmentCleanupHook(env->isolate, fun, arg); - return napi_ok; + return JSVM_OK; } -napi_status NAPI_CDECL napi_remove_env_cleanup_hook(napi_env env, - napi_cleanup_hook fun, +JSVM_Status JSVM_CDECL jsvm_remove_env_cleanup_hook(JSVM_Env env, + jsvm_cleanup_hook fun, void* arg) { CHECK_ENV(env); CHECK_ARG(env, fun); node::RemoveEnvironmentCleanupHook(env->isolate, fun, arg); - return napi_ok; + return JSVM_OK; } -struct napi_async_cleanup_hook_handle__ { - napi_async_cleanup_hook_handle__(napi_env env, - napi_async_cleanup_hook user_hook, +struct jsvm_async_cleanup_hook_handle__ { + jsvm_async_cleanup_hook_handle__(JSVM_Env env, + jsvm_async_cleanup_hook user_hook, void* user_data) : env_(env), user_hook_(user_hook), user_data_(user_data) { handle_ = node::AddEnvironmentCleanupHook(env->isolate, Hook, this); env->Ref(); } - ~napi_async_cleanup_hook_handle__() { + ~jsvm_async_cleanup_hook_handle__() { node::RemoveEnvironmentCleanupHook(std::move(handle_)); if (done_cb_ != nullptr) done_cb_(done_data_); // Release the `env` handle asynchronously since it would be surprising if // a call to a N-API function would destroy `env` synchronously. - static_cast(env_)->node_env()->SetImmediate( + static_cast(env_)->node_env()->SetImmediate( [env = env_](node::Environment*) { env->Unref(); }); } static void Hook(void* data, void (*done_cb)(void*), void* done_data) { - napi_async_cleanup_hook_handle__* handle = - static_cast(data); + jsvm_async_cleanup_hook_handle__* handle = + static_cast(data); handle->done_cb_ = done_cb; handle->done_data_ = done_data; handle->user_hook_(handle, handle->user_data_); } node::AsyncCleanupHookHandle handle_; - napi_env env_ = nullptr; - napi_async_cleanup_hook user_hook_ = nullptr; + JSVM_Env env_ = nullptr; + jsvm_async_cleanup_hook user_hook_ = nullptr; void* user_data_ = nullptr; void (*done_cb_)(void*) = nullptr; void* done_data_ = nullptr; }; -napi_status NAPI_CDECL -napi_add_async_cleanup_hook(napi_env env, - napi_async_cleanup_hook hook, +JSVM_Status JSVM_CDECL +jsvm_add_async_cleanup_hook(JSVM_Env env, + jsvm_async_cleanup_hook hook, void* arg, - napi_async_cleanup_hook_handle* remove_handle) { + jsvm_async_cleanup_hook_handle* remove_handle) { CHECK_ENV(env); CHECK_ARG(env, hook); - napi_async_cleanup_hook_handle__* handle = - new napi_async_cleanup_hook_handle__(env, hook, arg); + jsvm_async_cleanup_hook_handle__* handle = + new jsvm_async_cleanup_hook_handle__(env, hook, arg); if (remove_handle != nullptr) *remove_handle = handle; - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL -napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle) { - if (remove_handle == nullptr) return napi_invalid_arg; +JSVM_Status JSVM_CDECL +jsvm_remove_async_cleanup_hook(jsvm_async_cleanup_hook_handle remove_handle) { + if (remove_handle == nullptr) return JSVM_INVALID_ARG; delete remove_handle; - return napi_ok; + return JSVM_OK; } -napi_status NAPI_CDECL napi_fatal_exception(napi_env env, napi_value err) { - NAPI_PREAMBLE(env); +JSVM_Status JSVM_CDECL jsvm_fatal_exception(JSVM_Env env, JSVM_Value err) { + JSVM_PREAMBLE(env); CHECK_ARG(env, err); v8::Local local_err = v8impl::V8LocalValueFromJsValue(err); - static_cast(env)->trigger_fatal_exception(local_err); + static_cast(env)->trigger_fatal_exception(local_err); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -NAPI_NO_RETURN void NAPI_CDECL napi_fatal_error(const char* location, +JSVM_NO_RETURN void JSVM_CDECL jsvm_fatal_error(const char* location, size_t location_len, const char* message, size_t message_len) { std::string location_string; std::string message_string; - if (location_len != NAPI_AUTO_LENGTH) { + if (location_len != JSVM_AUTO_LENGTH) { location_string.assign(const_cast(location), location_len); } else { location_string.assign(const_cast(location), strlen(location)); } - if (message_len != NAPI_AUTO_LENGTH) { + if (message_len != JSVM_AUTO_LENGTH) { message_string.assign(const_cast(message), message_len); } else { message_string.assign(const_cast(message), strlen(message)); @@ -874,12 +874,12 @@ NAPI_NO_RETURN void NAPI_CDECL napi_fatal_error(const char* location, node::OnFatalError(location_string.c_str(), message_string.c_str()); } -napi_status NAPI_CDECL -napi_open_callback_scope(napi_env env, - napi_value /** ignored */, - napi_async_context async_context_handle, - napi_callback_scope* result) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw +JSVM_Status JSVM_CDECL +jsvm_open_callback_scope(JSVM_Env env, + JSVM_Value /** ignored */, + jsvm_async_context async_context_handle, + jsvm_callback_scope* result) { + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, result); @@ -889,29 +889,29 @@ napi_open_callback_scope(napi_env env, *result = node_async_context->OpenCallbackScope(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_close_callback_scope(napi_env env, - napi_callback_scope scope) { - // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw +JSVM_Status JSVM_CDECL jsvm_close_callback_scope(JSVM_Env env, + jsvm_callback_scope scope) { + // Omit JSVM_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); CHECK_ARG(env, scope); if (env->open_callback_scopes == 0) { - return napi_callback_scope_mismatch; + return JSVM_CALLBACK_SCOPE_MISMATCH; } - v8impl::AsyncContext::CloseCallbackScope(reinterpret_cast(env), + v8impl::AsyncContext::CloseCallbackScope(reinterpret_cast(env), scope); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_async_init(napi_env env, - napi_value async_resource, - napi_value async_resource_name, - napi_async_context* result) { +JSVM_Status JSVM_CDECL jsvm_async_init(JSVM_Env env, + JSVM_Value async_resource, + JSVM_Value async_resource_name, + jsvm_async_context* result) { CHECK_ENV(env); CHECK_ARG(env, async_resource_name); CHECK_ARG(env, result); @@ -933,18 +933,18 @@ napi_status NAPI_CDECL napi_async_init(napi_env env, CHECK_TO_STRING(env, context, v8_resource_name, async_resource_name); v8impl::AsyncContext* async_context = - new v8impl::AsyncContext(reinterpret_cast(env), + new v8impl::AsyncContext(reinterpret_cast(env), v8_resource, v8_resource_name, externally_managed_resource); - *result = reinterpret_cast(async_context); + *result = reinterpret_cast(async_context); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_async_destroy(napi_env env, - napi_async_context async_context) { +JSVM_Status JSVM_CDECL napi_async_destroy(JSVM_Env env, + jsvm_async_context async_context) { CHECK_ENV(env); CHECK_ARG(env, async_context); @@ -953,17 +953,17 @@ napi_status NAPI_CDECL napi_async_destroy(napi_env env, delete node_async_context; - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_make_callback(napi_env env, - napi_async_context async_context, - napi_value recv, - napi_value func, +JSVM_Status JSVM_CDECL jsvm_make_callback(JSVM_Env env, + jsvm_async_context async_context, + JSVM_Value recv, + JSVM_Value func, size_t argc, - const napi_value* argv, - napi_value* result) { - NAPI_PREAMBLE(env); + const JSVM_Value* argv, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, recv); if (argc > 0) { CHECK_ARG(env, argv); @@ -985,7 +985,7 @@ napi_status NAPI_CDECL napi_make_callback(napi_env env, v8recv, v8func, argc, - reinterpret_cast*>(const_cast(argv)), + reinterpret_cast*>(const_cast(argv)), {0, 0}); } else { v8impl::AsyncContext* node_async_context = @@ -994,13 +994,13 @@ napi_status NAPI_CDECL napi_make_callback(napi_env env, v8recv, v8func, argc, - reinterpret_cast*>(const_cast(argv))); + reinterpret_cast*>(const_cast(argv))); } if (try_catch.HasCaught()) { - return napi_set_last_error(env, napi_pending_exception); + return jsvm_set_last_error(env, JSVM_PENDING_EXCEPTION); } else { - CHECK_MAYBE_EMPTY(env, callback_result, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, callback_result, JSVM_GENERIC_FAILURE); if (result != nullptr) { *result = v8impl::JsValueFromV8LocalValue(callback_result.ToLocalChecked()); @@ -1010,16 +1010,16 @@ napi_status NAPI_CDECL napi_make_callback(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_create_buffer(napi_env env, +JSVM_Status JSVM_CDECL jsvm_create_buffer(JSVM_Env env, size_t length, void** data, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::MaybeLocal maybe = node::Buffer::New(env->isolate, length); - CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, maybe, JSVM_GENERIC_FAILURE); v8::Local buffer = maybe.ToLocalChecked(); @@ -1032,24 +1032,24 @@ napi_status NAPI_CDECL napi_create_buffer(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_create_external_buffer(napi_env env, +JSVM_Status JSVM_CDECL OH_JSVM_CreateExternal_buffer(JSVM_Env env, size_t length, void* data, - napi_finalize finalize_cb, - void* finalize_hint, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_FINALIZE finalizeCb, + void* finalizeHint, + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); #if defined(V8_ENABLE_SANDBOX) - return napi_set_last_error(env, napi_no_external_buffers_allowed); + return jsvm_set_last_error(env, JSVM_NO_EXTERNAL_BUFFERS_ALLOWED); #endif v8::Isolate* isolate = env->isolate; // The finalizer object will delete itself after invoking the callback. v8impl::BufferFinalizer* finalizer = - v8impl::BufferFinalizer::New(env, finalize_cb, nullptr, finalize_hint); + v8impl::BufferFinalizer::New(env, finalizeCb, nullptr, finalizeHint); v8::MaybeLocal maybe = node::Buffer::New(isolate, @@ -1058,7 +1058,7 @@ napi_status NAPI_CDECL napi_create_external_buffer(napi_env env, v8impl::BufferFinalizer::FinalizeBufferCallback, finalizer); - CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, maybe, JSVM_GENERIC_FAILURE); *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked()); return GET_RETURN_STATUS(env); @@ -1068,18 +1068,18 @@ napi_status NAPI_CDECL napi_create_external_buffer(napi_env env, // coverity[leaked_storage] } -napi_status NAPI_CDECL napi_create_buffer_copy(napi_env env, +JSVM_Status JSVM_CDECL jsvm_create_buffer_copy(JSVM_Env env, size_t length, const void* data, void** result_data, - napi_value* result) { - NAPI_PREAMBLE(env); + JSVM_Value* result) { + JSVM_PREAMBLE(env); CHECK_ARG(env, result); v8::MaybeLocal maybe = node::Buffer::Copy(env->isolate, static_cast(data), length); - CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure); + CHECK_MAYBE_EMPTY(env, maybe, JSVM_GENERIC_FAILURE); v8::Local buffer = maybe.ToLocalChecked(); *result = v8impl::JsValueFromV8LocalValue(buffer); @@ -1091,19 +1091,19 @@ napi_status NAPI_CDECL napi_create_buffer_copy(napi_env env, return GET_RETURN_STATUS(env); } -napi_status NAPI_CDECL napi_is_buffer(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL jsvm_is_buffer(JSVM_Env env, + JSVM_Value value, bool* result) { CHECK_ENV(env); CHECK_ARG(env, value); CHECK_ARG(env, result); *result = node::Buffer::HasInstance(v8impl::V8LocalValueFromJsValue(value)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_buffer_info(napi_env env, - napi_value value, +JSVM_Status JSVM_CDECL jsvm_get_buffer_info(JSVM_Env env, + JSVM_Value value, void** data, size_t* length) { CHECK_ENV(env); @@ -1118,43 +1118,43 @@ napi_status NAPI_CDECL napi_get_buffer_info(napi_env env, *length = node::Buffer::Length(buffer); } - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_node_version(napi_env env, - const napi_node_version** result) { +JSVM_Status JSVM_CDECL jsvm_get_node_version(JSVM_Env env, + const jsvm_node_version** result) { CHECK_ENV(env); CHECK_ARG(env, result); - static const napi_node_version version = { + static const jsvm_node_version version = { NODE_MAJOR_VERSION, NODE_MINOR_VERSION, NODE_PATCH_VERSION, NODE_RELEASE}; *result = &version; - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } namespace { namespace uvimpl { -static napi_status ConvertUVErrorCode(int code) { +static JSVM_Status ConvertUVErrorCode(int code) { switch (code) { case 0: - return napi_ok; + return JSVM_OK; case UV_EINVAL: - return napi_invalid_arg; + return JSVM_INVALID_ARG; case UV_ECANCELED: - return napi_cancelled; + return JSVM_CENCELLED; default: - return napi_generic_failure; + return JSVM_GENERIC_FAILURE; } } // Wrapper around uv_work_t which calls user-provided callbacks. class Work : public node::AsyncResource, public node::ThreadPoolWork { private: - explicit Work(node_napi_env env, + explicit Work(node_jsvm_env env, v8::Local async_resource, v8::Local async_resource_name, - napi_async_execute_callback execute, - napi_async_complete_callback complete = nullptr, + jsvm_async_execute_callback execute, + jsvm_async_complete_callback complete = nullptr, void* data = nullptr) : AsyncResource( env->isolate, @@ -1169,11 +1169,11 @@ class Work : public node::AsyncResource, public node::ThreadPoolWork { ~Work() override = default; public: - static Work* New(node_napi_env env, + static Work* New(node_jsvm_env env, v8::Local async_resource, v8::Local async_resource_name, - napi_async_execute_callback execute, - napi_async_complete_callback complete, + jsvm_async_execute_callback execute, + jsvm_async_complete_callback complete, void* data) { return new Work( env, async_resource, async_resource_name, execute, complete, data); @@ -1192,7 +1192,7 @@ class Work : public node::AsyncResource, public node::ThreadPoolWork { CallbackScope callback_scope(this); - _env->CallbackIntoModule([&](napi_env env) { + _env->CallbackIntoModule([&](JSVM_Env env) { _complete(env, ConvertUVErrorCode(status), _data); }); @@ -1201,10 +1201,10 @@ class Work : public node::AsyncResource, public node::ThreadPoolWork { } private: - node_napi_env _env; + node_jsvm_env _env; void* _data; - napi_async_execute_callback _execute; - napi_async_complete_callback _complete; + jsvm_async_execute_callback _execute; + jsvm_async_complete_callback _complete; }; } // end of namespace uvimpl @@ -1213,20 +1213,20 @@ class Work : public node::AsyncResource, public node::ThreadPoolWork { #define CALL_UV(env, condition) \ do { \ int result = (condition); \ - napi_status status = uvimpl::ConvertUVErrorCode(result); \ - if (status != napi_ok) { \ - return napi_set_last_error(env, status, result); \ + JSVM_Status status = uvimpl::ConvertUVErrorCode(result); \ + if (status != JSVM_OK) { \ + return jsvm_set_last_error(env, status, result); \ } \ } while (0) -napi_status NAPI_CDECL -napi_create_async_work(napi_env env, - napi_value async_resource, - napi_value async_resource_name, - napi_async_execute_callback execute, - napi_async_complete_callback complete, +JSVM_Status JSVM_CDECL +jsvm_create_async_work(JSVM_Env env, + JSVM_Value async_resource, + JSVM_Value async_resource_name, + jsvm_async_execute_callback execute, + jsvm_async_complete_callback complete, void* data, - napi_async_work* result) { + jsvm_async_work* result) { CHECK_ENV(env); CHECK_ARG(env, execute); CHECK_ARG(env, result); @@ -1243,52 +1243,52 @@ napi_create_async_work(napi_env env, v8::Local resource_name; CHECK_TO_STRING(env, context, resource_name, async_resource_name); - uvimpl::Work* work = uvimpl::Work::New(reinterpret_cast(env), + uvimpl::Work* work = uvimpl::Work::New(reinterpret_cast(env), resource, resource_name, execute, complete, data); - *result = reinterpret_cast(work); + *result = reinterpret_cast(work); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_delete_async_work(napi_env env, - napi_async_work work) { +JSVM_Status JSVM_CDECL jsvm_delete_async_work(JSVM_Env env, + jsvm_async_work work) { CHECK_ENV(env); CHECK_ARG(env, work); uvimpl::Work::Delete(reinterpret_cast(work)); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_uv_event_loop(napi_env env, uv_loop_t** loop) { +JSVM_Status JSVM_CDECL jsvm_get_uv_event_loop(JSVM_Env env, uv_loop_t** loop) { CHECK_ENV(env); CHECK_ARG(env, loop); - *loop = reinterpret_cast(env)->node_env()->event_loop(); - return napi_clear_last_error(env); + *loop = reinterpret_cast(env)->node_env()->event_loop(); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_queue_async_work(napi_env env, - napi_async_work work) { +JSVM_Status JSVM_CDECL jsvm_queue_async_work(JSVM_Env env, + jsvm_async_work work) { CHECK_ENV(env); CHECK_ARG(env, work); uv_loop_t* event_loop = nullptr; - STATUS_CALL(napi_get_uv_event_loop(env, &event_loop)); + STATUS_CALL(jsvm_get_uv_event_loop(env, &event_loop)); uvimpl::Work* w = reinterpret_cast(work); w->ScheduleWork(); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL napi_cancel_async_work(napi_env env, - napi_async_work work) { +JSVM_Status JSVM_CDECL jsvm_cancel_async_work(JSVM_Env env, + jsvm_async_work work) { CHECK_ENV(env); CHECK_ARG(env, work); @@ -1296,27 +1296,27 @@ napi_status NAPI_CDECL napi_cancel_async_work(napi_env env, CALL_UV(env, w->CancelWork()); - return napi_clear_last_error(env); + return jsvm_clear_last_error(env); } -napi_status NAPI_CDECL -napi_create_threadsafe_function(napi_env env, - napi_value func, - napi_value async_resource, - napi_value async_resource_name, +JSVM_Status JSVM_CDECL +jsvm_create_threadsafe_function(JSVM_Env env, + JSVM_Value func, + JSVM_Value async_resource, + JSVM_Value async_resource_name, size_t max_queue_size, size_t initial_thread_count, void* thread_finalize_data, - napi_finalize thread_finalize_cb, + JSVM_FINALIZE thread_finalize_cb, void* context, - napi_threadsafe_function_call_js call_js_cb, + jsvm_threadsafe_function_call_js call_js_cb, napi_threadsafe_function* result) { CHECK_ENV(env); CHECK_ARG(env, async_resource_name); - RETURN_STATUS_IF_FALSE(env, initial_thread_count > 0, napi_invalid_arg); + RETURN_STATUS_IF_FALSE(env, initial_thread_count > 0, JSVM_INVALID_ARG); CHECK_ARG(env, result); - napi_status status = napi_ok; + JSVM_Status status = JSVM_OK; v8::Local v8_func; if (func == nullptr) { @@ -1344,71 +1344,71 @@ napi_create_threadsafe_function(napi_env env, initial_thread_count, context, max_queue_size, - reinterpret_cast(env), + reinterpret_cast(env), thread_finalize_data, thread_finalize_cb, call_js_cb); if (ts_fn == nullptr) { - status = napi_generic_failure; + status = JSVM_GENERIC_FAILURE; } else { // Init deletes ts_fn upon failure. status = ts_fn->Init(); - if (status == napi_ok) { + if (status == JSVM_OK) { *result = reinterpret_cast(ts_fn); } } - return napi_set_last_error(env, status); + return jsvm_set_last_error(env, status); } -napi_status NAPI_CDECL napi_get_threadsafe_function_context( +JSVM_Status JSVM_CDECL jsvm_get_threadsafe_function_context( napi_threadsafe_function func, void** result) { CHECK_NOT_NULL(func); CHECK_NOT_NULL(result); *result = reinterpret_cast(func)->Context(); - return napi_ok; + return JSVM_OK; } -napi_status NAPI_CDECL -napi_call_threadsafe_function(napi_threadsafe_function func, +JSVM_Status JSVM_CDECL +jsvm_call_threadsafe_function(napi_threadsafe_function func, void* data, - napi_threadsafe_function_call_mode is_blocking) { + jsvm_threadsafe_function_call_mode is_blocking) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Push(data, is_blocking); } -napi_status NAPI_CDECL -napi_acquire_threadsafe_function(napi_threadsafe_function func) { +JSVM_Status JSVM_CDECL +jsvm_acquire_threadsafe_function(napi_threadsafe_function func) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Acquire(); } -napi_status NAPI_CDECL napi_release_threadsafe_function( - napi_threadsafe_function func, napi_threadsafe_function_release_mode mode) { +JSVM_Status JSVM_CDECL jsvm_release_threadsafe_function( + napi_threadsafe_function func, jsvm_threadsafe_function_release_mode mode) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Release(mode); } -napi_status NAPI_CDECL -napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func) { +JSVM_Status JSVM_CDECL +jsvm_unref_threadsafe_function(JSVM_Env env, napi_threadsafe_function func) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Unref(); } -napi_status NAPI_CDECL -napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func) { +JSVM_Status JSVM_CDECL +jsvm_ref_threadsafe_function(JSVM_Env env, napi_threadsafe_function func) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Ref(); } -napi_status NAPI_CDECL node_api_get_module_file_name(napi_env env, +JSVM_Status JSVM_CDECL node_api_get_module_file_name(JSVM_Env env, const char** result) { CHECK_ENV(env); CHECK_ARG(env, result); - *result = static_cast(env)->GetFilename(); - return napi_clear_last_error(env); + *result = static_cast(env)->GetFilename(); + return jsvm_clear_last_error(env); } diff --git a/src/node_api_internals.h b/src/node_api_internals.h index 25f6b2919..10dd2cb7c 100644 --- a/src/node_api_internals.h +++ b/src/node_api_internals.h @@ -2,21 +2,21 @@ #define SRC_NODE_API_INTERNALS_H_ #include "v8.h" -#define NAPI_EXPERIMENTAL +#define JSVM_EXPERIMENTAL #include "env-inl.h" #include "js_native_api_v8.h" #include "node_api.h" #include "util-inl.h" -struct node_napi_env__ : public napi_env__ { +struct node_JSVM_Env__ : public JSVM_Env__ { node_napi_env__(v8::Local context, const std::string& module_filename, int32_t module_api_version); bool can_call_into_js() const override; - void CallFinalizer(napi_finalize cb, void* data, void* hint) override; + void CallFinalizer(JSVM_FINALIZE cb, void* data, void* hint) override; template - void CallFinalizer(napi_finalize cb, void* data, void* hint); + void CallFinalizer(JSVM_FINALIZE cb, void* data, void* hint); void EnqueueFinalizer(v8impl::RefTracker* finalizer) override; void DrainFinalizerQueue(); @@ -37,6 +37,6 @@ struct node_napi_env__ : public napi_env__ { bool finalization_scheduled = false; }; -using node_napi_env = node_napi_env__*; +using node_jsvm_env = node_jsvm_env__*; #endif // SRC_NODE_API_INTERNALS_H_ diff --git a/src/node_binding.cc b/src/node_binding.cc index 259ce86b4..3586890d4 100644 --- a/src/node_binding.cc +++ b/src/node_binding.cc @@ -403,10 +403,10 @@ inline InitializerCallback GetInitializerCallback(DLib* dlib) { return reinterpret_cast(dlib->GetSymbolAddress(name)); } -inline napi_addon_register_func GetNapiInitializerCallback(DLib* dlib) { +inline jsvm_addon_register_func GetNapiInitializerCallback(DLib* dlib) { const char* name = - STRINGIFY(NAPI_MODULE_INITIALIZER_BASE) STRINGIFY(NAPI_MODULE_VERSION); - return reinterpret_cast( + STRINGIFY(JSVM_MODULE_INITIALIZER_BASE) STRINGIFY(JSVM_MODULE_VERSION); + return reinterpret_cast( dlib->GetSymbolAddress(name)); } @@ -491,13 +491,13 @@ void DLOpen(const FunctionCallbackInfo& args) { if (auto callback = GetInitializerCallback(dlib)) { callback(exports, module, context); return true; - } else if (auto napi_callback = GetNapiInitializerCallback(dlib)) { + } else if (auto JSVM_Callback = GetNapiInitializerCallback(dlib)) { int32_t module_api_version = NODE_API_DEFAULT_MODULE_API_VERSION; if (auto get_version = GetNapiAddonGetApiVersionCallback(dlib)) { module_api_version = get_version(); } - napi_module_register_by_symbol( - exports, module, context, napi_callback, module_api_version); + jsvm_module_register_by_symbol( + exports, module, context, JSVM_Callback, module_api_version); return true; } else { mp = dlib->GetSavedModuleFromGlobalHandleMap(); diff --git a/src/node_binding.h b/src/node_binding.h index 32106afb0..f94fc6c95 100644 --- a/src/node_binding.h +++ b/src/node_binding.h @@ -8,7 +8,7 @@ #endif #include "node.h" -#define NAPI_EXPERIMENTAL +#define JSVM_EXPERIMENTAL #include "node_api.h" #include "uv.h" @@ -37,11 +37,11 @@ static_assert(static_cast(NM_F_LINKED) == nullptr}; \ void _register_##modname() { node_module_register(&_module); } -void napi_module_register_by_symbol( +void jsvm_module_register_by_symbol( v8::Local exports, v8::Local module, v8::Local context, - napi_addon_register_func init, + jsvm_addon_register_func init, int32_t module_api_version = NODE_API_DEFAULT_MODULE_API_VERSION); node::addon_context_register_func get_node_api_context_register_func( diff --git a/src/node_internals.h b/src/node_internals.h index 427cfab4e..1e7faa758 100644 --- a/src/node_internals.h +++ b/src/node_internals.h @@ -163,7 +163,7 @@ v8::MaybeLocal New(Environment* env, // Creates a Buffer instance over an existing ArrayBuffer. v8::MaybeLocal New(Environment* env, v8::Local ab, - size_t byte_offset, + size_t byteOffset, size_t length); // Construct a Buffer from a MaybeStackBuffer (and also its subclasses like // Utf8Value and TwoByteValue). @@ -402,7 +402,7 @@ namespace fs { std::string Basename(const std::string& str, const std::string& extension); } // namespace fs -node_module napi_module_to_node_module(const napi_module* mod); +node_module jsvm_module_to_node_module(const jsvm_module* mod); std::ostream& operator<<(std::ostream& output, const std::vector& v); -- Gitee