Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/nodejs/node.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorVladimir Morozov <vmorozov@microsoft.com>2022-03-19 01:59:02 +0300
committerMichael Dawson <mdawson@devrus.com>2022-03-21 20:24:16 +0300
commit718be08686312d19645861b9715491a49ee3c9cb (patch)
tree1a0dca89f88f5141f44092df90556f585253b85e /src
parent655926155647ad39236220b094c7d1f391ce02ed (diff)
node-api: format Node-API related code
PR-URL: https://github.com/nodejs/node/pull/42396 Reviewed-By: Anna Henningsen <anna@addaleax.net> Reviewed-By: Michael Dawson <midawson@redhat.com> Reviewed-By: Darshan Sen <raisinten@gmail.com>
Diffstat (limited to 'src')
-rw-r--r--src/js_native_api.h81
-rw-r--r--src/js_native_api_types.h9
-rw-r--r--src/js_native_api_v8.cc583
-rw-r--r--src/js_native_api_v8.h183
-rw-r--r--src/js_native_api_v8_internals.h12
-rw-r--r--src/node_api.cc319
-rw-r--r--src/node_api.h113
-rw-r--r--src/node_api_types.h3
8 files changed, 577 insertions, 726 deletions
diff --git a/src/js_native_api.h b/src/js_native_api.h
index 50ccf11e240..364d3672d1c 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 <stddef.h> // NOLINT(modernize-deprecated-headers)
#include <stdbool.h> // NOLINT(modernize-deprecated-headers)
+#include <stddef.h> // 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 <node_api.h> 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 6aba06629b3..da4bff19d38 100644
--- a/src/js_native_api_types.h
+++ b/src/js_native_api_types.h
@@ -8,7 +8,7 @@
#include <stdint.h> // 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 1c29c43836a..611a0521fce 100644
--- a/src/js_native_api_v8.cc
+++ b/src/js_native_api_v8.cc
@@ -1,43 +1,41 @@
+#include <algorithm>
#include <climits> // INT_MAX
#include <cmath>
-#include <algorithm>
#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<int>(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<int>(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<int>(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<int>(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<v8::Name>* result) {
+inline static napi_status V8NameFromPropertyDescriptor(
+ napi_env env,
+ const napi_property_descriptor* p,
+ v8::Local<v8::Name>* result) {
if (p->utf8name != nullptr) {
CHECK_NEW_FROM_UTF8(env, *result, p->utf8name);
} else {
v8::Local<v8::Value> 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<v8::Name>();
@@ -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<v8::PropertyAttribute>(attribute_flags);
}
-inline static napi_deferred
-JsDeferredFromNodePersistent(v8impl::Persistent<v8::Value>* local) {
+inline static napi_deferred JsDeferredFromNodePersistent(
+ v8impl::Persistent<v8::Value>* local) {
return reinterpret_cast<napi_deferred>(local);
}
-inline static v8impl::Persistent<v8::Value>*
-NodePersistentFromJsDeferred(napi_deferred local) {
+inline static v8impl::Persistent<v8::Value>* NodePersistentFromJsDeferred(
+ napi_deferred local) {
return reinterpret_cast<v8impl::Persistent<v8::Value>*>(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 <typename T>
v8::Local<T> Escape(v8::Local<T> 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<napi_handle_scope>(s);
}
-inline static HandleScopeWrapper*
-V8HandleScopeFromJsHandleScope(napi_handle_scope s) {
+inline static HandleScopeWrapper* V8HandleScopeFromJsHandleScope(
+ napi_handle_scope s) {
return reinterpret_cast<HandleScopeWrapper*>(s);
}
@@ -177,9 +176,11 @@ inline static napi_status ConcludeDeferred(napi_env env,
auto v8_resolver = v8_deferred.As<v8::Promise::Resolver>();
- v8::Maybe<bool> success = is_resolved ?
- v8_resolver->Resolve(context, v8impl::V8LocalValueFromJsValue(result)) :
- v8_resolver->Reject(context, v8impl::V8LocalValueFromJsValue(result));
+ v8::Maybe<bool> 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<v8::Object> obj = value.As<v8::Object>();
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<v8impl::Reference*>(val.As<v8::External>()->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<v8::Value>
- New(napi_env env, napi_callback cb, void* data) {
+ static inline v8::Local<v8::Value> 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<CallbackBundle*>(data);
@@ -288,9 +288,8 @@ class CallbackWrapperBase : public CallbackWrapper {
public:
inline CallbackWrapperBase(const v8::FunctionCallbackInfo<v8::Value>& 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<CallbackBundle*>(
cbinfo.Data().As<v8::External>()->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<v8::Value> value) {
- exceptionOccurred = true;
- env->isolate->ThrowException(value);
- });
+ env->CallIntoModule([&](napi_env env) { result = cb(env, cbinfo_wrapper); },
+ [&](napi_env env, v8::Local<v8::Value> 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<v8::Value>& 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<v8::FunctionTemplate>* result,
- v8::Local<v8::Signature> sig = v8::Local<v8::Signature>()) {
+ static inline napi_status NewTemplate(
+ napi_env env,
+ napi_callback cb,
+ void* cb_data,
+ v8::Local<v8::FunctionTemplate>* result,
+ v8::Local<v8::Signature> sig = v8::Local<v8::Signature>()) {
v8::Local<v8::Value> 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 <WrapType wrap_type>
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<napi_ref>(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<v8::FunctionTemplate> 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_filter>(napi_key_enumerable |
- napi_key_skip_symbols),
+ static_cast<napi_key_filter>(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<v8::PropertyFilter>(filter |
- v8::PropertyFilter::ONLY_WRITABLE);
+ filter = static_cast<v8::PropertyFilter>(filter |
+ v8::PropertyFilter::ONLY_WRITABLE);
}
if (key_filter & napi_key_enumerable) {
- filter =
- static_cast<v8::PropertyFilter>(filter |
- v8::PropertyFilter::ONLY_ENUMERABLE);
+ filter = static_cast<v8::PropertyFilter>(
+ filter | v8::PropertyFilter::ONLY_ENUMERABLE);
}
if (key_filter & napi_key_configurable) {
- filter =
- static_cast<v8::PropertyFilter>(filter |
- v8::PropertyFilter::ONLY_WRITABLE);
+ filter = static_cast<v8::PropertyFilter>(filter |
+ v8::PropertyFilter::ONLY_WRITABLE);
}
if (key_filter & napi_key_skip_strings) {
- filter =
- static_cast<v8::PropertyFilter>(filter |
- v8::PropertyFilter::SKIP_STRINGS);
+ filter = static_cast<v8::PropertyFilter>(filter |
+ v8::PropertyFilter::SKIP_STRINGS);
}
if (key_filter & napi_key_skip_symbols) {
- filter =
- static_cast<v8::PropertyFilter>(filter |
- v8::PropertyFilter::SKIP_SYMBOLS);
+ filter = static_cast<v8::PropertyFilter>(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<bool> 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<bool> 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<v8::Context> context = env->context();
@@ -1343,16 +1331,15 @@ napi_status napi_object_freeze(napi_env env,
CHECK_TO_OBJECT(env, context, obj, object);
v8::Maybe<bool> 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<v8::Context> context = env->context();
@@ -1361,10 +1348,10 @@ napi_status napi_object_seal(napi_env env,
CHECK_TO_OBJECT(env, context, obj, object);
v8::Maybe<bool> 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<int>(length));
+ auto str_maybe = v8::String::NewFromUtf8(
+ isolate, str, v8::NewStringType::kNormal, static_cast<int>(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<v8::Context> 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<v8::BigInt> b = v8::BigInt::NewFromWords(
- context, sign_bit, word_count, words);
+ v8::MaybeLocal<v8::BigInt> 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::String>()));
+ v8::Symbol::New(isolate, desc.As<v8::String>()));
}
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<v8::String> description_string =
- v8impl::V8LocalValueFromJsValue(js_description_string).As<v8::String>();
+ v8impl::V8LocalValueFromJsValue(js_description_string).As<v8::String>();
*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<bool> 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<v8::Function> v8func;
CHECK_TO_FUNCTION(env, v8func, func);
- auto maybe = v8func->Call(context, v8recv, argc,
- reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
+ auto maybe = v8func->Call(
+ context,
+ v8recv,
+ argc,
+ reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(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<v8::Boolean> 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<v8::Context> context = env->context(); \
- v8::Local<v8::MixedCaseName> 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<v8::Context> context = env->context(); \
+ v8::Local<v8::MixedCaseName> 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<v8impl::retrievable>(env,
- js_object,
- native_object,
- finalize_cb,
- finalize_hint,
- result);
+ return v8impl::Wrap<v8impl::retrievable>(
+ 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<const uint64_t*>(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<const uint64_t*>(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<v8::Value> 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<v8::BigInt>()->ToWordsArray(&sign,
- &size,
- reinterpret_cast<uint64_t*>(&tag));
+ val.As<v8::BigInt>()->ToWordsArray(
+ &sign, &size, reinterpret_cast<uint64_t*>(&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<v8::Function> ctor;
CHECK_TO_FUNCTION(env, ctor, constructor);
- auto maybe = ctor->NewInstance(context, argc,
- reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
+ auto maybe = ctor->NewInstance(
+ context,
+ argc,
+ reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(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<v8::Value>::New(env->isolate, env->last_exception));
+ v8::Local<v8::Value>::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<v8::ArrayBuffer> buffer = value.As<v8::ArrayBuffer>();
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<v8::DataView> DataView = v8::DataView::New(buffer, byte_offset,
- byte_length);
+ v8::Local<v8::DataView> 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<v8::String>());
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<v8impl::anonymous>(env,
- js_object,
- native_object,
- finalize_cb,
- finalize_hint,
- result);
+ return v8impl::Wrap<v8impl::anonymous>(
+ 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 bdf68505a7d..ffe351f4f6c 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<v8::Context> 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<bool> mark_arraybuffer_as_untransferable(
@@ -83,8 +84,7 @@ struct napi_env__ {
return v8::Just(true);
}
- static inline void
- HandleThrow(napi_env env, v8::Local<v8::Value> value) {
+ static inline void HandleThrow(napi_env env, v8::Local<v8::Value> 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<v8::Value> 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<v8::Value> v8value = v8impl::V8LocalValueFromJsValue((src)); \
- RETURN_STATUS_IF_FALSE((env), v8value->IsFunction(), napi_invalid_arg); \
- (result) = v8value.As<v8::Function>(); \
+#define CHECK_TO_FUNCTION(env, result, src) \
+ do { \
+ CHECK_ARG((env), (src)); \
+ v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue((src)); \
+ RETURN_STATUS_IF_FALSE((env), v8value->IsFunction(), napi_invalid_arg); \
+ (result) = v8value.As<v8::Function>(); \
} 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<v8::Value>) == sizeof(napi_value),
- "Cannot convert between v8::Local<v8::Value> and napi_value");
+ "Cannot convert between v8::Local<v8::Value> and napi_value");
inline napi_value JsValueFromV8LocalValue(v8::Local<v8::Value> local) {
return reinterpret_cast<napi_value>(*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 8428390ef1e..4f1b94d3d0c 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 60fbe96b8ef..aa4f8a6a240 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -64,18 +64,16 @@ class BufferFinalizer : private Finalizer {
static_cast<node_napi_env>(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<v8::Context> context, const std::string& module_filename) {
+static inline napi_env NewEnv(v8::Local<v8::Context> 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<v8::Context> 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<napi_env>(arg)->Unref();
- },
+ [](void* arg) { static_cast<napi_env>(arg)->Unref(); },
static_cast<void*>(result));
return result;
}
-static inline void trigger_fatal_exception(
- napi_env env, v8::Local<v8::Value> local_err) {
+static inline void trigger_fatal_exception(napi_env env,
+ v8::Local<v8::Value> local_err) {
v8::Local<v8::Message> 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<v8::Function> js_cb =
- v8::Local<v8::Function>::New(env->isolate, ref);
+ v8::Local<v8::Function>::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<ThreadSafeFunction*>(data)
- ->CloseHandlesAndMaybeDelete(true);
+ reinterpret_cast<ThreadSafeFunction*>(data)->CloseHandlesAndMaybeDelete(
+ true);
}
private:
@@ -564,7 +556,10 @@ static void napi_module_register_cb(v8::Local<v8::Object> exports,
v8::Local<v8::Value> module,
v8::Local<v8::Context> context,
void* priv) {
- napi_module_register_by_symbol(exports, module, context,
+ napi_module_register_by_symbol(
+ exports,
+ module,
+ context,
static_cast<const napi_module*>(priv)->nm_register_func);
}
@@ -576,8 +571,7 @@ void napi_module_register_by_symbol(v8::Local<v8::Object> 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<v8::Object> 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<napi_module*>(mod), // priv
- nullptr,
+ -1,
+ mod->nm_flags | NM_F_DELETEME,
+ nullptr,
+ mod->nm_filename,
+ nullptr,
+ napi_module_register_cb,
+ mod->nm_modname,
+ const_cast<napi_module*>(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<node_napi_env>(env_)->node_env()
- ->SetImmediate([env = env_](node::Environment*) { env->Unref(); });
+ static_cast<node_napi_env>(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<char*>(location), location_len);
+ location_string.assign(const_cast<char*>(location), location_len);
} else {
- location_string.assign(
- const_cast<char*>(location), strlen(location));
+ location_string.assign(const_cast<char*>(location), strlen(location));
}
if (message_len != NAPI_AUTO_LENGTH) {
- message_string.assign(
- const_cast<char*>(message), message_len);
+ message_string.assign(const_cast<char*>(message), message_len);
} else {
- message_string.assign(
- const_cast<char*>(message), strlen(message));
+ message_string.assign(const_cast<char*>(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<v8::Object> maybe = node::Buffer::New(
- isolate,
- static_cast<char*>(data),
- length,
- v8impl::BufferFinalizer::FinalizeBufferCallback,
- finalizer);
+ v8impl::Finalizer* finalizer =
+ v8impl::Finalizer::New(env,
+ finalize_cb,
+ nullptr,
+ finalize_hint,
+ v8impl::Finalizer::kKeepEnvReference);
+
+ v8::MaybeLocal<v8::Object> maybe =
+ node::Buffer::New(isolate,
+ static_cast<char*>(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<v8::Object> maybe = node::Buffer::Copy(
- env->isolate,
- static_cast<const char*>(data), length);
+ v8::MaybeLocal<v8::Object> maybe =
+ node::Buffer::Copy(env->isolate, static_cast<const char*>(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<v8::Value> 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<v8::Value> 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<v8impl::ThreadSafeFunction*>(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<v8impl::ThreadSafeFunction*>(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<v8impl::ThreadSafeFunction*>(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<v8impl::ThreadSafeFunction*>(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<v8impl::ThreadSafeFunction*>(func)->Ref();
}
diff --git a/src/node_api.h b/src/node_api.h
index 1772c67c15a..e8e903b62a8 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 58ffc61b3a5..4ad26a8fb64 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);
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-03 15:14:08 +0300