1berry/nodejs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

node-api: rename nogc to basic

Browse Source 
Signed-off-by: Gabriel Schulhof <gabrielschulhof@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/53830
Reviewed-By: Vladimir Morozov <vmorozov@microsoft.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Michael Dawson <midawson@redhat.com>
This commit is contained in:
Gabriel Schulhof 2024-07-12 20:59:47 -07:00
parent 5e533710c8
commit 2d1b4a8cf7
13 changed files with 157 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
benchmark/napi/ref/addon.c
View File

@ -33,7 +33,7 @@ SetCount(napi_env env, napi_callback_info info) {
return NULL; return NULL;
} }
static void IncrementCounter(node_api_nogc_env env, void* data, void* hint) { static void IncrementCounter(node_api_basic_env env, void* data, void* hint) {
size_t* count = data; size_t* count = data;
(*count) = (*count) + 1; (*count) = (*count) + 1;
} }

62
doc/api/n-api.md
View File

@ -477,7 +477,7 @@ napiVersion: 6
--> -->
```c ```c
napi_status napi_set_instance_data(node_api_nogc_env env, napi_status napi_set_instance_data(node_api_basic_env env,
void* data, void* data,
napi_finalize finalize_cb, napi_finalize finalize_cb,
void* finalize_hint); void* finalize_hint);
@ -509,7 +509,7 @@ napiVersion: 6
--> -->
```c ```c
napi_status napi_get_instance_data(node_api_nogc_env env, napi_status napi_get_instance_data(node_api_basic_env env,
void** data); void** data);
``` ```
@ -611,16 +611,16 @@ when an instance of a native addon is unloaded. Notification of this event is
delivered through the callbacks given to [`napi_add_env_cleanup_hook`][] and delivered through the callbacks given to [`napi_add_env_cleanup_hook`][] and
[`napi_set_instance_data`][]. [`napi_set_instance_data`][].
### `node_api_nogc_env` ### `node_api_basic_env`
> Stability: 1 - Experimental > Stability: 1 - Experimental
This variant of `napi_env` is passed to synchronous finalizers This variant of `napi_env` is passed to synchronous finalizers
([`node_api_nogc_finalize`][]). There is a subset of Node-APIs which accept ([`node_api_basic_finalize`][]). There is a subset of Node-APIs which accept
a parameter of type `node_api_nogc_env` as their first argument. These APIs do a parameter of type `node_api_basic_env` as their first argument. These APIs do
not access the state of the JavaScript engine and are thus safe to call from not access the state of the JavaScript engine and are thus safe to call from
synchronous finalizers. Passing a parameter of type `napi_env` to these APIs is synchronous finalizers. Passing a parameter of type `napi_env` to these APIs is
allowed, however, passing a parameter of type `node_api_nogc_env` to APIs that allowed, however, passing a parameter of type `node_api_basic_env` to APIs that
access the JavaScript engine state is not allowed. Attempting to do so without access the JavaScript engine state is not allowed. Attempting to do so without
a cast will produce a compiler warning or an error when add-ons are compiled a cast will produce a compiler warning or an error when add-ons are compiled
with flags which cause them to emit warnings and/or errors when incorrect with flags which cause them to emit warnings and/or errors when incorrect
@ -791,7 +791,7 @@ typedef napi_value (*napi_callback)(napi_env, napi_callback_info);
Unless for reasons discussed in [Object Lifetime Management][], creating a Unless for reasons discussed in [Object Lifetime Management][], creating a
handle and/or callback scope inside a `napi_callback` is not necessary. handle and/or callback scope inside a `napi_callback` is not necessary.
#### `node_api_nogc_finalize` #### `node_api_basic_finalize`
<!-- YAML <!-- YAML
added: added:
@ -806,11 +806,11 @@ Function pointer type for add-on provided functions that allow the user to be
notified when externally-owned data is ready to be cleaned up because the notified when externally-owned data is ready to be cleaned up because the
object it was associated with has been garbage-collected. The user must provide object it was associated with has been garbage-collected. The user must provide
a function satisfying the following signature which would get called upon the a function satisfying the following signature which would get called upon the
object's collection. Currently, `node_api_nogc_finalize` can be used for object's collection. Currently, `node_api_basic_finalize` can be used for
finding out when objects that have external data are collected. finding out when objects that have external data are collected.
```c ```c
typedef void (*node_api_nogc_finalize)(node_api_nogc_env env, typedef void (*node_api_basic_finalize)(node_api_basic_env env,
void* finalize_data, void* finalize_data,
void* finalize_hint); void* finalize_hint);
``` ```
@ -820,7 +820,7 @@ handle and/or callback scope inside the function body is not necessary.
Since these functions may be called while the JavaScript engine is in a state Since these functions may be called while the JavaScript engine is in a state
where it cannot execute JavaScript code, only Node-APIs which accept a where it cannot execute JavaScript code, only Node-APIs which accept a
`node_api_nogc_env` as their first parameter may be called. `node_api_basic_env` as their first parameter may be called.
[`node_api_post_finalizer`][] can be used to schedule Node-API calls that [`node_api_post_finalizer`][] can be used to schedule Node-API calls that
require access to the JavaScript engine's state to run after the current require access to the JavaScript engine's state to run after the current
garbage collection cycle has completed. garbage collection cycle has completed.
@ -834,10 +834,10 @@ Change History:
* experimental (`NAPI_EXPERIMENTAL`): * experimental (`NAPI_EXPERIMENTAL`):
Only Node-API calls that accept a `node_api_nogc_env` as their first Only Node-API calls that accept a `node_api_basic_env` as their first
parameter may be called, otherwise the application will be terminated with an parameter may be called, otherwise the application will be terminated with an
appropriate error message. This feature can be turned off by defining appropriate error message. This feature can be turned off by defining
`NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT`. `NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT`.
#### `napi_finalize` #### `napi_finalize`
@ -862,9 +862,9 @@ Change History:
* experimental (`NAPI_EXPERIMENTAL` is defined): * experimental (`NAPI_EXPERIMENTAL` is defined):
A function of this type may no longer be used as a finalizer, except with A function of this type may no longer be used as a finalizer, except with
[`node_api_post_finalizer`][]. [`node_api_nogc_finalize`][] must be used [`node_api_post_finalizer`][]. [`node_api_basic_finalize`][] must be used
instead. This feature can be turned off by defining instead. This feature can be turned off by defining
`NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT`. `NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT`.
#### `napi_async_execute_callback` #### `napi_async_execute_callback`
@ -1066,7 +1066,7 @@ napiVersion: 1
```c ```c
napi_status napi_status
napi_get_last_error_info(node_api_nogc_env env, napi_get_last_error_info(node_api_basic_env env,
const napi_extended_error_info** result); const napi_extended_error_info** result);
``` ```
@ -1885,7 +1885,7 @@ napiVersion: 3
--> -->
```c ```c
NODE_EXTERN napi_status napi_add_env_cleanup_hook(node_api_nogc_env env, NODE_EXTERN napi_status napi_add_env_cleanup_hook(node_api_basic_env env,
napi_cleanup_hook fun, napi_cleanup_hook fun,
void* arg); void* arg);
``` ```
@ -1915,7 +1915,7 @@ napiVersion: 3
--> -->
```c ```c
NAPI_EXTERN napi_status napi_remove_env_cleanup_hook(node_api_nogc_env env, NAPI_EXTERN napi_status napi_remove_env_cleanup_hook(node_api_basic_env env,
void (*fun)(void* arg), void (*fun)(void* arg),
void* arg); void* arg);
``` ```
@ -1944,7 +1944,7 @@ changes:
```c ```c
NAPI_EXTERN napi_status napi_add_async_cleanup_hook( NAPI_EXTERN napi_status napi_add_async_cleanup_hook(
node_api_nogc_env env, node_api_basic_env env,
napi_async_cleanup_hook hook, napi_async_cleanup_hook hook,
void* arg, void* arg,
napi_async_cleanup_hook_handle* remove_handle); napi_async_cleanup_hook_handle* remove_handle);
@ -5533,7 +5533,7 @@ napiVersion: 5
napi_status napi_add_finalizer(napi_env env, napi_status napi_add_finalizer(napi_env env,
napi_value js_object, napi_value js_object,
void* finalize_data, void* finalize_data,
node_api_nogc_finalize finalize_cb, node_api_basic_finalize finalize_cb,
void* finalize_hint, void* finalize_hint,
napi_ref* result); napi_ref* result);
``` ```
@ -5574,7 +5574,7 @@ added:
> Stability: 1 - Experimental > Stability: 1 - Experimental
```c ```c
napi_status node_api_post_finalizer(node_api_nogc_env env, napi_status node_api_post_finalizer(node_api_basic_env env,
napi_finalize finalize_cb, napi_finalize finalize_cb,
void* finalize_data, void* finalize_data,
void* finalize_hint); void* finalize_hint);
@ -5644,7 +5644,7 @@ Once created the async worker can be queued
for execution using the [`napi_queue_async_work`][] function: for execution using the [`napi_queue_async_work`][] function:
```c ```c
napi_status napi_queue_async_work(node_api_nogc_env env, napi_status napi_queue_async_work(node_api_basic_env env,
napi_async_work work); napi_async_work work);
``` ```
@ -5736,7 +5736,7 @@ napiVersion: 1
--> -->
```c ```c
napi_status napi_queue_async_work(node_api_nogc_env env, napi_status napi_queue_async_work(node_api_basic_env env,
napi_async_work work); napi_async_work work);
``` ```
@ -5757,7 +5757,7 @@ napiVersion: 1
--> -->
```c ```c
napi_status napi_cancel_async_work(node_api_nogc_env env, napi_status napi_cancel_async_work(node_api_basic_env env,
napi_async_work work); napi_async_work work);
``` ```
@ -5961,7 +5961,7 @@ typedef struct {
const char* release; const char* release;
} napi_node_version; } napi_node_version;
napi_status napi_get_node_version(node_api_nogc_env env, napi_status napi_get_node_version(node_api_basic_env env,
const napi_node_version** version); const napi_node_version** version);
``` ```
@ -5984,7 +5984,7 @@ napiVersion: 1
--> -->
```c ```c
napi_status napi_get_version(node_api_nogc_env env, napi_status napi_get_version(node_api_basic_env env,
uint32_t* result); uint32_t* result);
``` ```
@ -6017,7 +6017,7 @@ napiVersion: 1
--> -->
```c ```c
NAPI_EXTERN napi_status napi_adjust_external_memory(node_api_nogc_env env, NAPI_EXTERN napi_status napi_adjust_external_memory(node_api_basic_env env,
int64_t change_in_bytes, int64_t change_in_bytes,
int64_t* result); int64_t* result);
``` ```
@ -6234,7 +6234,7 @@ napiVersion: 2
--> -->
```c ```c
NAPI_EXTERN napi_status napi_get_uv_event_loop(node_api_nogc_env env, NAPI_EXTERN napi_status napi_get_uv_event_loop(node_api_basic_env env,
struct uv_loop_s** loop); struct uv_loop_s** loop);
``` ```
@ -6554,7 +6554,7 @@ napiVersion: 4
```c ```c
NAPI_EXTERN napi_status NAPI_EXTERN napi_status
napi_ref_threadsafe_function(node_api_nogc_env env, napi_threadsafe_function func); napi_ref_threadsafe_function(node_api_basic_env env, napi_threadsafe_function func);
``` ```
* `[in] env`: The environment that the API is invoked under. * `[in] env`: The environment that the API is invoked under.
@ -6580,7 +6580,7 @@ napiVersion: 4
```c ```c
NAPI_EXTERN napi_status NAPI_EXTERN napi_status
napi_unref_threadsafe_function(node_api_nogc_env env, napi_threadsafe_function func); napi_unref_threadsafe_function(node_api_basic_env env, napi_threadsafe_function func);
``` ```
* `[in] env`: The environment that the API is invoked under. * `[in] env`: The environment that the API is invoked under.
@ -6606,7 +6606,7 @@ napiVersion: 9
```c ```c
NAPI_EXTERN napi_status NAPI_EXTERN napi_status
node_api_get_module_file_name(node_api_nogc_env env, const char** result); node_api_get_module_file_name(node_api_basic_env env, const char** result);
``` ```
@ -6731,10 +6731,10 @@ the add-on's file name during loading.
[`napi_wrap`]: #napi_wrap [`napi_wrap`]: #napi_wrap
[`node-addon-api`]: https://github.com/nodejs/node-addon-api [`node-addon-api`]: https://github.com/nodejs/node-addon-api
[`node_api.h`]: https://github.com/nodejs/node/blob/HEAD/src/node_api.h [`node_api.h`]: https://github.com/nodejs/node/blob/HEAD/src/node_api.h
[`node_api_basic_finalize`]: #node_api_basic_finalize
[`node_api_create_external_string_latin1`]: #node_api_create_external_string_latin1 [`node_api_create_external_string_latin1`]: #node_api_create_external_string_latin1
[`node_api_create_external_string_utf16`]: #node_api_create_external_string_utf16 [`node_api_create_external_string_utf16`]: #node_api_create_external_string_utf16
[`node_api_create_syntax_error`]: #node_api_create_syntax_error [`node_api_create_syntax_error`]: #node_api_create_syntax_error
[`node_api_nogc_finalize`]: #node_api_nogc_finalize
[`node_api_post_finalizer`]: #node_api_post_finalizer [`node_api_post_finalizer`]: #node_api_post_finalizer
[`node_api_throw_syntax_error`]: #node_api_throw_syntax_error [`node_api_throw_syntax_error`]: #node_api_throw_syntax_error
[`process.release`]: process.md#processrelease [`process.release`]: process.md#processrelease

