From 93c874fdbeae4619f246215ba2ee08170164f963 Mon Sep 17 00:00:00 2001 From: Vladimir Morozov Date: Fri, 18 Mar 2022 15:59:02 -0700 Subject: [PATCH] node-api: format Node-API related code PR-URL: https://github.com/nodejs/node/pull/42396 Reviewed-By: Anna Henningsen Reviewed-By: Michael Dawson Reviewed-By: Darshan Sen --- src/js_native_api.h | 81 ++--- src/js_native_api_types.h | 9 +- src/js_native_api_v8.cc | 583 +++++++++++++------------------ src/js_native_api_v8.h | 183 +++++----- src/js_native_api_v8_internals.h | 12 +- src/node_api.cc | 319 ++++++++--------- src/node_api.h | 113 +++--- src/node_api_types.h | 3 +- 8 files changed, 577 insertions(+), 726 deletions(-) diff --git a/src/js_native_api.h b/src/js_native_api.h index 50ccf11e240580..364d3672d1c344 100644 --- a/src/js_native_api.h +++ b/src/js_native_api.h @@ -2,8 +2,8 @@ #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) +#include // NOLINT(modernize-deprecated-headers) // Use INT_MAX, this should only be consumed by the pre-processor anyway. #define NAPI_VERSION_EXPERIMENTAL 2147483647 @@ -26,14 +26,15 @@ // If you need __declspec(dllimport), either include instead, or // define NAPI_EXTERN as __declspec(dllimport) on the compiler's command line. #ifndef NAPI_EXTERN - #ifdef _WIN32 - #define NAPI_EXTERN __declspec(dllexport) - #elif defined(__wasm32__) - #define NAPI_EXTERN __attribute__((visibility("default"))) \ - __attribute__((__import_module__("napi"))) - #else - #define NAPI_EXTERN __attribute__((visibility("default"))) - #endif +#ifdef _WIN32 +#define NAPI_EXTERN __declspec(dllexport) +#elif defined(__wasm32__) +#define NAPI_EXTERN \ + __attribute__((visibility("default"))) \ + __attribute__((__import_module__("napi"))) +#else +#define NAPI_EXTERN __attribute__((visibility("default"))) +#endif #endif #define NAPI_AUTO_LENGTH SIZE_MAX @@ -49,8 +50,7 @@ EXTERN_C_START NAPI_EXTERN napi_status -napi_get_last_error_info(napi_env env, - const napi_extended_error_info** result); +napi_get_last_error_info(napi_env env, const napi_extended_error_info** result); // Getters for defined singletons NAPI_EXTERN napi_status napi_get_undefined(napi_env env, napi_value* result); @@ -145,18 +145,12 @@ NAPI_EXTERN napi_status napi_get_value_bool(napi_env env, bool* result); // Copies LATIN-1 encoded bytes from a string into a buffer. -NAPI_EXTERN napi_status napi_get_value_string_latin1(napi_env env, - napi_value value, - char* buf, - size_t bufsize, - size_t* result); +NAPI_EXTERN napi_status napi_get_value_string_latin1( + napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result); // Copies UTF-8 encoded bytes from a string into a buffer. -NAPI_EXTERN napi_status napi_get_value_string_utf8(napi_env env, - napi_value value, - char* buf, - size_t bufsize, - size_t* result); +NAPI_EXTERN napi_status napi_get_value_string_utf8( + napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result); // Copies UTF-16 encoded bytes from a string into a buffer. NAPI_EXTERN napi_status napi_get_value_string_utf16(napi_env env, @@ -208,17 +202,17 @@ NAPI_EXTERN napi_status napi_has_own_property(napi_env env, napi_value key, bool* result); NAPI_EXTERN napi_status napi_set_named_property(napi_env env, - napi_value object, - const char* utf8name, - napi_value value); + napi_value object, + const char* utf8name, + napi_value value); NAPI_EXTERN napi_status napi_has_named_property(napi_env env, - napi_value object, - const char* utf8name, - bool* result); + napi_value object, + const char* utf8name, + bool* result); NAPI_EXTERN napi_status napi_get_named_property(napi_env env, - napi_value object, - const char* utf8name, - napi_value* result); + napi_value object, + const char* utf8name, + napi_value* result); NAPI_EXTERN napi_status napi_set_element(napi_env env, napi_value object, uint32_t index, @@ -359,12 +353,10 @@ NAPI_EXTERN napi_status napi_open_handle_scope(napi_env env, napi_handle_scope* result); NAPI_EXTERN napi_status napi_close_handle_scope(napi_env env, napi_handle_scope scope); -NAPI_EXTERN napi_status -napi_open_escapable_handle_scope(napi_env env, - napi_escapable_handle_scope* result); -NAPI_EXTERN napi_status -napi_close_escapable_handle_scope(napi_env env, - napi_escapable_handle_scope scope); +NAPI_EXTERN napi_status napi_open_escapable_handle_scope( + napi_env env, napi_escapable_handle_scope* result); +NAPI_EXTERN napi_status napi_close_escapable_handle_scope( + napi_env env, napi_escapable_handle_scope scope); NAPI_EXTERN napi_status napi_escape_handle(napi_env env, napi_escapable_handle_scope scope, @@ -377,11 +369,11 @@ NAPI_EXTERN napi_status napi_throw_error(napi_env env, const char* code, const char* msg); NAPI_EXTERN napi_status napi_throw_type_error(napi_env env, - const char* code, - const char* msg); + const char* code, + const char* msg); NAPI_EXTERN napi_status napi_throw_range_error(napi_env env, - const char* code, - const char* msg); + const char* code, + const char* msg); #ifdef NAPI_EXPERIMENTAL NAPI_EXTERN napi_status node_api_throw_syntax_error(napi_env env, const char* code, @@ -542,8 +534,7 @@ NAPI_EXTERN napi_status napi_set_instance_data(napi_env env, napi_finalize finalize_cb, void* finalize_hint); -NAPI_EXTERN napi_status napi_get_instance_data(napi_env env, - void** data); +NAPI_EXTERN napi_status napi_get_instance_data(napi_env env, void** data); #endif // NAPI_VERSION >= 6 #if NAPI_VERSION >= 7 @@ -567,10 +558,8 @@ napi_check_object_type_tag(napi_env env, napi_value value, const napi_type_tag* type_tag, bool* result); -NAPI_EXTERN napi_status napi_object_freeze(napi_env env, - napi_value object); -NAPI_EXTERN napi_status napi_object_seal(napi_env env, - napi_value object); +NAPI_EXTERN napi_status napi_object_freeze(napi_env env, napi_value object); +NAPI_EXTERN napi_status napi_object_seal(napi_env env, napi_value object); #endif // NAPI_VERSION >= 8 EXTERN_C_END diff --git a/src/js_native_api_types.h b/src/js_native_api_types.h index 6aba06629b3154..da4bff19d38044 100644 --- a/src/js_native_api_types.h +++ b/src/js_native_api_types.h @@ -8,7 +8,7 @@ #include // NOLINT(modernize-deprecated-headers) #if !defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900) - typedef uint16_t char16_t; +typedef uint16_t char16_t; #endif // JSVM API types are all opaque pointers for ABI stability @@ -36,9 +36,7 @@ typedef enum { napi_default_method = napi_writable | napi_configurable, // Default for object properties, like in JS obj[prop]. - napi_default_jsproperty = napi_writable | - napi_enumerable | - napi_configurable, + napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable, #endif // NAPI_VERSION >= 8 } napi_property_attributes; @@ -102,8 +100,7 @@ typedef enum { // * the definition of `napi_status` in doc/api/n-api.md to reflect the newly // added value(s). -typedef napi_value (*napi_callback)(napi_env env, - napi_callback_info info); +typedef napi_value (*napi_callback)(napi_env env, napi_callback_info info); typedef void (*napi_finalize)(napi_env env, void* finalize_data, void* finalize_hint); diff --git a/src/js_native_api_v8.cc b/src/js_native_api_v8.cc index 1c29c43836a0c3..611a0521fceab8 100644 --- a/src/js_native_api_v8.cc +++ b/src/js_native_api_v8.cc @@ -1,43 +1,41 @@ +#include #include // INT_MAX #include -#include #define NAPI_EXPERIMENTAL #include "env-inl.h" -#include "js_native_api_v8.h" #include "js_native_api.h" +#include "js_native_api_v8.h" #include "util-inl.h" -#define CHECK_MAYBE_NOTHING(env, maybe, status) \ +#define CHECK_MAYBE_NOTHING(env, maybe, status) \ RETURN_STATUS_IF_FALSE((env), !((maybe).IsNothing()), (status)) -#define CHECK_MAYBE_NOTHING_WITH_PREAMBLE(env, maybe, status) \ +#define CHECK_MAYBE_NOTHING_WITH_PREAMBLE(env, maybe, status) \ RETURN_STATUS_IF_FALSE_WITH_PREAMBLE((env), !((maybe).IsNothing()), (status)) -#define CHECK_TO_NUMBER(env, context, result, src) \ +#define CHECK_TO_NUMBER(env, context, result, src) \ CHECK_TO_TYPE((env), Number, (context), (result), (src), napi_number_expected) // n-api defines NAPI_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 // 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"); \ - 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); \ - auto str_maybe = v8::String::NewFromUtf8( \ - (env)->isolate, (str), v8::NewStringType::kInternalized, \ - static_cast(len)); \ - CHECK_MAYBE_EMPTY((env), str_maybe, napi_generic_failure); \ - (result) = str_maybe.ToLocalChecked(); \ +#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"); \ + 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); \ + auto str_maybe = v8::String::NewFromUtf8((env)->isolate, \ + (str), \ + v8::NewStringType::kInternalized, \ + static_cast(len)); \ + CHECK_MAYBE_EMPTY((env), str_maybe, napi_generic_failure); \ + (result) = str_maybe.ToLocalChecked(); \ } while (0) -#define CHECK_NEW_FROM_UTF8(env, result, str) \ +#define CHECK_NEW_FROM_UTF8(env, result, str) \ CHECK_NEW_FROM_UTF8_LEN((env), (result), (str), NAPI_AUTO_LENGTH) #define CREATE_TYPED_ARRAY( \ @@ -45,12 +43,15 @@ do { \ if ((size_of_element) > 1) { \ THROW_RANGE_ERROR_IF_FALSE( \ - (env), (byte_offset) % (size_of_element) == 0, \ + (env), \ + (byte_offset) % (size_of_element) == 0, \ "ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT", \ - "start offset of "#type" should be a multiple of "#size_of_element); \ + "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(), \ + THROW_RANGE_ERROR_IF_FALSE( \ + (env), \ + (length) * (size_of_element) + (byte_offset) <= buffer->ByteLength(), \ "ERR_NAPI_INVALID_TYPEDARRAY_LENGTH", \ "Invalid typed array length"); \ (out) = v8::type::New((buffer), (byte_offset), (length)); \ @@ -60,15 +61,15 @@ namespace v8impl { namespace { -inline static napi_status -V8NameFromPropertyDescriptor(napi_env env, - const napi_property_descriptor* p, - v8::Local* result) { +inline static napi_status V8NameFromPropertyDescriptor( + napi_env env, + const napi_property_descriptor* p, + v8::Local* result) { if (p->utf8name != nullptr) { CHECK_NEW_FROM_UTF8(env, *result, p->utf8name); } else { v8::Local property_value = - v8impl::V8LocalValueFromJsValue(p->name); + v8impl::V8LocalValueFromJsValue(p->name); RETURN_STATUS_IF_FALSE(env, property_value->IsName(), napi_name_expected); *result = property_value.As(); @@ -85,7 +86,7 @@ inline static v8::PropertyAttribute V8PropertyAttributesFromDescriptor( // The napi_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 & napi_writable) == 0) { attribute_flags |= v8::PropertyAttribute::ReadOnly; } @@ -99,13 +100,13 @@ inline static v8::PropertyAttribute V8PropertyAttributesFromDescriptor( return static_cast(attribute_flags); } -inline static napi_deferred -JsDeferredFromNodePersistent(v8impl::Persistent* local) { +inline static napi_deferred JsDeferredFromNodePersistent( + v8impl::Persistent* local) { return reinterpret_cast(local); } -inline static v8impl::Persistent* -NodePersistentFromJsDeferred(napi_deferred local) { +inline static v8impl::Persistent* NodePersistentFromJsDeferred( + napi_deferred local) { return reinterpret_cast*>(local); } @@ -126,9 +127,7 @@ class EscapableHandleScopeWrapper { public: explicit EscapableHandleScopeWrapper(v8::Isolate* isolate) : scope(isolate), escape_called_(false) {} - bool escape_called() const { - return escape_called_; - } + bool escape_called() const { return escape_called_; } template v8::Local Escape(v8::Local handle) { escape_called_ = true; @@ -140,13 +139,13 @@ class EscapableHandleScopeWrapper { bool escape_called_; }; -inline static napi_handle_scope -JsHandleScopeFromV8HandleScope(HandleScopeWrapper* s) { +inline static napi_handle_scope JsHandleScopeFromV8HandleScope( + HandleScopeWrapper* s) { return reinterpret_cast(s); } -inline static HandleScopeWrapper* -V8HandleScopeFromJsHandleScope(napi_handle_scope s) { +inline static HandleScopeWrapper* V8HandleScopeFromJsHandleScope( + napi_handle_scope s) { return reinterpret_cast(s); } @@ -177,9 +176,11 @@ inline static napi_status ConcludeDeferred(napi_env env, auto v8_resolver = v8_deferred.As(); - v8::Maybe success = is_resolved ? - v8_resolver->Resolve(context, v8impl::V8LocalValueFromJsValue(result)) : - v8_resolver->Reject(context, v8impl::V8LocalValueFromJsValue(result)); + v8::Maybe success = + is_resolved ? v8_resolver->Resolve( + context, v8impl::V8LocalValueFromJsValue(result)) + : v8_resolver->Reject( + context, v8impl::V8LocalValueFromJsValue(result)); delete deferred_ref; @@ -188,10 +189,7 @@ inline static napi_status ConcludeDeferred(napi_env env, return GET_RETURN_STATUS(env); } -enum UnwrapAction { - KeepWrap, - RemoveWrap -}; +enum UnwrapAction { KeepWrap, RemoveWrap }; inline static napi_status Unwrap(napi_env env, napi_value js_object, @@ -210,7 +208,7 @@ inline static napi_status Unwrap(napi_env env, v8::Local obj = value.As(); auto val = obj->GetPrivate(context, NAPI_PRIVATE_KEY(context, wrapper)) - .ToLocalChecked(); + .ToLocalChecked(); RETURN_STATUS_IF_FALSE(env, val->IsExternal(), napi_invalid_arg); Reference* reference = static_cast(val.As()->Value()); @@ -221,7 +219,7 @@ inline static napi_status Unwrap(napi_env env, if (action == RemoveWrap) { CHECK(obj->DeletePrivate(context, NAPI_PRIVATE_KEY(context, wrapper)) - .FromJust()); + .FromJust()); Reference::Delete(reference); } @@ -240,8 +238,9 @@ 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, void* data) { + static inline v8::Local New(napi_env env, + napi_callback cb, + void* data) { CallbackBundle* bundle = new CallbackBundle(); bundle->cb = cb; bundle->cb_data = data; @@ -251,9 +250,10 @@ class CallbackBundle { Reference::New(env, cbdata, 0, true, Delete, bundle, nullptr); return cbdata; } - napi_env env; // Necessary to invoke C++ NAPI callback - void* cb_data; // The user provided callback data - napi_callback cb; + napi_env env; // Necessary to invoke C++ NAPI callback + void* cb_data; // The user provided callback data + napi_callback cb; + private: static void Delete(napi_env env, void* data, void* hint) { CallbackBundle* bundle = static_cast(data); @@ -288,9 +288,8 @@ class CallbackWrapperBase : public CallbackWrapper { public: inline CallbackWrapperBase(const v8::FunctionCallbackInfo& cbinfo, const size_t args_length) - : CallbackWrapper(JsValueFromV8LocalValue(cbinfo.This()), - args_length, - nullptr), + : CallbackWrapper( + JsValueFromV8LocalValue(cbinfo.This()), args_length, nullptr), _cbinfo(cbinfo) { _bundle = reinterpret_cast( cbinfo.Data().As()->Value()); @@ -308,12 +307,11 @@ class CallbackWrapperBase : public CallbackWrapper { napi_value result = nullptr; bool exceptionOccurred = false; - env->CallIntoModule([&](napi_env env) { - result = cb(env, cbinfo_wrapper); - }, [&](napi_env env, v8::Local value) { - exceptionOccurred = true; - env->isolate->ThrowException(value); - }); + env->CallIntoModule([&](napi_env env) { result = cb(env, cbinfo_wrapper); }, + [&](napi_env env, v8::Local value) { + exceptionOccurred = true; + env->isolate->ThrowException(value); + }); if (!exceptionOccurred && (result != nullptr)) { this->SetReturnValue(result); @@ -324,8 +322,7 @@ class CallbackWrapperBase : public CallbackWrapper { CallbackBundle* _bundle; }; -class FunctionCallbackWrapper - : public CallbackWrapperBase { +class FunctionCallbackWrapper : public CallbackWrapperBase { public: static void Invoke(const v8::FunctionCallbackInfo& info) { FunctionCallbackWrapper cbwrapper(info); @@ -347,11 +344,12 @@ class FunctionCallbackWrapper return napi_clear_last_error(env); } - static inline napi_status NewTemplate(napi_env env, - napi_callback cb, - void* cb_data, - v8::Local* result, - v8::Local sig = v8::Local()) { + static inline napi_status NewTemplate( + napi_env env, + napi_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); @@ -396,10 +394,7 @@ class FunctionCallbackWrapper } }; -enum WrapType { - retrievable, - anonymous -}; +enum WrapType { retrievable, anonymous }; template inline napi_status Wrap(napi_env env, @@ -419,9 +414,10 @@ inline napi_status Wrap(napi_env env, if (wrap_type == retrievable) { // If we've already wrapped this object, we error out. - RETURN_STATUS_IF_FALSE(env, + RETURN_STATUS_IF_FALSE( + env, !obj->HasPrivate(context, NAPI_PRIVATE_KEY(context, wrapper)) - .FromJust(), + .FromJust(), napi_invalid_arg); } else if (wrap_type == anonymous) { // If no finalize callback is provided, we error out. @@ -440,13 +436,21 @@ inline napi_status Wrap(napi_env env, *result = reinterpret_cast(reference); } else { // Create a self-deleting reference. - reference = v8impl::Reference::New(env, obj, 0, true, finalize_cb, - native_object, finalize_cb == nullptr ? nullptr : finalize_hint); + reference = v8impl::Reference::New( + env, + obj, + 0, + true, + finalize_cb, + native_object, + finalize_cb == nullptr ? nullptr : finalize_hint); } if (wrap_type == retrievable) { - CHECK(obj->SetPrivate(context, NAPI_PRIVATE_KEY(context, wrapper), - v8::External::New(env->isolate, reference)).FromJust()); + CHECK(obj->SetPrivate(context, + NAPI_PRIVATE_KEY(context, wrapper), + v8::External::New(env->isolate, reference)) + .FromJust()); } return GET_RETURN_STATUS(env); @@ -721,29 +725,29 @@ void Reference::SecondPassCallback( } // end of namespace v8impl // Warning: Keep in-sync with napi_status enum -static -const char* error_messages[] = {nullptr, - "Invalid argument", - "An object was expected", - "A string was expected", - "A string or symbol was expected", - "A function was expected", - "A number was expected", - "A boolean was expected", - "An array was expected", - "Unknown failure", - "An exception is pending", - "The async work item was cancelled", - "napi_escape_handle already called on scope", - "Invalid handle scope usage", - "Invalid callback scope usage", - "Thread-safe function queue is full", - "Thread-safe function handle is closing", - "A bigint was expected", - "A date was expected", - "An arraybuffer was expected", - "A detachable arraybuffer was expected", - "Main thread would deadlock", +static const char* error_messages[] = { + nullptr, + "Invalid argument", + "An object was expected", + "A string was expected", + "A string or symbol was expected", + "A function was expected", + "A number was expected", + "A boolean was expected", + "An array was expected", + "Unknown failure", + "An exception is pending", + "The async work item was cancelled", + "napi_escape_handle already called on scope", + "Invalid handle scope usage", + "Invalid callback scope usage", + "Thread-safe function queue is full", + "Thread-safe function handle is closing", + "A bigint was expected", + "A date was expected", + "An arraybuffer was expected", + "A detachable arraybuffer was expected", + "Main thread would deadlock", }; napi_status napi_get_last_error_info(napi_env env, @@ -757,17 +761,15 @@ napi_status napi_get_last_error_info(napi_env env, // change each time a message was added. const int last_status = napi_would_deadlock; - static_assert( - NAPI_ARRAYSIZE(error_messages) == last_status + 1, - "Count of error messages must match count of error values"); + 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); // 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.error_message = error_messages[env->last_error.error_code]; if (env->last_error.error_code == napi_ok) { - napi_clear_last_error(env); + napi_clear_last_error(env); } *result = &(env->last_error); return napi_ok; @@ -860,12 +862,11 @@ napi_status napi_define_class(napi_env env, env, p->setter, p->data, &setter_tpl)); } - tpl->PrototypeTemplate()->SetAccessorProperty( - property_name, - getter_tpl, - setter_tpl, - attributes, - v8::AccessControl::DEFAULT); + tpl->PrototypeTemplate()->SetAccessorProperty(property_name, + getter_tpl, + setter_tpl, + attributes, + v8::AccessControl::DEFAULT); } else if (p->method != nullptr) { v8::Local t; STATUS_CALL(v8impl::FunctionCallbackWrapper::NewTemplate( @@ -893,10 +894,8 @@ napi_status napi_define_class(napi_env env, } } - STATUS_CALL(napi_define_properties(env, - *result, - static_descriptors.size(), - static_descriptors.data())); + STATUS_CALL(napi_define_properties( + env, *result, static_descriptors.size(), static_descriptors.data())); } return GET_RETURN_STATUS(env); @@ -909,8 +908,7 @@ napi_status napi_get_property_names(napi_env env, env, object, napi_key_include_prototypes, - static_cast(napi_key_enumerable | - napi_key_skip_symbols), + static_cast(napi_key_enumerable | napi_key_skip_symbols), napi_key_numbers_to_strings, result); } @@ -930,29 +928,24 @@ napi_status napi_get_all_property_names(napi_env env, v8::PropertyFilter filter = v8::PropertyFilter::ALL_PROPERTIES; if (key_filter & napi_key_writable) { - filter = - static_cast(filter | - v8::PropertyFilter::ONLY_WRITABLE); + filter = static_cast(filter | + v8::PropertyFilter::ONLY_WRITABLE); } if (key_filter & napi_key_enumerable) { - filter = - static_cast(filter | - v8::PropertyFilter::ONLY_ENUMERABLE); + filter = static_cast( + filter | v8::PropertyFilter::ONLY_ENUMERABLE); } if (key_filter & napi_key_configurable) { - filter = - static_cast(filter | - v8::PropertyFilter::ONLY_WRITABLE); + filter = static_cast(filter | + v8::PropertyFilter::ONLY_WRITABLE); } if (key_filter & napi_key_skip_strings) { - filter = - static_cast(filter | - v8::PropertyFilter::SKIP_STRINGS); + filter = static_cast(filter | + v8::PropertyFilter::SKIP_STRINGS); } if (key_filter & napi_key_skip_symbols) { - filter = - static_cast(filter | - v8::PropertyFilter::SKIP_SYMBOLS); + filter = static_cast(filter | + v8::PropertyFilter::SKIP_SYMBOLS); } v8::KeyCollectionMode collection_mode; v8::KeyConversionMode conversion_mode; @@ -1076,8 +1069,7 @@ napi_status napi_delete_property(napi_env env, v8::Maybe delete_maybe = obj->Delete(context, k); CHECK_MAYBE_NOTHING(env, delete_maybe, napi_generic_failure); - if (result != nullptr) - *result = delete_maybe.FromMaybe(false); + if (result != nullptr) *result = delete_maybe.FromMaybe(false); return GET_RETURN_STATUS(env); } @@ -1247,8 +1239,7 @@ napi_status napi_delete_element(napi_env env, v8::Maybe delete_maybe = obj->Delete(context, index); CHECK_MAYBE_NOTHING(env, delete_maybe, napi_generic_failure); - if (result != nullptr) - *result = delete_maybe.FromMaybe(false); + if (result != nullptr) *result = delete_maybe.FromMaybe(false); return GET_RETURN_STATUS(env); } @@ -1290,9 +1281,8 @@ napi_status napi_define_properties(napi_env env, descriptor.set_enumerable((p->attributes & napi_enumerable) != 0); descriptor.set_configurable((p->attributes & napi_configurable) != 0); - auto define_maybe = obj->DefineProperty(context, - property_name, - descriptor); + auto define_maybe = + obj->DefineProperty(context, property_name, descriptor); if (!define_maybe.FromMaybe(false)) { return napi_set_last_error(env, napi_invalid_arg); @@ -1306,9 +1296,8 @@ napi_status napi_define_properties(napi_env env, descriptor.set_enumerable((p->attributes & napi_enumerable) != 0); descriptor.set_configurable((p->attributes & napi_configurable) != 0); - auto define_maybe = obj->DefineProperty(context, - property_name, - descriptor); + auto define_maybe = + obj->DefineProperty(context, property_name, descriptor); if (!define_maybe.FromMaybe(false)) { return napi_set_last_error(env, napi_generic_failure); @@ -1333,8 +1322,7 @@ napi_status napi_define_properties(napi_env env, return GET_RETURN_STATUS(env); } -napi_status napi_object_freeze(napi_env env, - napi_value object) { +napi_status napi_object_freeze(napi_env env, napi_value object) { NAPI_PREAMBLE(env); v8::Local context = env->context(); @@ -1343,16 +1331,15 @@ napi_status napi_object_freeze(napi_env env, CHECK_TO_OBJECT(env, context, obj, object); v8::Maybe set_frozen = - obj->SetIntegrityLevel(context, v8::IntegrityLevel::kFrozen); + obj->SetIntegrityLevel(context, v8::IntegrityLevel::kFrozen); - RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(env, - set_frozen.FromMaybe(false), napi_generic_failure); + RETURN_STATUS_IF_FALSE_WITH_PREAMBLE( + env, set_frozen.FromMaybe(false), napi_generic_failure); return GET_RETURN_STATUS(env); } -napi_status napi_object_seal(napi_env env, - napi_value object) { +napi_status napi_object_seal(napi_env env, napi_value object) { NAPI_PREAMBLE(env); v8::Local context = env->context(); @@ -1361,10 +1348,10 @@ napi_status napi_object_seal(napi_env env, CHECK_TO_OBJECT(env, context, obj, object); v8::Maybe set_sealed = - obj->SetIntegrityLevel(context, v8::IntegrityLevel::kSealed); + obj->SetIntegrityLevel(context, v8::IntegrityLevel::kSealed); - RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(env, - set_sealed.FromMaybe(false), napi_generic_failure); + RETURN_STATUS_IF_FALSE_WITH_PREAMBLE( + env, set_sealed.FromMaybe(false), napi_generic_failure); return GET_RETURN_STATUS(env); } @@ -1432,8 +1419,7 @@ napi_status napi_create_object(napi_env env, napi_value* result) { CHECK_ENV(env); CHECK_ARG(env, result); - *result = v8impl::JsValueFromV8LocalValue( - v8::Object::New(env->isolate)); + *result = v8impl::JsValueFromV8LocalValue(v8::Object::New(env->isolate)); return napi_clear_last_error(env); } @@ -1442,8 +1428,7 @@ napi_status napi_create_array(napi_env env, napi_value* result) { CHECK_ENV(env); CHECK_ARG(env, result); - *result = v8impl::JsValueFromV8LocalValue( - v8::Array::New(env->isolate)); + *result = v8impl::JsValueFromV8LocalValue(v8::Array::New(env->isolate)); return napi_clear_last_error(env); } @@ -1454,8 +1439,8 @@ napi_status napi_create_array_with_length(napi_env env, CHECK_ENV(env); CHECK_ARG(env, result); - *result = v8impl::JsValueFromV8LocalValue( - v8::Array::New(env->isolate, length)); + *result = + v8impl::JsValueFromV8LocalValue(v8::Array::New(env->isolate, length)); return napi_clear_last_error(env); } @@ -1465,12 +1450,10 @@ napi_status napi_create_string_latin1(napi_env env, size_t length, napi_value* result) { CHECK_ENV(env); - if (length > 0) - CHECK_ARG(env, str); + 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); + RETURN_STATUS_IF_FALSE( + env, (length == NAPI_AUTO_LENGTH) || length <= INT_MAX, napi_invalid_arg); auto isolate = env->isolate; auto str_maybe = @@ -1489,19 +1472,14 @@ napi_status napi_create_string_utf8(napi_env env, size_t length, napi_value* result) { CHECK_ENV(env); - if (length > 0) - CHECK_ARG(env, str); + 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); + RETURN_STATUS_IF_FALSE( + env, (length == NAPI_AUTO_LENGTH) || length <= INT_MAX, napi_invalid_arg); auto isolate = env->isolate; - auto str_maybe = - v8::String::NewFromUtf8(isolate, - str, - v8::NewStringType::kNormal, - static_cast(length)); + auto str_maybe = v8::String::NewFromUtf8( + isolate, str, v8::NewStringType::kNormal, static_cast(length)); CHECK_MAYBE_EMPTY(env, str_maybe, napi_generic_failure); *result = v8impl::JsValueFromV8LocalValue(str_maybe.ToLocalChecked()); return napi_clear_last_error(env); @@ -1512,12 +1490,10 @@ napi_status napi_create_string_utf16(napi_env env, size_t length, napi_value* result) { CHECK_ENV(env); - if (length > 0) - CHECK_ARG(env, str); + 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); + RETURN_STATUS_IF_FALSE( + env, (length == NAPI_AUTO_LENGTH) || length <= INT_MAX, napi_invalid_arg); auto isolate = env->isolate; auto str_maybe = @@ -1531,26 +1507,22 @@ napi_status napi_create_string_utf16(napi_env env, return napi_clear_last_error(env); } -napi_status napi_create_double(napi_env env, - double value, - napi_value* result) { +napi_status napi_create_double(napi_env env, double value, napi_value* result) { CHECK_ENV(env); CHECK_ARG(env, result); - *result = v8impl::JsValueFromV8LocalValue( - v8::Number::New(env->isolate, value)); + *result = + v8impl::JsValueFromV8LocalValue(v8::Number::New(env->isolate, value)); return napi_clear_last_error(env); } -napi_status napi_create_int32(napi_env env, - int32_t value, - napi_value* result) { +napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result) { CHECK_ENV(env); CHECK_ARG(env, result); - *result = v8impl::JsValueFromV8LocalValue( - v8::Integer::New(env->isolate, value)); + *result = + v8impl::JsValueFromV8LocalValue(v8::Integer::New(env->isolate, value)); return napi_clear_last_error(env); } @@ -1567,9 +1539,7 @@ napi_status napi_create_uint32(napi_env env, return napi_clear_last_error(env); } -napi_status napi_create_int64(napi_env env, - int64_t value, - napi_value* result) { +napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result) { CHECK_ENV(env); CHECK_ARG(env, result); @@ -1585,8 +1555,8 @@ napi_status napi_create_bigint_int64(napi_env env, CHECK_ENV(env); CHECK_ARG(env, result); - *result = v8impl::JsValueFromV8LocalValue( - v8::BigInt::New(env->isolate, value)); + *result = + v8impl::JsValueFromV8LocalValue(v8::BigInt::New(env->isolate, value)); return napi_clear_last_error(env); } @@ -1614,11 +1584,10 @@ napi_status napi_create_bigint_words(napi_env env, v8::Local context = env->context(); - RETURN_STATUS_IF_FALSE( - env, word_count <= INT_MAX, napi_invalid_arg); + RETURN_STATUS_IF_FALSE(env, word_count <= INT_MAX, napi_invalid_arg); - v8::MaybeLocal b = v8::BigInt::NewFromWords( - context, sign_bit, word_count, words); + v8::MaybeLocal b = + v8::BigInt::NewFromWords(context, sign_bit, word_count, words); CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, b, napi_generic_failure); @@ -1656,7 +1625,7 @@ napi_status napi_create_symbol(napi_env env, RETURN_STATUS_IF_FALSE(env, desc->IsString(), napi_string_expected); *result = v8impl::JsValueFromV8LocalValue( - v8::Symbol::New(isolate, desc.As())); + v8::Symbol::New(isolate, desc.As())); } return napi_clear_last_error(env); @@ -1670,15 +1639,13 @@ napi_status node_api_symbol_for(napi_env env, CHECK_ARG(env, result); napi_value js_description_string; - STATUS_CALL(napi_create_string_utf8(env, - utf8description, - length, - &js_description_string)); + STATUS_CALL(napi_create_string_utf8( + env, utf8description, length, &js_description_string)); v8::Local description_string = - v8impl::V8LocalValueFromJsValue(js_description_string).As(); + v8impl::V8LocalValueFromJsValue(js_description_string).As(); *result = v8impl::JsValueFromV8LocalValue( - v8::Symbol::For(env->isolate, description_string)); + v8::Symbol::For(env->isolate, description_string)); return napi_clear_last_error(env); } @@ -1703,9 +1670,8 @@ static inline napi_status set_error_code(napi_env env, CHECK_NEW_FROM_UTF8(env, code_key, "code"); v8::Maybe set_maybe = err_object->Set(context, code_key, code_value); - RETURN_STATUS_IF_FALSE(env, - set_maybe.FromMaybe(false), - napi_generic_failure); + RETURN_STATUS_IF_FALSE( + env, set_maybe.FromMaybe(false), napi_generic_failure); } return napi_ok; } @@ -1837,8 +1803,7 @@ napi_status napi_get_undefined(napi_env env, napi_value* result) { CHECK_ENV(env); CHECK_ARG(env, result); - *result = v8impl::JsValueFromV8LocalValue( - v8::Undefined(env->isolate)); + *result = v8impl::JsValueFromV8LocalValue(v8::Undefined(env->isolate)); return napi_clear_last_error(env); } @@ -1847,8 +1812,7 @@ napi_status napi_get_null(napi_env env, napi_value* result) { CHECK_ENV(env); CHECK_ARG(env, result); - *result = v8impl::JsValueFromV8LocalValue( - v8::Null(env->isolate)); + *result = v8impl::JsValueFromV8LocalValue(v8::Null(env->isolate)); return napi_clear_last_error(env); } @@ -1918,8 +1882,11 @@ napi_status napi_call_function(napi_env env, v8::Local v8func; CHECK_TO_FUNCTION(env, v8func, func); - auto maybe = v8func->Call(context, v8recv, argc, - reinterpret_cast*>(const_cast(argv))); + auto maybe = v8func->Call( + context, + v8recv, + argc, + reinterpret_cast*>(const_cast(argv))); if (try_catch.HasCaught()) { return napi_set_last_error(env, napi_pending_exception); @@ -1953,9 +1920,7 @@ napi_status napi_throw(napi_env env, napi_value error) { return napi_clear_last_error(env); } -napi_status napi_throw_error(napi_env env, - const char* code, - const char* msg) { +napi_status napi_throw_error(napi_env env, const char* code, const char* msg) { NAPI_PREAMBLE(env); v8::Isolate* isolate = env->isolate; @@ -2226,11 +2191,8 @@ napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result) { // 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_get_value_string_latin1(napi_env env, - napi_value value, - char* buf, - size_t bufsize, - size_t* result) { +napi_status napi_get_value_string_latin1( + napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result) { CHECK_ENV(env); CHECK_ARG(env, value); @@ -2267,11 +2229,8 @@ napi_status napi_get_value_string_latin1(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_get_value_string_utf8(napi_env env, - napi_value value, - char* buf, - size_t bufsize, - size_t* result) { +napi_status napi_get_value_string_utf8( + napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result) { CHECK_ENV(env); CHECK_ARG(env, value); @@ -2350,26 +2309,25 @@ napi_status napi_coerce_to_bool(napi_env env, v8::Isolate* isolate = env->isolate; v8::Local b = - v8impl::V8LocalValueFromJsValue(value)->ToBoolean(isolate); + v8impl::V8LocalValueFromJsValue(value)->ToBoolean(isolate); *result = v8impl::JsValueFromV8LocalValue(b); return GET_RETURN_STATUS(env); } -#define GEN_COERCE_FUNCTION(UpperCaseName, MixedCaseName, LowerCaseName) \ - napi_status napi_coerce_to_##LowerCaseName(napi_env env, \ - napi_value value, \ - napi_value* result) { \ - NAPI_PREAMBLE(env); \ - CHECK_ARG(env, value); \ - CHECK_ARG(env, result); \ - \ - v8::Local context = env->context(); \ - v8::Local str; \ - \ - CHECK_TO_##UpperCaseName(env, context, str, value); \ - \ - *result = v8impl::JsValueFromV8LocalValue(str); \ - return GET_RETURN_STATUS(env); \ +#define GEN_COERCE_FUNCTION(UpperCaseName, MixedCaseName, LowerCaseName) \ + napi_status napi_coerce_to_##LowerCaseName( \ + napi_env env, napi_value value, napi_value* result) { \ + NAPI_PREAMBLE(env); \ + CHECK_ARG(env, value); \ + CHECK_ARG(env, result); \ + \ + v8::Local context = env->context(); \ + v8::Local str; \ + \ + CHECK_TO_##UpperCaseName(env, context, str, value); \ + \ + *result = v8impl::JsValueFromV8LocalValue(str); \ + return GET_RETURN_STATUS(env); \ } GEN_COERCE_FUNCTION(NUMBER, Number, number) @@ -2384,12 +2342,8 @@ napi_status napi_wrap(napi_env env, napi_finalize finalize_cb, void* finalize_hint, napi_ref* result) { - return v8impl::Wrap(env, - js_object, - native_object, - finalize_cb, - finalize_hint, - result); + return v8impl::Wrap( + env, js_object, native_object, finalize_cb, finalize_hint, result); } napi_status napi_unwrap(napi_env env, napi_value obj, void** result) { @@ -2414,13 +2368,8 @@ napi_status napi_create_external(napi_env env, // The Reference object will delete itself after invoking the finalizer // callback. - v8impl::Reference::New(env, - external_value, - 0, - true, - finalize_cb, - data, - finalize_hint); + v8impl::Reference::New( + env, external_value, 0, true, finalize_cb, data, finalize_hint); *result = v8impl::JsValueFromV8LocalValue(external_value); @@ -2439,21 +2388,17 @@ NAPI_EXTERN napi_status napi_type_tag_object(napi_env env, auto key = NAPI_PRIVATE_KEY(context, type_tag); auto maybe_has = obj->HasPrivate(context, key); CHECK_MAYBE_NOTHING_WITH_PREAMBLE(env, maybe_has, napi_generic_failure); - RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(env, - !maybe_has.FromJust(), - napi_invalid_arg); - - auto tag = v8::BigInt::NewFromWords(context, - 0, - 2, - reinterpret_cast(type_tag)); + RETURN_STATUS_IF_FALSE_WITH_PREAMBLE( + env, !maybe_has.FromJust(), napi_invalid_arg); + + auto tag = v8::BigInt::NewFromWords( + context, 0, 2, reinterpret_cast(type_tag)); CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, tag, napi_generic_failure); auto maybe_set = obj->SetPrivate(context, key, tag.ToLocalChecked()); CHECK_MAYBE_NOTHING_WITH_PREAMBLE(env, maybe_set, napi_generic_failure); - RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(env, - maybe_set.FromJust(), - napi_generic_failure); + RETURN_STATUS_IF_FALSE_WITH_PREAMBLE( + env, maybe_set.FromJust(), napi_generic_failure); return GET_RETURN_STATUS(env); } @@ -2470,8 +2415,8 @@ napi_check_object_type_tag(napi_env env, CHECK_ARG_WITH_PREAMBLE(env, type_tag); CHECK_ARG_WITH_PREAMBLE(env, result); - auto maybe_value = obj->GetPrivate(context, - NAPI_PRIVATE_KEY(context, type_tag)); + auto maybe_value = + obj->GetPrivate(context, NAPI_PRIVATE_KEY(context, type_tag)); CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, maybe_value, napi_generic_failure); v8::Local val = maybe_value.ToLocalChecked(); @@ -2483,9 +2428,8 @@ napi_check_object_type_tag(napi_env env, int sign; int size = 2; napi_type_tag tag; - val.As()->ToWordsArray(&sign, - &size, - reinterpret_cast(&tag)); + val.As()->ToWordsArray( + &sign, &size, reinterpret_cast(&tag)); if (size == 2 && sign == 0) *result = (tag.lower == type_tag->lower && tag.upper == type_tag->upper); } @@ -2637,8 +2581,7 @@ napi_status napi_close_handle_scope(napi_env env, napi_handle_scope scope) { } napi_status napi_open_escapable_handle_scope( - napi_env env, - napi_escapable_handle_scope* result) { + napi_env env, napi_escapable_handle_scope* result) { // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); @@ -2651,8 +2594,7 @@ napi_status napi_open_escapable_handle_scope( } napi_status napi_close_escapable_handle_scope( - napi_env env, - napi_escapable_handle_scope scope) { + napi_env env, napi_escapable_handle_scope scope) { // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. CHECK_ENV(env); @@ -2704,8 +2646,10 @@ napi_status napi_new_instance(napi_env env, v8::Local ctor; CHECK_TO_FUNCTION(env, ctor, constructor); - auto maybe = ctor->NewInstance(context, argc, - reinterpret_cast*>(const_cast(argv))); + auto maybe = ctor->NewInstance( + context, + argc, + reinterpret_cast*>(const_cast(argv))); CHECK_MAYBE_EMPTY(env, maybe, napi_pending_exception); @@ -2729,9 +2673,8 @@ napi_status napi_instanceof(napi_env env, CHECK_TO_OBJECT(env, context, ctor, constructor); if (!ctor->IsFunction()) { - napi_throw_type_error(env, - "ERR_NAPI_CONS_FUNCTION", - "Constructor must be a function"); + napi_throw_type_error( + env, "ERR_NAPI_CONS_FUNCTION", "Constructor must be a function"); return napi_set_last_error(env, napi_function_expected); } @@ -2767,7 +2710,7 @@ napi_status napi_get_and_clear_last_exception(napi_env env, return napi_get_undefined(env, result); } else { *result = v8impl::JsValueFromV8LocalValue( - v8::Local::New(env->isolate, env->last_exception)); + v8::Local::New(env->isolate, env->last_exception)); env->last_exception.Reset(); } @@ -2817,20 +2760,9 @@ napi_status napi_create_external_arraybuffer(napi_env env, // `Buffer` variant for easier implementation. napi_value buffer; STATUS_CALL(napi_create_external_buffer( - env, - byte_length, - external_data, - finalize_cb, - finalize_hint, - &buffer)); + env, byte_length, external_data, finalize_cb, finalize_hint, &buffer)); return napi_get_typedarray_info( - env, - buffer, - nullptr, - nullptr, - nullptr, - result, - nullptr); + env, buffer, nullptr, nullptr, nullptr, result, nullptr); } napi_status napi_get_arraybuffer_info(napi_env env, @@ -3019,15 +2951,14 @@ napi_status napi_create_dataview(napi_env env, 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 " - "equal to the size in bytes of the array passed in"); + napi_throw_range_error(env, + "ERR_NAPI_INVALID_DATAVIEW_ARGS", + "byte_offset + byte_length 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); } - v8::Local DataView = v8::DataView::New(buffer, byte_offset, - byte_length); + v8::Local DataView = + v8::DataView::New(buffer, byte_offset, byte_length); *result = v8impl::JsValueFromV8LocalValue(DataView); return GET_RETURN_STATUS(env); @@ -3123,9 +3054,7 @@ napi_status napi_reject_deferred(napi_env env, return v8impl::ConcludeDeferred(env, deferred, resolution, false); } -napi_status napi_is_promise(napi_env env, - napi_value value, - bool* is_promise) { +napi_status napi_is_promise(napi_env env, napi_value value, bool* is_promise) { CHECK_ENV(env); CHECK_ARG(env, value); CHECK_ARG(env, is_promise); @@ -3135,9 +3064,7 @@ napi_status napi_is_promise(napi_env env, return napi_clear_last_error(env); } -napi_status napi_create_date(napi_env env, - double time, - napi_value* result) { +napi_status napi_create_date(napi_env env, double time, napi_value* result) { NAPI_PREAMBLE(env); CHECK_ARG(env, result); @@ -3149,9 +3076,7 @@ napi_status napi_create_date(napi_env env, return GET_RETURN_STATUS(env); } -napi_status napi_is_date(napi_env env, - napi_value value, - bool* is_date) { +napi_status napi_is_date(napi_env env, napi_value value, bool* is_date) { CHECK_ENV(env); CHECK_ARG(env, value); CHECK_ARG(env, is_date); @@ -3195,8 +3120,7 @@ napi_status napi_run_script(napi_env env, auto maybe_script = v8::Script::Compile(context, v8_script.As()); CHECK_MAYBE_EMPTY(env, maybe_script, napi_generic_failure); - auto script_result = - maybe_script.ToLocalChecked()->Run(context); + auto script_result = maybe_script.ToLocalChecked()->Run(context); CHECK_MAYBE_EMPTY(env, script_result, napi_generic_failure); *result = v8impl::JsValueFromV8LocalValue(script_result.ToLocalChecked()); @@ -3209,12 +3133,8 @@ napi_status napi_add_finalizer(napi_env env, napi_finalize finalize_cb, void* finalize_hint, napi_ref* result) { - return v8impl::Wrap(env, - js_object, - native_object, - finalize_cb, - finalize_hint, - result); + return v8impl::Wrap( + env, js_object, native_object, finalize_cb, finalize_hint, result); } napi_status napi_adjust_external_memory(napi_env env, @@ -3223,8 +3143,8 @@ napi_status napi_adjust_external_memory(napi_env env, CHECK_ENV(env); CHECK_ARG(env, adjusted_value); - *adjusted_value = env->isolate->AdjustAmountOfExternalAllocatedMemory( - change_in_bytes); + *adjusted_value = + env->isolate->AdjustAmountOfExternalAllocatedMemory(change_in_bytes); return napi_clear_last_error(env); } @@ -3242,18 +3162,13 @@ napi_status napi_set_instance_data(napi_env env, v8impl::RefBase::Delete(old_data); } - env->instance_data = v8impl::RefBase::New(env, - 0, - true, - finalize_cb, - data, - finalize_hint); + env->instance_data = + v8impl::RefBase::New(env, 0, true, finalize_cb, data, finalize_hint); return napi_clear_last_error(env); } -napi_status napi_get_instance_data(napi_env env, - void** data) { +napi_status napi_get_instance_data(napi_env env, void** data) { CHECK_ENV(env); CHECK_ARG(env, data); diff --git a/src/js_native_api_v8.h b/src/js_native_api_v8.h index bdf68505a7d7a3..ffe351f4f6c65e 100644 --- a/src/js_native_api_v8.h +++ b/src/js_native_api_v8.h @@ -53,8 +53,7 @@ class RefTracker { struct napi_env__ { explicit napi_env__(v8::Local context) - : isolate(context->GetIsolate()), - context_persistent(isolate, context) { + : isolate(context->GetIsolate()), context_persistent(isolate, context) { CHECK_EQ(isolate, context->GetIsolate()); napi_clear_last_error(this); } @@ -75,7 +74,9 @@ struct napi_env__ { } inline void Ref() { refs++; } - inline void Unref() { if ( --refs == 0) delete this; } + inline void Unref() { + if (--refs == 0) delete this; + } virtual bool can_call_into_js() const { return true; } virtual v8::Maybe mark_arraybuffer_as_untransferable( @@ -83,8 +84,7 @@ struct napi_env__ { return v8::Just(true); } - static inline void - HandleThrow(napi_env env, v8::Local value) { + static inline void HandleThrow(napi_env env, v8::Local value) { env->isolate->ThrowException(value); } @@ -104,9 +104,7 @@ struct napi_env__ { virtual void CallFinalizer(napi_finalize cb, void* data, void* hint) { v8::HandleScope handle_scope(isolate); - CallIntoModule([&](napi_env env) { - cb(env, data, hint); - }); + CallIntoModule([&](napi_env env) { cb(env, data, hint); }); } v8impl::Persistent last_exception; @@ -127,11 +125,9 @@ struct napi_env__ { // is exception safe versus calling Ref/Unref directly class EnvRefHolder { public: - explicit EnvRefHolder(napi_env env) : _env(env) { - _env->Ref(); - } + explicit EnvRefHolder(napi_env env) : _env(env) { _env->Ref(); } - explicit EnvRefHolder(const EnvRefHolder& other): _env(other.env()) { + explicit EnvRefHolder(const EnvRefHolder& other) : _env(other.env()) { _env->Ref(); } @@ -146,9 +142,7 @@ class EnvRefHolder { } } - napi_env env(void) const { - return _env; - } + napi_env env(void) const { return _env; } private: napi_env _env; @@ -164,21 +158,21 @@ static inline napi_status napi_clear_last_error(napi_env env) { return napi_ok; } -static inline -napi_status napi_set_last_error(napi_env env, napi_status error_code, - uint32_t engine_error_code = 0, - void* engine_reserved = nullptr) { +static 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; } -#define RETURN_STATUS_IF_FALSE(env, condition, status) \ - do { \ - if (!(condition)) { \ - return napi_set_last_error((env), (status)); \ - } \ +#define RETURN_STATUS_IF_FALSE(env, condition, status) \ + do { \ + if (!(condition)) { \ + return napi_set_last_error((env), (status)); \ + } \ } while (0) #define RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(env, condition, status) \ @@ -189,84 +183,81 @@ napi_status napi_set_last_error(napi_env env, napi_status error_code, } \ } while (0) -#define CHECK_ENV(env) \ - do { \ - if ((env) == nullptr) { \ - return napi_invalid_arg; \ - } \ +#define CHECK_ENV(env) \ + do { \ + if ((env) == nullptr) { \ + return napi_invalid_arg; \ + } \ } while (0) -#define CHECK_ARG(env, arg) \ +#define CHECK_ARG(env, arg) \ RETURN_STATUS_IF_FALSE((env), ((arg) != nullptr), napi_invalid_arg) -#define CHECK_ARG_WITH_PREAMBLE(env, arg) \ - RETURN_STATUS_IF_FALSE_WITH_PREAMBLE((env), \ - ((arg) != nullptr), \ - napi_invalid_arg) +#define CHECK_ARG_WITH_PREAMBLE(env, arg) \ + RETURN_STATUS_IF_FALSE_WITH_PREAMBLE( \ + (env), ((arg) != nullptr), napi_invalid_arg) -#define CHECK_MAYBE_EMPTY(env, maybe, status) \ +#define CHECK_MAYBE_EMPTY(env, maybe, status) \ RETURN_STATUS_IF_FALSE((env), !((maybe).IsEmpty()), (status)) #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) \ - CHECK_ENV((env)); \ - RETURN_STATUS_IF_FALSE((env), \ - (env)->last_exception.IsEmpty() && (env)->can_call_into_js(), \ - napi_pending_exception); \ - napi_clear_last_error((env)); \ +#define NAPI_PREAMBLE(env) \ + CHECK_ENV((env)); \ + RETURN_STATUS_IF_FALSE( \ + (env), \ + (env)->last_exception.IsEmpty() && (env)->can_call_into_js(), \ + napi_pending_exception); \ + napi_clear_last_error((env)); \ v8impl::TryCatch try_catch((env)) -#define CHECK_TO_TYPE(env, type, context, result, src, status) \ - do { \ - CHECK_ARG((env), (src)); \ - auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \ - CHECK_MAYBE_EMPTY((env), maybe, (status)); \ - (result) = maybe.ToLocalChecked(); \ +#define CHECK_TO_TYPE(env, type, context, result, src, status) \ + do { \ + CHECK_ARG((env), (src)); \ + auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \ + CHECK_MAYBE_EMPTY((env), maybe, (status)); \ + (result) = maybe.ToLocalChecked(); \ } while (0) -#define CHECK_TO_TYPE_WITH_PREAMBLE(env, type, context, result, src, status) \ - do { \ - CHECK_ARG_WITH_PREAMBLE((env), (src)); \ - auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \ - CHECK_MAYBE_EMPTY_WITH_PREAMBLE((env), maybe, (status)); \ - (result) = maybe.ToLocalChecked(); \ +#define CHECK_TO_TYPE_WITH_PREAMBLE(env, type, context, result, src, status) \ + do { \ + CHECK_ARG_WITH_PREAMBLE((env), (src)); \ + auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \ + CHECK_MAYBE_EMPTY_WITH_PREAMBLE((env), maybe, (status)); \ + (result) = maybe.ToLocalChecked(); \ } while (0) -#define CHECK_TO_FUNCTION(env, result, src) \ - do { \ - CHECK_ARG((env), (src)); \ - v8::Local v8value = v8impl::V8LocalValueFromJsValue((src)); \ - RETURN_STATUS_IF_FALSE((env), v8value->IsFunction(), napi_invalid_arg); \ - (result) = v8value.As(); \ +#define CHECK_TO_FUNCTION(env, result, src) \ + do { \ + CHECK_ARG((env), (src)); \ + v8::Local v8value = v8impl::V8LocalValueFromJsValue((src)); \ + RETURN_STATUS_IF_FALSE((env), v8value->IsFunction(), napi_invalid_arg); \ + (result) = v8value.As(); \ } while (0) -#define CHECK_TO_OBJECT(env, context, result, src) \ +#define CHECK_TO_OBJECT(env, context, result, src) \ CHECK_TO_TYPE((env), Object, (context), (result), (src), napi_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) +#define CHECK_TO_OBJECT_WITH_PREAMBLE(env, context, result, src) \ + CHECK_TO_TYPE_WITH_PREAMBLE( \ + (env), Object, (context), (result), (src), napi_object_expected) -#define CHECK_TO_STRING(env, context, result, src) \ +#define CHECK_TO_STRING(env, context, result, src) \ CHECK_TO_TYPE((env), String, (context), (result), (src), napi_string_expected) -#define GET_RETURN_STATUS(env) \ - (!try_catch.HasCaught() ? napi_ok \ - : napi_set_last_error((env), napi_pending_exception)) +#define GET_RETURN_STATUS(env) \ + (!try_catch.HasCaught() \ + ? napi_ok \ + : napi_set_last_error((env), napi_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); \ - } \ +#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); \ + } \ } while (0) #define RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(env, condition, status) \ @@ -287,7 +278,7 @@ namespace v8impl { // 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"); + "Cannot convert between v8::Local and napi_value"); inline napi_value JsValueFromV8LocalValue(v8::Local local) { return reinterpret_cast(*local); @@ -305,10 +296,7 @@ class Finalizer { // Some Finalizers are run during shutdown when the napi_env is destroyed, // and some need to keep an explicit reference to the napi_env because they // are run independently. - enum EnvReferenceMode { - kNoEnvReference, - kKeepEnvReference - }; + enum EnvReferenceMode { kNoEnvReference, kKeepEnvReference }; protected: Finalizer(napi_env env, @@ -316,18 +304,16 @@ class Finalizer { void* finalize_data, void* finalize_hint, EnvReferenceMode refmode = kNoEnvReference) - : _env(env), - _finalize_callback(finalize_callback), - _finalize_data(finalize_data), - _finalize_hint(finalize_hint), - _has_env_reference(refmode == kKeepEnvReference) { - if (_has_env_reference) - _env->Ref(); + : _env(env), + _finalize_callback(finalize_callback), + _finalize_data(finalize_data), + _finalize_hint(finalize_hint), + _has_env_reference(refmode == kKeepEnvReference) { + if (_has_env_reference) _env->Ref(); } ~Finalizer() { - if (_has_env_reference) - _env->Unref(); + if (_has_env_reference) _env->Unref(); } public: @@ -340,9 +326,7 @@ class Finalizer { env, finalize_callback, finalize_data, finalize_hint, refmode); } - static void Delete(Finalizer* finalizer) { - delete finalizer; - } + static void Delete(Finalizer* finalizer) { delete finalizer; } protected: napi_env _env; @@ -355,8 +339,7 @@ class Finalizer { class TryCatch : public v8::TryCatch { public: - explicit TryCatch(napi_env env) - : v8::TryCatch(env->isolate), _env(env) {} + explicit TryCatch(napi_env env) : v8::TryCatch(env->isolate), _env(env) {} ~TryCatch() { if (HasCaught()) { @@ -444,10 +427,10 @@ class Reference : public RefBase { } // end of namespace v8impl -#define STATUS_CALL(call) \ - do { \ - napi_status status = (call); \ - if (status != napi_ok) return status; \ +#define STATUS_CALL(call) \ + do { \ + napi_status status = (call); \ + if (status != napi_ok) return status; \ } while (0) #endif // SRC_JS_NATIVE_API_V8_H_ diff --git a/src/js_native_api_v8_internals.h b/src/js_native_api_v8_internals.h index 8428390ef1eaf3..4f1b94d3d0c9d7 100644 --- a/src/js_native_api_v8_internals.h +++ b/src/js_native_api_v8_internals.h @@ -14,18 +14,18 @@ // included below, defines `NAPI_VERSION`. #include "node_version.h" + #include "env.h" -#include "node_internals.h" #include "gtest/gtest_prod.h" +#include "node_internals.h" -#define NAPI_ARRAYSIZE(array) \ - node::arraysize((array)) +#define NAPI_ARRAYSIZE(array) node::arraysize((array)) -#define NAPI_FIXED_ONE_BYTE_STRING(isolate, string) \ +#define NAPI_FIXED_ONE_BYTE_STRING(isolate, string) \ node::FIXED_ONE_BYTE_STRING((isolate), (string)) -#define NAPI_PRIVATE_KEY(context, suffix) \ - (node::Environment::GetCurrent((context))->napi_ ## suffix()) +#define NAPI_PRIVATE_KEY(context, suffix) \ + (node::Environment::GetCurrent((context))->napi_##suffix()) namespace v8impl { diff --git a/src/node_api.cc b/src/node_api.cc index 60fbe96b8ef272..aa4f8a6a2401e2 100644 --- a/src/node_api.cc +++ b/src/node_api.cc @@ -64,18 +64,16 @@ class BufferFinalizer : private Finalizer { static_cast(finalizer->_env)->node_env(); node_env->SetImmediate( [finalizer = std::move(finalizer)](node::Environment* env) { - if (finalizer->_finalize_callback == nullptr) return; + if (finalizer->_finalize_callback == nullptr) return; - v8::HandleScope handle_scope(finalizer->_env->isolate); - v8::Context::Scope context_scope(finalizer->_env->context()); + v8::HandleScope handle_scope(finalizer->_env->isolate); + v8::Context::Scope context_scope(finalizer->_env->context()); - finalizer->_env->CallIntoModule([&](napi_env env) { - finalizer->_finalize_callback( - env, - finalizer->_finalize_data, - finalizer->_finalize_hint); - }); - }); + finalizer->_env->CallIntoModule([&](napi_env env) { + finalizer->_finalize_callback( + env, finalizer->_finalize_data, finalizer->_finalize_hint); + }); + }); } struct Deleter { @@ -85,8 +83,8 @@ class BufferFinalizer : private Finalizer { }; }; -static inline napi_env -NewEnv(v8::Local context, const std::string& module_filename) { +static inline napi_env NewEnv(v8::Local context, + const std::string& module_filename) { node_napi_env result; result = new node_napi_env__(context, module_filename); @@ -98,18 +96,16 @@ NewEnv(v8::Local context, const std::string& module_filename) { // once all N-API addons using this napi_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; } -static inline void trigger_fatal_exception( - napi_env env, v8::Local local_err) { +static inline void trigger_fatal_exception(napi_env env, + v8::Local local_err) { v8::Local local_msg = - v8::Exception::CreateMessage(env->isolate, local_err); + v8::Exception::CreateMessage(env->isolate, local_err); node::errors::TriggerUncaughtException(env->isolate, local_err, local_msg); } @@ -124,20 +120,20 @@ class ThreadSafeFunction : public node::AsyncResource { node_napi_env env_, void* finalize_data_, napi_finalize finalize_cb_, - napi_threadsafe_function_call_js call_js_cb_): - AsyncResource(env_->isolate, - resource, - *v8::String::Utf8Value(env_->isolate, name)), - thread_count(thread_count_), - is_closing(false), - dispatch_state(kDispatchIdle), - context(context_), - max_queue_size(max_queue_size_), - env(env_), - finalize_data(finalize_data_), - finalize_cb(finalize_cb_), - call_js_cb(call_js_cb_ == nullptr ? CallJs : call_js_cb_), - handles_closing(false) { + napi_threadsafe_function_call_js call_js_cb_) + : AsyncResource(env_->isolate, + resource, + *v8::String::Utf8Value(env_->isolate, name)), + thread_count(thread_count_), + is_closing(false), + dispatch_state(kDispatchIdle), + context(context_), + max_queue_size(max_queue_size_), + env(env_), + finalize_data(finalize_data_), + finalize_cb(finalize_cb_), + call_js_cb(call_js_cb_ == nullptr ? CallJs : call_js_cb_), + handles_closing(false) { ref.Reset(env->isolate, func); node::AddEnvironmentCleanupHook(env->isolate, Cleanup, this); env->Ref(); @@ -153,9 +149,8 @@ class ThreadSafeFunction : public node::AsyncResource { napi_status Push(void* data, napi_threadsafe_function_call_mode mode) { node::Mutex::ScopedLock lock(this->mutex); - while (queue.size() >= max_queue_size && - max_queue_size > 0 && - !is_closing) { + while (queue.size() >= max_queue_size && max_queue_size > 0 && + !is_closing) { if (mode == napi_tsfn_nonblocking) { return napi_queue_full; } @@ -211,7 +206,7 @@ class ThreadSafeFunction : public node::AsyncResource { } void EmptyQueueAndDelete() { - for (; !queue.empty() ; queue.pop()) { + for (; !queue.empty(); queue.pop()) { call_js_cb(nullptr, nullptr, context, queue.front()); } delete this; @@ -262,9 +257,7 @@ class ThreadSafeFunction : public node::AsyncResource { return napi_ok; } - inline void* Context() { - return context; - } + inline void* Context() { return context; } protected: void Dispatch() { @@ -329,12 +322,11 @@ class ThreadSafeFunction : public node::AsyncResource { napi_value js_callback = nullptr; if (!ref.IsEmpty()) { v8::Local js_cb = - v8::Local::New(env->isolate, ref); + v8::Local::New(env->isolate, ref); js_callback = v8impl::JsValueFromV8LocalValue(js_cb); } - env->CallIntoModule([&](napi_env env) { - call_js_cb(env, js_callback, context, data); - }); + env->CallIntoModule( + [&](napi_env env) { call_js_cb(env, js_callback, context, data); }); } return has_more; @@ -344,9 +336,8 @@ class ThreadSafeFunction : public node::AsyncResource { v8::HandleScope scope(env->isolate); if (finalize_cb) { CallbackScope cb_scope(this); - env->CallIntoModule([&](napi_env env) { - finalize_cb(env, finalize_data, context); - }); + env->CallIntoModule( + [&](napi_env env) { finalize_cb(env, finalize_data, context); }); } EmptyQueueAndDelete(); } @@ -393,15 +384,16 @@ class ThreadSafeFunction : public node::AsyncResource { status = napi_get_undefined(env, &recv); if (status != napi_ok) { - napi_throw_error(env, "ERR_NAPI_TSFN_GET_UNDEFINED", - "Failed to retrieve undefined value"); + napi_throw_error(env, + "ERR_NAPI_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"); + napi_throw_error( + env, "ERR_NAPI_TSFN_CALL_JS", "Failed to call JS callback"); return; } } @@ -414,8 +406,8 @@ class ThreadSafeFunction : public node::AsyncResource { } static void Cleanup(void* data) { - reinterpret_cast(data) - ->CloseHandlesAndMaybeDelete(true); + reinterpret_cast(data)->CloseHandlesAndMaybeDelete( + true); } private: @@ -564,7 +556,10 @@ static void napi_module_register_cb(v8::Local exports, v8::Local module, v8::Local context, void* priv) { - napi_module_register_by_symbol(exports, module, context, + napi_module_register_by_symbol( + exports, + module, + context, static_cast(priv)->nm_register_func); } @@ -576,8 +571,7 @@ void napi_module_register_by_symbol(v8::Local exports, std::string module_filename = ""; if (init == nullptr) { CHECK_NOT_NULL(node_env); - node_env->ThrowError( - "Module has no declared entry point."); + node_env->ThrowError("Module has no declared entry point."); return; } @@ -620,23 +614,23 @@ void napi_module_register_by_symbol(v8::Local exports, namespace node { node_module napi_module_to_node_module(const napi_module* mod) { return { - -1, - mod->nm_flags | NM_F_DELETEME, - nullptr, - mod->nm_filename, - nullptr, - napi_module_register_cb, - mod->nm_modname, - const_cast(mod), // priv - nullptr, + -1, + mod->nm_flags | NM_F_DELETEME, + nullptr, + mod->nm_filename, + nullptr, + napi_module_register_cb, + mod->nm_modname, + const_cast(mod), // priv + nullptr, }; } } // namespace node // Registers a NAPI module. void napi_module_register(napi_module* mod) { - node::node_module* nm = new node::node_module( - node::napi_module_to_node_module(mod)); + node::node_module* nm = + new node::node_module(node::napi_module_to_node_module(mod)); node::node_module_register(nm); } @@ -665,23 +659,20 @@ napi_status napi_remove_env_cleanup_hook(napi_env env, struct napi_async_cleanup_hook_handle__ { napi_async_cleanup_hook_handle__(napi_env env, napi_async_cleanup_hook user_hook, - void* user_data): - env_(env), - user_hook_(user_hook), - user_data_(user_data) { + 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__() { node::RemoveEnvironmentCleanupHook(std::move(handle_)); - if (done_cb_ != nullptr) - done_cb_(done_data_); + 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([env = env_](node::Environment*) { env->Unref(); }); + static_cast(env_)->node_env()->SetImmediate( + [env = env_](node::Environment*) { env->Unref(); }); } static void Hook(void* data, void (*done_cb)(void*), void* done_data) { @@ -709,19 +700,16 @@ napi_status napi_add_async_cleanup_hook( CHECK_ARG(env, hook); napi_async_cleanup_hook_handle__* handle = - new napi_async_cleanup_hook_handle__(env, hook, arg); + new napi_async_cleanup_hook_handle__(env, hook, arg); - if (remove_handle != nullptr) - *remove_handle = handle; + if (remove_handle != nullptr) *remove_handle = handle; return napi_clear_last_error(env); } napi_status napi_remove_async_cleanup_hook( napi_async_cleanup_hook_handle remove_handle) { - - if (remove_handle == nullptr) - return napi_invalid_arg; + if (remove_handle == nullptr) return napi_invalid_arg; delete remove_handle; @@ -746,19 +734,15 @@ NAPI_NO_RETURN void napi_fatal_error(const char* location, std::string message_string; if (location_len != NAPI_AUTO_LENGTH) { - location_string.assign( - const_cast(location), location_len); + location_string.assign(const_cast(location), location_len); } else { - location_string.assign( - const_cast(location), strlen(location)); + location_string.assign(const_cast(location), strlen(location)); } if (message_len != NAPI_AUTO_LENGTH) { - message_string.assign( - const_cast(message), message_len); + message_string.assign(const_cast(message), message_len); } else { - message_string.assign( - const_cast(message), strlen(message)); + message_string.assign(const_cast(message), strlen(message)); } node::FatalError(location_string.c_str(), message_string.c_str()); @@ -831,8 +815,7 @@ napi_status napi_async_init(napi_env env, return napi_clear_last_error(env); } -napi_status napi_async_destroy(napi_env env, - napi_async_context async_context) { +napi_status napi_async_destroy(napi_env env, napi_async_context async_context) { CHECK_ENV(env); CHECK_ARG(env, async_context); @@ -890,8 +873,8 @@ napi_status napi_make_callback(napi_env env, } else { CHECK_MAYBE_EMPTY(env, callback_result, napi_generic_failure); if (result != nullptr) { - *result = v8impl::JsValueFromV8LocalValue( - callback_result.ToLocalChecked()); + *result = + v8impl::JsValueFromV8LocalValue(callback_result.ToLocalChecked()); } } @@ -932,16 +915,19 @@ napi_status napi_create_external_buffer(napi_env env, v8::Isolate* isolate = env->isolate; // The finalizer object will delete itself after invoking the callback. - v8impl::Finalizer* finalizer = v8impl::Finalizer::New( - env, finalize_cb, nullptr, finalize_hint, - v8impl::Finalizer::kKeepEnvReference); - - v8::MaybeLocal maybe = node::Buffer::New( - isolate, - static_cast(data), - length, - v8impl::BufferFinalizer::FinalizeBufferCallback, - finalizer); + v8impl::Finalizer* finalizer = + v8impl::Finalizer::New(env, + finalize_cb, + nullptr, + finalize_hint, + v8impl::Finalizer::kKeepEnvReference); + + v8::MaybeLocal maybe = + node::Buffer::New(isolate, + static_cast(data), + length, + v8impl::BufferFinalizer::FinalizeBufferCallback, + finalizer); CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure); @@ -961,9 +947,8 @@ napi_status napi_create_buffer_copy(napi_env env, NAPI_PREAMBLE(env); CHECK_ARG(env, result); - v8::MaybeLocal maybe = node::Buffer::Copy( - env->isolate, - static_cast(data), length); + v8::MaybeLocal maybe = + node::Buffer::Copy(env->isolate, static_cast(data), length); CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure); @@ -1010,11 +995,7 @@ napi_status napi_get_node_version(napi_env env, CHECK_ENV(env); CHECK_ARG(env, result); static const napi_node_version version = { - NODE_MAJOR_VERSION, - NODE_MINOR_VERSION, - NODE_PATCH_VERSION, - NODE_RELEASE - }; + NODE_MAJOR_VERSION, NODE_MINOR_VERSION, NODE_PATCH_VERSION, NODE_RELEASE}; *result = &version; return napi_clear_last_error(env); } @@ -1044,15 +1025,15 @@ class Work : public node::AsyncResource, public node::ThreadPoolWork { napi_async_execute_callback execute, napi_async_complete_callback complete = nullptr, void* data = nullptr) - : AsyncResource(env->isolate, - async_resource, - *v8::String::Utf8Value(env->isolate, async_resource_name)), - ThreadPoolWork(env->node_env()), - _env(env), - _data(data), - _execute(execute), - _complete(complete) { - } + : AsyncResource( + env->isolate, + async_resource, + *v8::String::Utf8Value(env->isolate, async_resource_name)), + ThreadPoolWork(env->node_env()), + _env(env), + _data(data), + _execute(execute), + _complete(complete) {} ~Work() override = default; @@ -1063,21 +1044,16 @@ class Work : public node::AsyncResource, public node::ThreadPoolWork { napi_async_execute_callback execute, napi_async_complete_callback complete, void* data) { - return new Work(env, async_resource, async_resource_name, - execute, complete, data); + return new Work( + env, async_resource, async_resource_name, execute, complete, data); } - static void Delete(Work* work) { - delete work; - } + static void Delete(Work* work) { delete work; } - void DoThreadPoolWork() override { - _execute(_env, _data); - } + void DoThreadPoolWork() override { _execute(_env, _data); } void AfterThreadPoolWork(int status) override { - if (_complete == nullptr) - return; + if (_complete == nullptr) return; // Establish a handle scope here so that every callback doesn't have to. // Also it is needed for the exception-handling below. @@ -1085,14 +1061,16 @@ class Work : public node::AsyncResource, public node::ThreadPoolWork { CallbackScope callback_scope(this); - _env->CallIntoModule([&](napi_env env) { - _complete(env, ConvertUVErrorCode(status), _data); - }, [](napi_env env, v8::Local local_err) { - // If there was an unhandled exception in the complete callback, - // report it as a fatal exception. (There is no JavaScript on the - // callstack that can possibly handle it.) - v8impl::trigger_fatal_exception(env, local_err); - }); + _env->CallIntoModule( + [&](napi_env env) { + _complete(env, ConvertUVErrorCode(status), _data); + }, + [](napi_env env, v8::Local local_err) { + // If there was an unhandled exception in the complete callback, + // report it as a fatal exception. (There is no JavaScript on the + // callstack that can possibly handle it.) + v8impl::trigger_fatal_exception(env, local_err); + }); // Note: Don't access `work` after this point because it was // likely deleted by the complete callback. @@ -1108,13 +1086,13 @@ class Work : public node::AsyncResource, public node::ThreadPoolWork { } // end of namespace uvimpl } // end of anonymous namespace -#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); \ - } \ +#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); \ + } \ } while (0) napi_status napi_create_async_work(napi_env env, @@ -1193,18 +1171,18 @@ napi_status napi_cancel_async_work(napi_env env, napi_async_work work) { return napi_clear_last_error(env); } -napi_status -napi_create_threadsafe_function(napi_env env, - napi_value func, - napi_value async_resource, - napi_value async_resource_name, - size_t max_queue_size, - size_t initial_thread_count, - void* thread_finalize_data, - napi_finalize thread_finalize_cb, - void* context, - napi_threadsafe_function_call_js call_js_cb, - napi_threadsafe_function* result) { +napi_status napi_create_threadsafe_function( + napi_env env, + napi_value func, + napi_value async_resource, + napi_value async_resource_name, + size_t max_queue_size, + size_t initial_thread_count, + void* thread_finalize_data, + napi_finalize thread_finalize_cb, + void* context, + napi_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); @@ -1256,9 +1234,8 @@ napi_create_threadsafe_function(napi_env env, return napi_set_last_error(env, status); } -napi_status -napi_get_threadsafe_function_context(napi_threadsafe_function func, - void** result) { +napi_status napi_get_threadsafe_function_context(napi_threadsafe_function func, + void** result) { CHECK_NOT_NULL(func); CHECK_NOT_NULL(result); @@ -1266,36 +1243,34 @@ napi_get_threadsafe_function_context(napi_threadsafe_function func, return napi_ok; } -napi_status -napi_call_threadsafe_function(napi_threadsafe_function func, - void* data, - napi_threadsafe_function_call_mode is_blocking) { +napi_status napi_call_threadsafe_function( + napi_threadsafe_function func, + void* data, + napi_threadsafe_function_call_mode is_blocking) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Push(data, is_blocking); } -napi_status -napi_acquire_threadsafe_function(napi_threadsafe_function func) { +napi_status napi_acquire_threadsafe_function(napi_threadsafe_function func) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Acquire(); } -napi_status -napi_release_threadsafe_function(napi_threadsafe_function func, - napi_threadsafe_function_release_mode mode) { +napi_status napi_release_threadsafe_function( + napi_threadsafe_function func, napi_threadsafe_function_release_mode mode) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Release(mode); } -napi_status -napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func) { +napi_status napi_unref_threadsafe_function(napi_env env, + napi_threadsafe_function func) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Unref(); } -napi_status -napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func) { +napi_status napi_ref_threadsafe_function(napi_env env, + napi_threadsafe_function func) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Ref(); } diff --git a/src/node_api.h b/src/node_api.h index 1772c67c15afb2..e8e903b62a893b 100644 --- a/src/node_api.h +++ b/src/node_api.h @@ -2,12 +2,12 @@ #define SRC_NODE_API_H_ #ifdef BUILDING_NODE_EXTENSION - #ifdef _WIN32 - // Building native module against node - #define NAPI_EXTERN __declspec(dllimport) - #elif defined(__wasm32__) - #define NAPI_EXTERN __attribute__((__import_module__("napi"))) - #endif +#ifdef _WIN32 +// Building native module against node +#define NAPI_EXTERN __declspec(dllimport) +#elif defined(__wasm32__) +#define NAPI_EXTERN __attribute__((__import_module__("napi"))) +#endif #endif #include "js_native_api.h" #include "node_api_types.h" @@ -15,17 +15,17 @@ struct uv_loop_s; // Forward declaration. #ifdef _WIN32 -# define NAPI_MODULE_EXPORT __declspec(dllexport) +#define NAPI_MODULE_EXPORT __declspec(dllexport) #else -# define NAPI_MODULE_EXPORT __attribute__((visibility("default"))) +#define NAPI_MODULE_EXPORT __attribute__((visibility("default"))) #endif #if defined(__GNUC__) -# define NAPI_NO_RETURN __attribute__((noreturn)) +#define NAPI_NO_RETURN __attribute__((noreturn)) #elif defined(_WIN32) -# define NAPI_NO_RETURN __declspec(noreturn) +#define NAPI_NO_RETURN __declspec(noreturn) #else -# define NAPI_NO_RETURN +#define NAPI_NO_RETURN #endif typedef napi_value (*napi_addon_register_func)(napi_env env, @@ -41,36 +41,33 @@ typedef struct napi_module { void* reserved[4]; } napi_module; -#define NAPI_MODULE_VERSION 1 +#define NAPI_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; \ +#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)); \ +#define NAPI_C_CTOR(fn) \ + static void fn(void) __attribute__((constructor)); \ static void fn(void) #endif -#define NAPI_MODULE_X(modname, regfunc, priv, flags) \ - EXTERN_C_START \ - static napi_module _module = \ - { \ - NAPI_MODULE_VERSION, \ - flags, \ - __FILE__, \ - regfunc, \ - #modname, \ - priv, \ - {0}, \ - }; \ - NAPI_C_CTOR(_register_ ## modname) { \ - napi_module_register(&_module); \ - } \ +#define NAPI_MODULE_X(modname, regfunc, priv, flags) \ + EXTERN_C_START \ + static napi_module _module = { \ + NAPI_MODULE_VERSION, \ + flags, \ + __FILE__, \ + regfunc, \ + #modname, \ + priv, \ + {0}, \ + }; \ + NAPI_C_CTOR(_register_##modname) { napi_module_register(&_module); } \ EXTERN_C_END #define NAPI_MODULE_INITIALIZER_X(base, version) \ @@ -88,24 +85,22 @@ typedef struct napi_module { } \ EXTERN_C_END #else -#define NAPI_MODULE(modname, regfunc) \ +#define NAPI_MODULE(modname, regfunc) \ NAPI_MODULE_X(modname, regfunc, NULL, 0) // NOLINT (readability/null_usage) #endif #define NAPI_MODULE_INITIALIZER_BASE napi_register_module_v -#define NAPI_MODULE_INITIALIZER \ - NAPI_MODULE_INITIALIZER_X(NAPI_MODULE_INITIALIZER_BASE, \ - NAPI_MODULE_VERSION) +#define NAPI_MODULE_INITIALIZER \ + NAPI_MODULE_INITIALIZER_X(NAPI_MODULE_INITIALIZER_BASE, NAPI_MODULE_VERSION) -#define NAPI_MODULE_INIT() \ - EXTERN_C_START \ - NAPI_MODULE_EXPORT napi_value \ - NAPI_MODULE_INITIALIZER(napi_env env, napi_value exports); \ - EXTERN_C_END \ - NAPI_MODULE(NODE_GYP_MODULE_NAME, NAPI_MODULE_INITIALIZER) \ - napi_value NAPI_MODULE_INITIALIZER(napi_env env, \ - napi_value exports) +#define NAPI_MODULE_INIT() \ + EXTERN_C_START \ + NAPI_MODULE_EXPORT napi_value NAPI_MODULE_INITIALIZER(napi_env env, \ + napi_value exports); \ + EXTERN_C_END \ + NAPI_MODULE(NODE_GYP_MODULE_NAME, NAPI_MODULE_INITIALIZER) \ + napi_value NAPI_MODULE_INITIALIZER(napi_env env, napi_value exports) EXTERN_C_START @@ -225,9 +220,8 @@ napi_create_threadsafe_function(napi_env env, napi_threadsafe_function_call_js call_js_cb, napi_threadsafe_function* result); -NAPI_EXTERN napi_status -napi_get_threadsafe_function_context(napi_threadsafe_function func, - void** result); +NAPI_EXTERN napi_status napi_get_threadsafe_function_context( + napi_threadsafe_function func, void** result); NAPI_EXTERN napi_status napi_call_threadsafe_function(napi_threadsafe_function func, @@ -237,9 +231,8 @@ napi_call_threadsafe_function(napi_threadsafe_function func, NAPI_EXTERN napi_status napi_acquire_threadsafe_function(napi_threadsafe_function func); -NAPI_EXTERN napi_status -napi_release_threadsafe_function(napi_threadsafe_function func, - napi_threadsafe_function_release_mode mode); +NAPI_EXTERN napi_status napi_release_threadsafe_function( + napi_threadsafe_function func, napi_threadsafe_function_release_mode mode); NAPI_EXTERN napi_status napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func); @@ -252,21 +245,21 @@ napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func); #if NAPI_VERSION >= 8 -NAPI_EXTERN napi_status napi_add_async_cleanup_hook( - napi_env env, - napi_async_cleanup_hook hook, - void* arg, - napi_async_cleanup_hook_handle* remove_handle); +NAPI_EXTERN napi_status +napi_add_async_cleanup_hook(napi_env env, + napi_async_cleanup_hook hook, + void* arg, + napi_async_cleanup_hook_handle* remove_handle); -NAPI_EXTERN napi_status napi_remove_async_cleanup_hook( - napi_async_cleanup_hook_handle remove_handle); +NAPI_EXTERN napi_status +napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle); #endif // NAPI_VERSION >= 8 #ifdef NAPI_EXPERIMENTAL -NAPI_EXTERN napi_status -node_api_get_module_file_name(napi_env env, const char** result); +NAPI_EXTERN napi_status node_api_get_module_file_name(napi_env env, + const char** result); #endif // NAPI_EXPERIMENTAL diff --git a/src/node_api_types.h b/src/node_api_types.h index 58ffc61b3a5f51..4ad26a8fb6476e 100644 --- a/src/node_api_types.h +++ b/src/node_api_types.h @@ -22,8 +22,7 @@ typedef enum { } napi_threadsafe_function_call_mode; #endif // NAPI_VERSION >= 4 -typedef void (*napi_async_execute_callback)(napi_env env, - void* data); +typedef void (*napi_async_execute_callback)(napi_env env, void* data); typedef void (*napi_async_complete_callback)(napi_env env, napi_status status, void* data);