EIC code displayed by LXR master/​include/​node/​js_native_api_types.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-02-21 10:05:22

 #ifndef SRC_JS_NATIVE_API_TYPES_H_
 #define SRC_JS_NATIVE_API_TYPES_H_
 
 // This file needs to be compatible with C compilers.
 // This is a public include file, and these includes have essentially
 // became part of it's API.
 #include <stddef.h>  // NOLINT(modernize-deprecated-headers)
 #include <stdint.h>  // NOLINT(modernize-deprecated-headers)
 
 #if !defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900)
 typedef uint16_t char16_t;
 #endif
 
 #ifndef NAPI_CDECL
 #ifdef _WIN32
 #define NAPI_CDECL __cdecl
 #else
 #define NAPI_CDECL
 #endif
 #endif
 
 // JSVM API types are all opaque pointers for ABI stability
 // typedef undefined structs instead of void* for compile time type safety
 typedef struct napi_env__* napi_env;
 
 // We need to mark APIs which can be called during garbage collection (GC),
 // meaning that they do not affect the state of the JS engine, and can
 // therefore be called synchronously from a finalizer that itself runs
 // 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
 // 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
 // their first parameter, because we must not call them during GC. In lieu of
 // inheritance, we use the properties of the const qualifier to accomplish
 // this, because both a const and a non-const value can be passed to an API
 // expecting a const value, but only a non-const value can be passed to an API
 // expecting a non-const value.
 //
 // 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
 // definition of nogc finalizer function pointer types below, which receive a
 // nogc environment as their first parameter, and can thus only call nogc APIs
 // (unless the user explicitly casts the environment), we achieve the ability
 // to ensure at compile time that we do not call APIs that affect the state of
 // the JS engine from a synchronous (nogc) finalizer.
 #if !defined(NAPI_EXPERIMENTAL) ||                                             \
     (defined(NAPI_EXPERIMENTAL) &&                                             \
      defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT))
 typedef struct napi_env__* node_api_nogc_env;
 #else
 typedef const struct napi_env__* node_api_nogc_env;
 #endif
 
 typedef struct napi_value__* napi_value;
 typedef struct napi_ref__* napi_ref;
 typedef struct napi_handle_scope__* napi_handle_scope;
 typedef struct napi_escapable_handle_scope__* napi_escapable_handle_scope;
 typedef struct napi_callback_info__* napi_callback_info;
 typedef struct napi_deferred__* napi_deferred;
 
 typedef enum {
   napi_default = 0,
   napi_writable = 1 << 0,
   napi_enumerable = 1 << 1,
   napi_configurable = 1 << 2,
 
   // Used with napi_define_class to distinguish static properties
   // from instance properties. Ignored by napi_define_properties.
   napi_static = 1 << 10,
 
 #if NAPI_VERSION >= 8
   // Default for class methods.
   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,
 #endif  // NAPI_VERSION >= 8
 } napi_property_attributes;
 
 typedef enum {
   // ES6 types (corresponds to typeof)
   napi_undefined,
   napi_null,
   napi_boolean,
   napi_number,
   napi_string,
   napi_symbol,
   napi_object,
   napi_function,
   napi_external,
   napi_bigint,
 } napi_valuetype;
 
 typedef enum {
   napi_int8_array,
   napi_uint8_array,
   napi_uint8_clamped_array,
   napi_int16_array,
   napi_uint16_array,
   napi_int32_array,
   napi_uint32_array,
   napi_float32_array,
   napi_float64_array,
   napi_bigint64_array,
   napi_biguint64_array,
 } napi_typedarray_type;
 
 typedef enum {
   napi_ok,
   napi_invalid_arg,
   napi_object_expected,
   napi_string_expected,
   napi_name_expected,
   napi_function_expected,
   napi_number_expected,
   napi_boolean_expected,
   napi_array_expected,
   napi_generic_failure,
   napi_pending_exception,
   napi_cancelled,
   napi_escape_called_twice,
   napi_handle_scope_mismatch,
   napi_callback_scope_mismatch,
   napi_queue_full,
   napi_closing,
   napi_bigint_expected,
   napi_date_expected,
   napi_arraybuffer_expected,
   napi_detachable_arraybuffer_expected,
   napi_would_deadlock,  // unused
   napi_no_external_buffers_allowed,
   napi_cannot_run_js,
 } napi_status;
 // Note: when adding a new enum value to `napi_status`, please also update
 //   * `const int last_status` in the definition of `napi_get_last_error_info()'
 //     in file js_native_api_v8.cc.
 //   * `const char* error_messages[]` in file js_native_api_v8.cc with a brief
 //     message explaining the error.
 //   * the definition of `napi_status` in doc/api/n-api.md to reflect the newly
 //     added value(s).
 
 typedef napi_value(NAPI_CDECL* napi_callback)(napi_env env,
                                               napi_callback_info info);
 typedef void(NAPI_CDECL* napi_finalize)(napi_env env,
                                         void* finalize_data,
                                         void* finalize_hint);
 
 #if !defined(NAPI_EXPERIMENTAL) ||                                             \
     (defined(NAPI_EXPERIMENTAL) &&                                             \
      defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT))
 typedef napi_finalize node_api_nogc_finalize;
 #else
 typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env,
                                                  void* finalize_data,
                                                  void* finalize_hint);
 #endif
 
 typedef struct {
   // One of utf8name or name should be NULL.
   const char* utf8name;
   napi_value name;
 
   napi_callback method;
   napi_callback getter;
   napi_callback setter;
   napi_value value;
 
   napi_property_attributes attributes;
   void* data;
 } napi_property_descriptor;
 
 typedef struct {
   const char* error_message;
   void* engine_reserved;
   uint32_t engine_error_code;
   napi_status error_code;
 } napi_extended_error_info;
 
 #if NAPI_VERSION >= 6
 typedef enum {
   napi_key_include_prototypes,
   napi_key_own_only
 } napi_key_collection_mode;
 
 typedef enum {
   napi_key_all_properties = 0,
   napi_key_writable = 1,
   napi_key_enumerable = 1 << 1,
   napi_key_configurable = 1 << 2,
   napi_key_skip_strings = 1 << 3,
   napi_key_skip_symbols = 1 << 4
 } napi_key_filter;
 
 typedef enum {
   napi_key_keep_numbers,
   napi_key_numbers_to_strings
 } napi_key_conversion;
 #endif  // NAPI_VERSION >= 6
 
 #if NAPI_VERSION >= 8
 typedef struct {
   uint64_t lower;
   uint64_t upper;
 } napi_type_tag;
 #endif  // NAPI_VERSION >= 8
 
 #endif  // SRC_JS_NATIVE_API_TYPES_H_

This page was automatically generated by the 2.3.7 LXR engine. The LXR team