51
src/js_native_api.h
View File

@ -50,7 +50,7 @@
EXTERN_C_START EXTERN_C_START
NAPI_EXTERN napi_status NAPI_CDECL napi_get_last_error_info( NAPI_EXTERN napi_status NAPI_CDECL napi_get_last_error_info(
node_api_nogc_env env, const napi_extended_error_info** result); node_api_basic_env env, const napi_extended_error_info** result);
// Getters for defined singletons // Getters for defined singletons
NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env, NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env,
@ -94,19 +94,19 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf16(napi_env env,
napi_value* result); napi_value* result);
#ifdef NAPI_EXPERIMENTAL #ifdef NAPI_EXPERIMENTAL
#define NODE_API_EXPERIMENTAL_HAS_EXTERNAL_STRINGS #define NODE_API_EXPERIMENTAL_HAS_EXTERNAL_STRINGS
NAPI_EXTERN napi_status NAPI_CDECL NAPI_EXTERN napi_status NAPI_CDECL node_api_create_external_string_latin1(
node_api_create_external_string_latin1(napi_env env, napi_env env,
char* str, char* str,
size_t length, size_t length,
node_api_nogc_finalize finalize_callback, node_api_basic_finalize finalize_callback,
void* finalize_hint, void* finalize_hint,
napi_value* result, napi_value* result,
bool* copied); bool* copied);
NAPI_EXTERN napi_status NAPI_CDECL NAPI_EXTERN napi_status NAPI_CDECL
node_api_create_external_string_utf16(napi_env env, node_api_create_external_string_utf16(napi_env env,
char16_t* str, char16_t* str,
size_t length, size_t length,
node_api_nogc_finalize finalize_callback, node_api_basic_finalize finalize_callback,
void* finalize_hint, void* finalize_hint,
napi_value* result, napi_value* result,
bool* copied); bool* copied);
@ -318,12 +318,13 @@ napi_define_class(napi_env env,
napi_value* result); napi_value* result);
// Methods to work with external data objects // Methods to work with external data objects
NAPI_EXTERN napi_status NAPI_CDECL napi_wrap(napi_env env, NAPI_EXTERN napi_status NAPI_CDECL
napi_value js_object, napi_wrap(napi_env env,
void* native_object, napi_value js_object,
node_api_nogc_finalize finalize_cb, void* native_object,
void* finalize_hint, node_api_basic_finalize finalize_cb,
napi_ref* result); void* finalize_hint,
napi_ref* result);
NAPI_EXTERN napi_status NAPI_CDECL napi_unwrap(napi_env env, NAPI_EXTERN napi_status NAPI_CDECL napi_unwrap(napi_env env,
napi_value js_object, napi_value js_object,
void** result); void** result);
@ -333,7 +334,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_remove_wrap(napi_env env,
NAPI_EXTERN napi_status NAPI_CDECL NAPI_EXTERN napi_status NAPI_CDECL
napi_create_external(napi_env env, napi_create_external(napi_env env,
void* data, void* data,
node_api_nogc_finalize finalize_cb, node_api_basic_finalize finalize_cb,
void* finalize_hint, void* finalize_hint,
napi_value* result); napi_value* result);
NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_external(napi_env env, NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_external(napi_env env,
@ -432,7 +433,7 @@ NAPI_EXTERN napi_status NAPI_CDECL
napi_create_external_arraybuffer(napi_env env, napi_create_external_arraybuffer(napi_env env,
void* external_data, void* external_data,
size_t byte_length, size_t byte_length,
node_api_nogc_finalize finalize_cb, node_api_basic_finalize finalize_cb,
void* finalize_hint, void* finalize_hint,
napi_value* result); napi_value* result);
#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED #endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
@ -474,7 +475,7 @@ napi_get_dataview_info(napi_env env,
size_t* byte_offset); size_t* byte_offset);
// version management // version management
NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_nogc_env env, NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env,
uint32_t* result); uint32_t* result);
// Promises // Promises
@ -498,7 +499,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_run_script(napi_env env,
// Memory management // Memory management
NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory( NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory(
node_api_nogc_env env, int64_t change_in_bytes, int64_t* adjusted_value); node_api_basic_env env, int64_t change_in_bytes, int64_t* adjusted_value);
#if NAPI_VERSION >= 5 #if NAPI_VERSION >= 5
@ -520,7 +521,7 @@ NAPI_EXTERN napi_status NAPI_CDECL
napi_add_finalizer(napi_env env, napi_add_finalizer(napi_env env,
napi_value js_object, napi_value js_object,
void* finalize_data, void* finalize_data,
node_api_nogc_finalize finalize_cb, node_api_basic_finalize finalize_cb,
void* finalize_hint, void* finalize_hint,
napi_ref* result); napi_ref* result);
@ -530,7 +531,7 @@ napi_add_finalizer(napi_env env,
#define NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER #define NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER
NAPI_EXTERN napi_status NAPI_CDECL NAPI_EXTERN napi_status NAPI_CDECL
node_api_post_finalizer(node_api_nogc_env env, node_api_post_finalizer(node_api_basic_env env,
napi_finalize finalize_cb, napi_finalize finalize_cb,
void* finalize_data, void* finalize_data,
void* finalize_hint); void* finalize_hint);
@ -575,13 +576,13 @@ napi_get_all_property_names(napi_env env,
// Instance data // Instance data
NAPI_EXTERN napi_status NAPI_CDECL NAPI_EXTERN napi_status NAPI_CDECL
napi_set_instance_data(node_api_nogc_env env, napi_set_instance_data(node_api_basic_env env,
void* data, void* data,
napi_finalize finalize_cb, napi_finalize finalize_cb,
void* finalize_hint); void* finalize_hint);
NAPI_EXTERN napi_status NAPI_CDECL napi_get_instance_data(node_api_nogc_env env, NAPI_EXTERN napi_status NAPI_CDECL
void** data); napi_get_instance_data(node_api_basic_env env, void** data);
#endif // NAPI_VERSION >= 6 #endif // NAPI_VERSION >= 6
#if NAPI_VERSION >= 7 #if NAPI_VERSION >= 7

22
src/js_native_api_types.h
View File

@ -27,7 +27,7 @@ typedef struct napi_env__* napi_env;
// meaning that they do not affect the state of the JS engine, and can // meaning that they do not affect the state of the JS engine, and can
// therefore be called synchronously from a finalizer that itself runs // therefore be called synchronously from a finalizer that itself runs
// synchronously during GC. Such APIs can receive either a `napi_env` or a // synchronously during GC. Such APIs can receive either a `napi_env` or a
// `node_api_nogc_env` as their first parameter, because we should be able to // `node_api_basic_env` as their first parameter, because we should be able to
// also call them during normal, non-garbage-collecting operations, whereas // also call them during normal, non-garbage-collecting operations, whereas
// APIs that affect the state of the JS engine can only receive a `napi_env` as // APIs that affect the state of the JS engine can only receive a `napi_env` as
// their first parameter, because we must not call them during GC. In lieu of // their first parameter, because we must not call them during GC. In lieu of
@ -37,19 +37,21 @@ typedef struct napi_env__* napi_env;
// expecting a non-const value. // expecting a non-const value.
// //
// In conjunction with appropriate CFLAGS to warn us if we're passing a const // In conjunction with appropriate CFLAGS to warn us if we're passing a const
// (nogc) environment into an API that expects a non-const environment, and the // (basic) environment into an API that expects a non-const environment, and
// definition of nogc finalizer function pointer types below, which receive a // the definition of basic finalizer function pointer types below, which
// nogc environment as their first parameter, and can thus only call nogc APIs // receive a basic environment as their first parameter, and can thus only call
// (unless the user explicitly casts the environment), we achieve the ability // basic APIs (unless the user explicitly casts the environment), we achieve
// to ensure at compile time that we do not call APIs that affect the state of // the ability to ensure at compile time that we do not call APIs that affect
// the JS engine from a synchronous (nogc) finalizer. // the state of the JS engine from a synchronous (basic) finalizer.
#if !defined(NAPI_EXPERIMENTAL) || \ #if !defined(NAPI_EXPERIMENTAL) || \
(defined(NAPI_EXPERIMENTAL) && \ (defined(NAPI_EXPERIMENTAL) && \
defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT)) (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) || \
defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))
typedef struct napi_env__* node_api_nogc_env; typedef struct napi_env__* node_api_nogc_env;
#else #else
typedef const struct napi_env__* node_api_nogc_env; typedef const struct napi_env__* node_api_nogc_env;
#endif #endif
typedef node_api_nogc_env node_api_basic_env;
typedef struct napi_value__* napi_value; typedef struct napi_value__* napi_value;
typedef struct napi_ref__* napi_ref; typedef struct napi_ref__* napi_ref;
@ -147,13 +149,15 @@ typedef void(NAPI_CDECL* napi_finalize)(napi_env env,
#if !defined(NAPI_EXPERIMENTAL) || \ #if !defined(NAPI_EXPERIMENTAL) || \
(defined(NAPI_EXPERIMENTAL) && \ (defined(NAPI_EXPERIMENTAL) && \
defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT)) (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) || \
defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))
typedef napi_finalize node_api_nogc_finalize; typedef napi_finalize node_api_nogc_finalize;
#else #else
typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env, typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env,
void* finalize_data, void* finalize_data,
void* finalize_hint); void* finalize_hint);
#endif #endif
typedef node_api_nogc_finalize node_api_basic_finalize;
typedef struct { typedef struct {
// One of utf8name or name should be NULL. // One of utf8name or name should be NULL.

43
src/js_native_api_v8.cc
View File

@ -909,8 +909,8 @@ static const char* error_messages[] = {
}; };
napi_status NAPI_CDECL napi_get_last_error_info( napi_status NAPI_CDECL napi_get_last_error_info(
node_api_nogc_env nogc_env, const napi_extended_error_info** result) { node_api_basic_env basic_env, const napi_extended_error_info** result) {
napi_env env = const_cast<napi_env>(nogc_env); napi_env env = const_cast<napi_env>(basic_env);
CHECK_ENV(env); CHECK_ENV(env);
CHECK_ARG(env, result); CHECK_ARG(env, result);
@ -1652,12 +1652,12 @@ napi_status NAPI_CDECL node_api_create_external_string_latin1(
napi_env env, napi_env env,
char* str, char* str,
size_t length, size_t length,
node_api_nogc_finalize nogc_finalize_callback, node_api_basic_finalize basic_finalize_callback,
void* finalize_hint, void* finalize_hint,
napi_value* result, napi_value* result,
bool* copied) { bool* copied) {
napi_finalize finalize_callback = napi_finalize finalize_callback =
reinterpret_cast<napi_finalize>(nogc_finalize_callback); reinterpret_cast<napi_finalize>(basic_finalize_callback);
return v8impl::NewExternalString( return v8impl::NewExternalString(
env, env,
str, str,
@ -1681,12 +1681,12 @@ napi_status NAPI_CDECL node_api_create_external_string_utf16(
napi_env env, napi_env env,
char16_t* str, char16_t* str,
size_t length, size_t length,
node_api_nogc_finalize nogc_finalize_callback, node_api_basic_finalize basic_finalize_callback,
void* finalize_hint, void* finalize_hint,
napi_value* result, napi_value* result,
bool* copied) { bool* copied) {
napi_finalize finalize_callback = napi_finalize finalize_callback =
reinterpret_cast<napi_finalize>(nogc_finalize_callback); reinterpret_cast<napi_finalize>(basic_finalize_callback);
return v8impl::NewExternalString( return v8impl::NewExternalString(
env, env,
str, str,
@ -2560,10 +2560,11 @@ GEN_COERCE_FUNCTION(STRING, String, string)
napi_status NAPI_CDECL napi_wrap(napi_env env, napi_status NAPI_CDECL napi_wrap(napi_env env,
napi_value js_object, napi_value js_object,
void* native_object, void* native_object,
node_api_nogc_finalize nogc_finalize_cb, node_api_basic_finalize basic_finalize_cb,
void* finalize_hint, void* finalize_hint,
napi_ref* result) { napi_ref* result) {
napi_finalize finalize_cb = reinterpret_cast<napi_finalize>(nogc_finalize_cb); napi_finalize finalize_cb =
reinterpret_cast<napi_finalize>(basic_finalize_cb);
return v8impl::Wrap( return v8impl::Wrap(
env, js_object, native_object, finalize_cb, finalize_hint, result); env, js_object, native_object, finalize_cb, finalize_hint, result);
} }
@ -2583,10 +2584,11 @@ napi_status NAPI_CDECL napi_remove_wrap(napi_env env,
napi_status NAPI_CDECL napi_status NAPI_CDECL
napi_create_external(napi_env env, napi_create_external(napi_env env,
void* data, void* data,
node_api_nogc_finalize nogc_finalize_cb, node_api_basic_finalize basic_finalize_cb,
void* finalize_hint, void* finalize_hint,
napi_value* result) { napi_value* result) {
napi_finalize finalize_cb = reinterpret_cast<napi_finalize>(nogc_finalize_cb); napi_finalize finalize_cb =
reinterpret_cast<napi_finalize>(basic_finalize_cb);
NAPI_PREAMBLE(env); NAPI_PREAMBLE(env);
CHECK_ARG(env, result); CHECK_ARG(env, result);
@ -3027,7 +3029,7 @@ napi_status NAPI_CDECL
napi_create_external_arraybuffer(napi_env env, napi_create_external_arraybuffer(napi_env env,
void* external_data, void* external_data,
size_t byte_length, size_t byte_length,
node_api_nogc_finalize finalize_cb, node_api_basic_finalize finalize_cb,
void* finalize_hint, void* finalize_hint,
napi_value* result) { napi_value* result) {
// The API contract here is that the cleanup function runs on the JS thread, // The API contract here is that the cleanup function runs on the JS thread,
@ -3292,7 +3294,7 @@ napi_status NAPI_CDECL napi_get_dataview_info(napi_env env,
return napi_clear_last_error(env); return napi_clear_last_error(env);
} }
napi_status NAPI_CDECL napi_get_version(node_api_nogc_env env, napi_status NAPI_CDECL napi_get_version(node_api_basic_env env,
uint32_t* result) { uint32_t* result) {
CHECK_ENV(env); CHECK_ENV(env);
CHECK_ARG(env, result); CHECK_ARG(env, result);
@ -3414,12 +3416,13 @@ napi_status NAPI_CDECL
napi_add_finalizer(napi_env env, napi_add_finalizer(napi_env env,
napi_value js_object, napi_value js_object,
void* finalize_data, void* finalize_data,
node_api_nogc_finalize nogc_finalize_cb, node_api_basic_finalize basic_finalize_cb,
void* finalize_hint, void* finalize_hint,
napi_ref* result) { napi_ref* result) {
// Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
// JS exceptions. // JS exceptions.
napi_finalize finalize_cb = reinterpret_cast<napi_finalize>(nogc_finalize_cb); napi_finalize finalize_cb =
reinterpret_cast<napi_finalize>(basic_finalize_cb);
CHECK_ENV_NOT_IN_GC(env); CHECK_ENV_NOT_IN_GC(env);
CHECK_ARG(env, js_object); CHECK_ARG(env, js_object);
CHECK_ARG(env, finalize_cb); CHECK_ARG(env, finalize_cb);
@ -3443,11 +3446,11 @@ napi_add_finalizer(napi_env env,
#ifdef NAPI_EXPERIMENTAL #ifdef NAPI_EXPERIMENTAL
napi_status NAPI_CDECL node_api_post_finalizer(node_api_nogc_env nogc_env, napi_status NAPI_CDECL node_api_post_finalizer(node_api_basic_env basic_env,
napi_finalize finalize_cb, napi_finalize finalize_cb,
void* finalize_data, void* finalize_data,
void* finalize_hint) { void* finalize_hint) {
napi_env env = const_cast<napi_env>(nogc_env); napi_env env = const_cast<napi_env>(basic_env);
CHECK_ENV(env); CHECK_ENV(env);
env->EnqueueFinalizer(v8impl::TrackedFinalizer::New( env->EnqueueFinalizer(v8impl::TrackedFinalizer::New(
env, finalize_cb, finalize_data, finalize_hint)); env, finalize_cb, finalize_data, finalize_hint));
@ -3456,7 +3459,7 @@ napi_status NAPI_CDECL node_api_post_finalizer(node_api_nogc_env nogc_env,
#endif #endif
napi_status NAPI_CDECL napi_adjust_external_memory(node_api_nogc_env env, napi_status NAPI_CDECL napi_adjust_external_memory(node_api_basic_env env,
int64_t change_in_bytes, int64_t change_in_bytes,
int64_t* adjusted_value) { int64_t* adjusted_value) {
CHECK_ENV(env); CHECK_ENV(env);
@ -3468,11 +3471,11 @@ napi_status NAPI_CDECL napi_adjust_external_memory(node_api_nogc_env env,
return napi_clear_last_error(env); return napi_clear_last_error(env);
} }
napi_status NAPI_CDECL napi_set_instance_data(node_api_nogc_env nogc_env, napi_status NAPI_CDECL napi_set_instance_data(node_api_basic_env basic_env,
void* data, void* data,
napi_finalize finalize_cb, napi_finalize finalize_cb,
void* finalize_hint) { void* finalize_hint) {
napi_env env = const_cast<napi_env>(nogc_env); napi_env env = const_cast<napi_env>(basic_env);
CHECK_ENV(env); CHECK_ENV(env);
v8impl::RefBase* old_data = static_cast<v8impl::RefBase*>(env->instance_data); v8impl::RefBase* old_data = static_cast<v8impl::RefBase*>(env->instance_data);
@ -3488,7 +3491,7 @@ napi_status NAPI_CDECL napi_set_instance_data(node_api_nogc_env nogc_env,
return napi_clear_last_error(env); return napi_clear_last_error(env);
} }
napi_status NAPI_CDECL napi_get_instance_data(node_api_nogc_env env, napi_status NAPI_CDECL napi_get_instance_data(node_api_basic_env env,
void** data) { void** data) {
CHECK_ENV(env); CHECK_ENV(env);
CHECK_ARG(env, data); CHECK_ARG(env, data);

10
src/js_native_api_v8.h
View File

@ -4,7 +4,7 @@
#include "js_native_api_types.h" #include "js_native_api_types.h"
#include "js_native_api_v8_internals.h" #include "js_native_api_v8_internals.h"
inline napi_status napi_clear_last_error(node_api_nogc_env env); inline napi_status napi_clear_last_error(node_api_basic_env env);
namespace v8impl { namespace v8impl {
@ -172,8 +172,8 @@ struct napi_env__ {
virtual ~napi_env__() = default; virtual ~napi_env__() = default;
}; };
inline napi_status napi_clear_last_error(node_api_nogc_env nogc_env) { inline napi_status napi_clear_last_error(node_api_basic_env basic_env) {
napi_env env = const_cast<napi_env>(nogc_env); napi_env env = const_cast<napi_env>(basic_env);
env->last_error.error_code = napi_ok; env->last_error.error_code = napi_ok;
env->last_error.engine_error_code = 0; env->last_error.engine_error_code = 0;
env->last_error.engine_reserved = nullptr; env->last_error.engine_reserved = nullptr;
@ -181,11 +181,11 @@ inline napi_status napi_clear_last_error(node_api_nogc_env nogc_env) {
return napi_ok; return napi_ok;
} }
inline napi_status napi_set_last_error(node_api_nogc_env nogc_env, inline napi_status napi_set_last_error(node_api_basic_env basic_env,
napi_status error_code, napi_status error_code,
uint32_t engine_error_code = 0, uint32_t engine_error_code = 0,
void* engine_reserved = nullptr) { void* engine_reserved = nullptr) {
napi_env env = const_cast<napi_env>(nogc_env); napi_env env = const_cast<napi_env>(basic_env);
env->last_error.error_code = error_code; env->last_error.error_code = error_code;
env->last_error.engine_error_code = engine_error_code; env->last_error.engine_error_code = engine_error_code;
env->last_error.engine_reserved = engine_reserved; env->last_error.engine_reserved = engine_reserved;

33
src/node_api.cc
View File

@ -765,7 +765,7 @@ void NAPI_CDECL napi_module_register(napi_module* mod) {
node::node_module_register(nm); node::node_module_register(nm);
} }
napi_status NAPI_CDECL napi_add_env_cleanup_hook(node_api_nogc_env env, napi_status NAPI_CDECL napi_add_env_cleanup_hook(node_api_basic_env env,
napi_cleanup_hook fun, napi_cleanup_hook fun,
void* arg) { void* arg) {
CHECK_ENV(env); CHECK_ENV(env);
@ -776,7 +776,7 @@ napi_status NAPI_CDECL napi_add_env_cleanup_hook(node_api_nogc_env env,
return napi_ok; return napi_ok;
} }
napi_status NAPI_CDECL napi_remove_env_cleanup_hook(node_api_nogc_env env, napi_status NAPI_CDECL napi_remove_env_cleanup_hook(node_api_basic_env env,
napi_cleanup_hook fun, napi_cleanup_hook fun,
void* arg) { void* arg) {
CHECK_ENV(env); CHECK_ENV(env);
@ -823,11 +823,11 @@ struct napi_async_cleanup_hook_handle__ {
}; };
napi_status NAPI_CDECL napi_status NAPI_CDECL
napi_add_async_cleanup_hook(node_api_nogc_env nogc_env, napi_add_async_cleanup_hook(node_api_basic_env basic_env,
napi_async_cleanup_hook hook, napi_async_cleanup_hook hook,
void* arg, void* arg,
napi_async_cleanup_hook_handle* remove_handle) { napi_async_cleanup_hook_handle* remove_handle) {
napi_env env = const_cast<napi_env>(nogc_env); napi_env env = const_cast<napi_env>(basic_env);
CHECK_ENV(env); CHECK_ENV(env);
CHECK_ARG(env, hook); CHECK_ARG(env, hook);
@ -1042,10 +1042,11 @@ napi_status NAPI_CDECL
napi_create_external_buffer(napi_env env, napi_create_external_buffer(napi_env env,
size_t length, size_t length,
void* data, void* data,
node_api_nogc_finalize nogc_finalize_cb, node_api_basic_finalize basic_finalize_cb,
void* finalize_hint, void* finalize_hint,
napi_value* result) { napi_value* result) {
napi_finalize finalize_cb = reinterpret_cast<napi_finalize>(nogc_finalize_cb); napi_finalize finalize_cb =
reinterpret_cast<napi_finalize>(basic_finalize_cb);
NAPI_PREAMBLE(env); NAPI_PREAMBLE(env);
CHECK_ARG(env, result); CHECK_ARG(env, result);
@ -1131,7 +1132,7 @@ napi_status NAPI_CDECL napi_get_buffer_info(napi_env env,
return napi_clear_last_error(env); return napi_clear_last_error(env);
} }
napi_status NAPI_CDECL napi_get_node_version(node_api_nogc_env env, napi_status NAPI_CDECL napi_get_node_version(node_api_basic_env env,
const napi_node_version** result) { const napi_node_version** result) {
CHECK_ENV(env); CHECK_ENV(env);
CHECK_ARG(env, result); CHECK_ARG(env, result);
@ -1275,16 +1276,16 @@ napi_status NAPI_CDECL napi_delete_async_work(napi_env env,
return napi_clear_last_error(env); return napi_clear_last_error(env);
} }
napi_status NAPI_CDECL napi_get_uv_event_loop(node_api_nogc_env nogc_env, napi_status NAPI_CDECL napi_get_uv_event_loop(node_api_basic_env basic_env,
uv_loop_t** loop) { uv_loop_t** loop) {
napi_env env = const_cast<napi_env>(nogc_env); napi_env env = const_cast<napi_env>(basic_env);
CHECK_ENV(env); CHECK_ENV(env);
CHECK_ARG(env, loop); CHECK_ARG(env, loop);
*loop = reinterpret_cast<node_napi_env>(env)->node_env()->event_loop(); *loop = reinterpret_cast<node_napi_env>(env)->node_env()->event_loop();
return napi_clear_last_error(env); return napi_clear_last_error(env);
} }
napi_status NAPI_CDECL napi_queue_async_work(node_api_nogc_env env, napi_status NAPI_CDECL napi_queue_async_work(node_api_basic_env env,
napi_async_work work) { napi_async_work work) {
CHECK_ENV(env); CHECK_ENV(env);
CHECK_ARG(env, work); CHECK_ARG(env, work);
@ -1299,7 +1300,7 @@ napi_status NAPI_CDECL napi_queue_async_work(node_api_nogc_env env,
return napi_clear_last_error(env); return napi_clear_last_error(env);
} }
napi_status NAPI_CDECL napi_cancel_async_work(node_api_nogc_env env, napi_status NAPI_CDECL napi_cancel_async_work(node_api_basic_env env,
napi_async_work work) { napi_async_work work) {
CHECK_ENV(env); CHECK_ENV(env);
CHECK_ARG(env, work); CHECK_ARG(env, work);
@ -1405,20 +1406,20 @@ napi_status NAPI_CDECL napi_release_threadsafe_function(
} }
napi_status NAPI_CDECL napi_unref_threadsafe_function( napi_status NAPI_CDECL napi_unref_threadsafe_function(
node_api_nogc_env env, napi_threadsafe_function func) { node_api_basic_env env, napi_threadsafe_function func) {
CHECK_NOT_NULL(func); CHECK_NOT_NULL(func);
return reinterpret_cast<v8impl::ThreadSafeFunction*>(func)->Unref(); return reinterpret_cast<v8impl::ThreadSafeFunction*>(func)->Unref();
} }
napi_status NAPI_CDECL napi_ref_threadsafe_function( napi_status NAPI_CDECL napi_ref_threadsafe_function(
node_api_nogc_env env, napi_threadsafe_function func) { node_api_basic_env env, napi_threadsafe_function func) {
CHECK_NOT_NULL(func); CHECK_NOT_NULL(func);
return reinterpret_cast<v8impl::ThreadSafeFunction*>(func)->Ref(); return reinterpret_cast<v8impl::ThreadSafeFunction*>(func)->Ref();
} }
napi_status NAPI_CDECL node_api_get_module_file_name(node_api_nogc_env nogc_env, napi_status NAPI_CDECL node_api_get_module_file_name(
const char** result) { node_api_basic_env basic_env, const char** result) {
napi_env env = const_cast<napi_env>(nogc_env); napi_env env = const_cast<napi_env>(basic_env);
CHECK_ENV(env); CHECK_ENV(env);
CHECK_ARG(env, result); CHECK_ARG(env, result);

26
src/node_api.h
View File

@ -131,7 +131,7 @@ NAPI_EXTERN napi_status NAPI_CDECL
napi_create_external_buffer(napi_env env, napi_create_external_buffer(napi_env env,
size_t length, size_t length,
void* data, void* data,
node_api_nogc_finalize finalize_cb, node_api_basic_finalize finalize_cb,
void* finalize_hint, void* finalize_hint,
napi_value* result); napi_value* result);
#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED #endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
@ -159,20 +159,20 @@ napi_create_async_work(napi_env env,
napi_async_work* result); napi_async_work* result);
NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(napi_env env, NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(napi_env env,
napi_async_work work); napi_async_work work);
NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(node_api_nogc_env env, NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(node_api_basic_env env,
napi_async_work work); napi_async_work work);
NAPI_EXTERN napi_status NAPI_CDECL napi_cancel_async_work(node_api_nogc_env env, NAPI_EXTERN napi_status NAPI_CDECL
napi_async_work work); napi_cancel_async_work(node_api_basic_env env, napi_async_work work);
// version management // version management
NAPI_EXTERN napi_status NAPI_CDECL NAPI_EXTERN napi_status NAPI_CDECL napi_get_node_version(
napi_get_node_version(node_api_nogc_env env, const napi_node_version** version); node_api_basic_env env, const napi_node_version** version);
#if NAPI_VERSION >= 2 #if NAPI_VERSION >= 2
// Return the current libuv event loop for a given environment // Return the current libuv event loop for a given environment
NAPI_EXTERN napi_status NAPI_CDECL NAPI_EXTERN napi_status NAPI_CDECL
napi_get_uv_event_loop(node_api_nogc_env env, struct uv_loop_s** loop); napi_get_uv_event_loop(node_api_basic_env env, struct uv_loop_s** loop);
#endif // NAPI_VERSION >= 2 #endif // NAPI_VERSION >= 2
@ -182,10 +182,10 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_fatal_exception(napi_env env,
napi_value err); napi_value err);
NAPI_EXTERN napi_status NAPI_CDECL napi_add_env_cleanup_hook( NAPI_EXTERN napi_status NAPI_CDECL napi_add_env_cleanup_hook(
node_api_nogc_env env, napi_cleanup_hook fun, void* arg); node_api_basic_env env, napi_cleanup_hook fun, void* arg);
NAPI_EXTERN napi_status NAPI_CDECL napi_remove_env_cleanup_hook( NAPI_EXTERN napi_status NAPI_CDECL napi_remove_env_cleanup_hook(
node_api_nogc_env env, napi_cleanup_hook fun, void* arg); node_api_basic_env env, napi_cleanup_hook fun, void* arg);
NAPI_EXTERN napi_status NAPI_CDECL NAPI_EXTERN napi_status NAPI_CDECL
napi_open_callback_scope(napi_env env, napi_open_callback_scope(napi_env env,
@ -229,17 +229,17 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_release_threadsafe_function(
napi_threadsafe_function func, napi_threadsafe_function_release_mode mode); napi_threadsafe_function func, napi_threadsafe_function_release_mode mode);
NAPI_EXTERN napi_status NAPI_CDECL napi_unref_threadsafe_function( NAPI_EXTERN napi_status NAPI_CDECL napi_unref_threadsafe_function(
node_api_nogc_env env, napi_threadsafe_function func); node_api_basic_env env, napi_threadsafe_function func);
NAPI_EXTERN napi_status NAPI_CDECL napi_ref_threadsafe_function( NAPI_EXTERN napi_status NAPI_CDECL napi_ref_threadsafe_function(
node_api_nogc_env env, napi_threadsafe_function func); node_api_basic_env env, napi_threadsafe_function func);
#endif // NAPI_VERSION >= 4 #endif // NAPI_VERSION >= 4
#if NAPI_VERSION >= 8 #if NAPI_VERSION >= 8
NAPI_EXTERN napi_status NAPI_CDECL NAPI_EXTERN napi_status NAPI_CDECL
napi_add_async_cleanup_hook(node_api_nogc_env env, napi_add_async_cleanup_hook(node_api_basic_env env,
napi_async_cleanup_hook hook, napi_async_cleanup_hook hook,
void* arg, void* arg,
napi_async_cleanup_hook_handle* remove_handle); napi_async_cleanup_hook_handle* remove_handle);
@ -252,7 +252,7 @@ napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle);
#if NAPI_VERSION >= 9 #if NAPI_VERSION >= 9
NAPI_EXTERN napi_status NAPI_CDECL NAPI_EXTERN napi_status NAPI_CDECL
node_api_get_module_file_name(node_api_nogc_env env, const char** result); node_api_get_module_file_name(node_api_basic_env env, const char** result);
#endif // NAPI_VERSION >= 9 #endif // NAPI_VERSION >= 9

14
test/js-native-api/common.h
View File

@ -23,7 +23,7 @@
} \ } \
} while (0) } while (0)
// The nogc version of GET_AND_THROW_LAST_ERROR. We cannot access any // The basic version of GET_AND_THROW_LAST_ERROR. We cannot access any
// exceptions and we cannot fail by way of JS exception, so we abort. // exceptions and we cannot fail by way of JS exception, so we abort.
#define FATALLY_FAIL_WITH_LAST_ERROR(env) \ #define FATALLY_FAIL_WITH_LAST_ERROR(env) \
do { \ do { \
@ -47,7 +47,7 @@
} \ } \
} while (0) } while (0)
#define NODE_API_NOGC_ASSERT_BASE(assertion, message, ret_val) \ #define NODE_API_BASIC_ASSERT_BASE(assertion, message, ret_val) \
do { \ do { \
if (!(assertion)) { \ if (!(assertion)) { \
fprintf(stderr, "assertion (" #assertion ") failed: " message); \ fprintf(stderr, "assertion (" #assertion ") failed: " message); \
@ -66,8 +66,8 @@
#define NODE_API_ASSERT_RETURN_VOID(env, assertion, message) \ #define NODE_API_ASSERT_RETURN_VOID(env, assertion, message) \
NODE_API_ASSERT_BASE(env, assertion, message, NODE_API_RETVAL_NOTHING) NODE_API_ASSERT_BASE(env, assertion, message, NODE_API_RETVAL_NOTHING)
#define NODE_API_NOGC_ASSERT_RETURN_VOID(assertion, message) \ #define NODE_API_BASIC_ASSERT_RETURN_VOID(assertion, message) \
NODE_API_NOGC_ASSERT_BASE(assertion, message, NODE_API_RETVAL_NOTHING) NODE_API_BASIC_ASSERT_BASE(assertion, message, NODE_API_RETVAL_NOTHING)
#define NODE_API_CALL_BASE(env, the_call, ret_val) \ #define NODE_API_CALL_BASE(env, the_call, ret_val) \
do { \ do { \
@ -77,7 +77,7 @@
} \ } \
} while (0) } while (0)
#define NODE_API_NOGC_CALL_BASE(env, the_call, ret_val) \ #define NODE_API_BASIC_CALL_BASE(env, the_call, ret_val) \
do { \ do { \
if ((the_call) != napi_ok) { \ if ((the_call) != napi_ok) { \
FATALLY_FAIL_WITH_LAST_ERROR((env)); \ FATALLY_FAIL_WITH_LAST_ERROR((env)); \
@ -93,8 +93,8 @@
#define NODE_API_CALL_RETURN_VOID(env, the_call) \ #define NODE_API_CALL_RETURN_VOID(env, the_call) \
NODE_API_CALL_BASE(env, the_call, NODE_API_RETVAL_NOTHING) NODE_API_CALL_BASE(env, the_call, NODE_API_RETVAL_NOTHING)
#define NODE_API_NOGC_CALL_RETURN_VOID(env, the_call) \ #define NODE_API_BASIC_CALL_RETURN_VOID(env, the_call) \
NODE_API_NOGC_CALL_BASE(env, the_call, NODE_API_RETVAL_NOTHING) NODE_API_BASIC_CALL_BASE(env, the_call, NODE_API_RETVAL_NOTHING)
#define NODE_API_CHECK_STATUS(the_call) \ #define NODE_API_CHECK_STATUS(the_call) \
do { \ do { \

15
test/js-native-api/test_cannot_run_js/test_cannot_run_js.c
View File

@ -7,10 +7,10 @@ static void Finalize(napi_env env, void* data, void* hint) {
napi_value global, set_timeout; napi_value global, set_timeout;
napi_ref* ref = data; napi_ref* ref = data;
NODE_API_NOGC_ASSERT_RETURN_VOID( NODE_API_BASIC_ASSERT_RETURN_VOID(
napi_delete_reference(env, *ref) == napi_ok, napi_delete_reference(env, *ref) == napi_ok,
"deleting reference in finalizer should succeed"); "deleting reference in finalizer should succeed");
NODE_API_NOGC_ASSERT_RETURN_VOID( NODE_API_BASIC_ASSERT_RETURN_VOID(
napi_get_global(env, &global) == napi_ok, napi_get_global(env, &global) == napi_ok,
"getting global reference in finalizer should succeed"); "getting global reference in finalizer should succeed");
napi_status result = napi_status result =
@ -23,12 +23,12 @@ static void Finalize(napi_env env, void* data, void* hint) {
// the point of view of the addon. // the point of view of the addon.
#ifdef NAPI_EXPERIMENTAL #ifdef NAPI_EXPERIMENTAL
NODE_API_NOGC_ASSERT_RETURN_VOID( NODE_API_BASIC_ASSERT_RETURN_VOID(
result == napi_cannot_run_js || result == napi_ok, result == napi_cannot_run_js || result == napi_ok,
"getting named property from global in finalizer should succeed " "getting named property from global in finalizer should succeed "
"or return napi_cannot_run_js"); "or return napi_cannot_run_js");
#else #else
NODE_API_NOGC_ASSERT_RETURN_VOID( NODE_API_BASIC_ASSERT_RETURN_VOID(
result == napi_pending_exception || result == napi_ok, result == napi_pending_exception || result == napi_ok,
"getting named property from global in finalizer should succeed " "getting named property from global in finalizer should succeed "
"or return napi_pending_exception"); "or return napi_pending_exception");
@ -36,9 +36,9 @@ static void Finalize(napi_env env, void* data, void* hint) {
free(ref); free(ref);
} }
static void NogcFinalize(node_api_nogc_env env, void* data, void* hint) { static void BasicFinalize(node_api_basic_env env, void* data, void* hint) {
#ifdef NAPI_EXPERIMENTAL #ifdef NAPI_EXPERIMENTAL
NODE_API_NOGC_CALL_RETURN_VOID( NODE_API_BASIC_CALL_RETURN_VOID(
env, node_api_post_finalizer(env, Finalize, data, hint)); env, node_api_post_finalizer(env, Finalize, data, hint));
#else #else
Finalize(env, data, hint); Finalize(env, data, hint);
@ -55,7 +55,8 @@ static napi_value CreateRef(napi_env env, napi_callback_info info) {
NODE_API_CALL(env, napi_typeof(env, cb, &value_type)); NODE_API_CALL(env, napi_typeof(env, cb, &value_type));
NODE_API_ASSERT( NODE_API_ASSERT(
env, value_type == napi_function, "argument must be function"); env, value_type == napi_function, "argument must be function");
NODE_API_CALL(env, napi_add_finalizer(env, cb, ref, NogcFinalize, NULL, ref)); NODE_API_CALL(env,
napi_add_finalizer(env, cb, ref, BasicFinalize, NULL, ref));
return cb; return cb;
} }

18
test/js-native-api/test_finalizer/test_finalizer.c
View File

@ -11,17 +11,17 @@ typedef struct {
napi_ref js_func; napi_ref js_func;
} FinalizerData; } FinalizerData;
static void finalizerOnlyCallback(node_api_nogc_env env, static void finalizerOnlyCallback(node_api_basic_env env,
void* finalize_data, void* finalize_data,
void* finalize_hint) { void* finalize_hint) {
FinalizerData* data = (FinalizerData*)finalize_data; FinalizerData* data = (FinalizerData*)finalize_data;
int32_t count = ++data->finalize_count; int32_t count = ++data->finalize_count;
// It is safe to access instance data // It is safe to access instance data
NODE_API_NOGC_CALL_RETURN_VOID(env, NODE_API_BASIC_CALL_RETURN_VOID(env,
napi_get_instance_data(env, (void**)&data)); napi_get_instance_data(env, (void**)&data));
NODE_API_NOGC_ASSERT_RETURN_VOID(count = data->finalize_count, NODE_API_BASIC_ASSERT_RETURN_VOID(count = data->finalize_count,
"Expected to be the same FinalizerData"); "Expected to be the same FinalizerData");
} }
static void finalizerCallingJSCallback(napi_env env, static void finalizerCallingJSCallback(napi_env env,
@ -40,20 +40,20 @@ static void finalizerCallingJSCallback(napi_env env,
} }
// Schedule async finalizer to run JavaScript-touching code. // Schedule async finalizer to run JavaScript-touching code.
static void finalizerWithJSCallback(node_api_nogc_env env, static void finalizerWithJSCallback(node_api_basic_env env,
void* finalize_data, void* finalize_data,
void* finalize_hint) { void* finalize_hint) {
NODE_API_NOGC_CALL_RETURN_VOID( NODE_API_BASIC_CALL_RETURN_VOID(
env, env,
node_api_post_finalizer( node_api_post_finalizer(
env, finalizerCallingJSCallback, finalize_data, finalize_hint)); env, finalizerCallingJSCallback, finalize_data, finalize_hint));
} }
static void finalizerWithFailedJSCallback(node_api_nogc_env nogc_env, static void finalizerWithFailedJSCallback(node_api_basic_env basic_env,
void* finalize_data, void* finalize_data,
void* finalize_hint) { void* finalize_hint) {
// Intentionally cast to a napi_env to test the fatal failure. // Intentionally cast to a napi_env to test the fatal failure.
napi_env env = (napi_env)nogc_env; napi_env env = (napi_env)basic_env;
napi_value obj; napi_value obj;
FinalizerData* data = (FinalizerData*)finalize_data; FinalizerData* data = (FinalizerData*)finalize_data;
++data->finalize_count; ++data->finalize_count;

2
test/js-native-api/test_string/test_string.c
View File

@ -87,7 +87,7 @@ static napi_value TestTwoByteImpl(napi_env env,
return output; return output;
} }
static void free_string(node_api_nogc_env env, void* data, void* hint) { static void free_string(node_api_basic_env env, void* data, void* hint) {
free(data); free(data);
} }

6
test/node-api/test_reference_by_node_api_version/test_reference_by_node_api_version.c
View File

@ -4,12 +4,12 @@
static uint32_t finalizeCount = 0; static uint32_t finalizeCount = 0;
static void FreeData(node_api_nogc_env env, void* data, void* hint) { static void FreeData(node_api_basic_env env, void* data, void* hint) {
NODE_API_NOGC_ASSERT_RETURN_VOID(data != NULL, "Expects non-NULL data."); NODE_API_BASIC_ASSERT_RETURN_VOID(data != NULL, "Expects non-NULL data.");
free(data); free(data);
} }
static void Finalize(node_api_nogc_env env, void* data, void* hint) { static void Finalize(node_api_basic_env env, void* data, void* hint) {
++finalizeCount; ++finalizeCount;
} }