emnapi 0.31.0 → 0.32.2

package/src/emnapi_common.h

@@ -0,0 +1,171 @@
+#include "emnapi.h"
+
+#if defined(__EMSCRIPTEN__) || defined(__wasi__)
+#include <assert.h>
+#include <stdlib.h>
+#else
+#if __STDC_VERSION__ >= 201112L && !defined(__cplusplus)
+#define static_assert _Static_assert
+#endif
+
+#include <stddef.h>
+
+EXTERN_C_START
+void* malloc(size_t size);
+void* calloc(size_t count, size_t size);
+void free(void* p);
+EXTERN_C_END
+#endif
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+
+#if __EMSCRIPTEN_major__ * 10000 + __EMSCRIPTEN_minor__ * 100 + __EMSCRIPTEN_tiny__ >= 30114  // NOLINT
+#include <emscripten/eventloop.h>
+#endif
+#endif
+
+#ifdef NDEBUG
+  #define	EMNAPI_ASSERT_CALL(the_call) (the_call)
+#else
+  #if defined(__EMSCRIPTEN__) || defined(__wasi__)
+  #define EMNAPI_ASSERT_CALL(the_call) (assert(napi_ok == (the_call)))
+  #else
+  #define	EMNAPI_ASSERT_CALL(the_call) (the_call)
+  #endif
+#endif
+
+#define CHECK_ENV(env)          \
+  do {                          \
+    if ((env) == NULL) {        \
+      return napi_invalid_arg;  \
+    }                           \
+  } while (0)
+
+#define RETURN_STATUS_IF_FALSE(env, condition, status)                  \
+  do {                                                                  \
+    if (!(condition)) {                                                 \
+      return napi_set_last_error((env), (status), 0, NULL);             \
+    }                                                                   \
+  } while (0)
+
+#define CHECK_ARG(env, arg) \
+  RETURN_STATUS_IF_FALSE((env), ((arg) != NULL), napi_invalid_arg)
+
+#define CHECK(expr)                                                           \
+  do {                                                                        \
+    if (!(expr)) {                                                            \
+      __builtin_trap();                                                       \
+    }                                                                         \
+  } while (0)
+
+#define CHECK_NOT_NULL(val) CHECK((val) != NULL)
+
+#define CHECK_EQ(a, b) CHECK((a) == (b))
+#define CHECK_LE(a, b) CHECK((a) <= (b))
+
+EXTERN_C_START
+
+EMNAPI_INTERNAL_EXTERN napi_status napi_set_last_error(napi_env env,
+                                       napi_status error_code,
+                                       uint32_t engine_error_code,
+                                       void* engine_reserved);
+EMNAPI_INTERNAL_EXTERN napi_status napi_clear_last_error(napi_env env);
+
+#ifdef __EMSCRIPTEN__
+#if __EMSCRIPTEN_major__ * 10000 + __EMSCRIPTEN_minor__ * 100 + __EMSCRIPTEN_tiny__ >= 30114  // NOLINT
+#define EMNAPI_KEEPALIVE_PUSH emscripten_runtime_keepalive_push
+#define EMNAPI_KEEPALIVE_POP emscripten_runtime_keepalive_pop
+#else
+
+EMNAPI_INTERNAL_EXTERN void _emnapi_runtime_keepalive_push();
+EMNAPI_INTERNAL_EXTERN void _emnapi_runtime_keepalive_pop();
+
+#define EMNAPI_KEEPALIVE_PUSH _emnapi_runtime_keepalive_push
+#define EMNAPI_KEEPALIVE_POP _emnapi_runtime_keepalive_pop
+#endif
+#else
+EMNAPI_INTERNAL_EXTERN void _emnapi_runtime_keepalive_push();
+EMNAPI_INTERNAL_EXTERN void _emnapi_runtime_keepalive_pop();
+
+#define EMNAPI_KEEPALIVE_PUSH _emnapi_runtime_keepalive_push
+#define EMNAPI_KEEPALIVE_POP _emnapi_runtime_keepalive_pop
+#endif
+
+EMNAPI_INTERNAL_EXTERN void _emnapi_env_ref(napi_env env);
+EMNAPI_INTERNAL_EXTERN void _emnapi_env_unref(napi_env env);
+EMNAPI_INTERNAL_EXTERN void _emnapi_ctx_increase_waiting_request_counter();
+EMNAPI_INTERNAL_EXTERN void _emnapi_ctx_decrease_waiting_request_counter();
+
+#if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
+#define EMNAPI_HAVE_THREADS 1
+#else
+#define EMNAPI_HAVE_THREADS 0
+#endif
+
+#if EMNAPI_HAVE_THREADS
+
+#define container_of(ptr, type, member) \
+  ((type *) ((char *) (ptr) - offsetof(type, member)))
+
+typedef void (*_emnapi_call_into_module_callback)(napi_env env, void* args);
+EMNAPI_INTERNAL_EXTERN
+void _emnapi_call_into_module(napi_env env,
+                              _emnapi_call_into_module_callback callback,
+                              void* args,
+                              int close_scope_if_throw);
+
+#endif
+
+typedef double async_id_t;
+typedef struct async_context {
+  async_id_t async_id;
+  async_id_t trigger_async_id;
+} async_context;
+
+#define ASYNC_RESOURCE_FIELD             \
+  napi_ref resource_;                    \
+  async_context async_context_;
+
+typedef struct emnapi_async_resource {
+  ASYNC_RESOURCE_FIELD
+} emnapi_async_resource;
+
+// call node::EmitAsyncInit
+EMNAPI_INTERNAL_EXTERN
+void _emnapi_node_emit_async_init(napi_value async_resource,
+                                  napi_value async_resource_name,
+                                  async_id_t trigger_async_id,
+                                  async_context* result);
+// call node::EmitAsyncDestroy
+EMNAPI_INTERNAL_EXTERN
+void _emnapi_node_emit_async_destroy(async_id_t id, async_id_t trigger_async_id);
+
+// EMNAPI_INTERNAL_EXTERN void _emnapi_node_open_callback_scope(napi_value async_resource, async_id_t id, async_id_t trigger_async_id, int64_t* result);
+// EMNAPI_INTERNAL_EXTERN void _emnapi_node_close_callback_scope(int64_t* scope);
+
+// call node:MakeCallback
+EMNAPI_INTERNAL_EXTERN
+napi_status _emnapi_node_make_callback(napi_env env,
+                                       napi_value async_resource,
+                                       napi_value cb,
+                                       napi_value* argv,
+                                       size_t size,
+                                       double async_id,
+                                       double trigger_async_id,
+                                       napi_value* result);
+
+#define EMNAPI_ASYNC_RESOURCE_CTOR(env, res, name, ar) \
+  do { \
+    EMNAPI_ASSERT_CALL(napi_create_reference((env), (res), 1, &(ar)->resource_)); \
+    _emnapi_node_emit_async_init((res), (name), -1.0, &(ar)->async_context_); \
+  } while (0)
+
+#define EMNAPI_ASYNC_RESOURCE_DTOR(env, ar) \
+  do { \
+    EMNAPI_ASSERT_CALL(napi_delete_reference((env), (ar)->resource_)); \
+    _emnapi_node_emit_async_destroy((ar)->async_context_.async_id, \
+                                    (ar)->async_context_.trigger_async_id); \
+  } while (0)
+
+EXTERN_C_END

package/src/js_native_api.c

@@ -0,0 +1,106 @@
+#include "emnapi_common.h"
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten/heap.h>
+#endif
+
+EXTERN_C_START
+
+static const char* emnapi_error_messages[] = {
+  NULL,
+  "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",
+  "External buffers are not allowed"
+};
+
+EMNAPI_INTERNAL_EXTERN void _emnapi_get_last_error_info(napi_env env,
+                                        napi_status* error_code,
+                                        uint32_t* engine_error_code,
+                                        void** engine_reserved);
+
+napi_status napi_get_last_error_info(
+    napi_env env, const napi_extended_error_info** result) {
+  static napi_extended_error_info last_error;
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+
+  const int last_status = napi_no_external_buffers_allowed;
+
+  static_assert((sizeof(emnapi_error_messages) / sizeof(const char*)) == napi_no_external_buffers_allowed + 1,
+                "Count of error messages must match count of error values");
+
+  _emnapi_get_last_error_info(env,
+                              &last_error.error_code,
+                              &last_error.engine_error_code,
+                              &last_error.engine_reserved);
+
+  CHECK_LE(last_error.error_code, last_status);
+
+  last_error.error_message = emnapi_error_messages[last_error.error_code];
+
+  if (last_error.error_code == napi_ok) {
+    napi_clear_last_error(env);
+    last_error.engine_error_code = 0;
+    last_error.engine_reserved = NULL;
+  }
+  *result = &last_error;
+  return napi_ok;
+}
+
+#define PAGESIZE 65536
+
+napi_status napi_adjust_external_memory(napi_env env,
+                                        int64_t change_in_bytes,
+                                        int64_t* adjusted_value) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, adjusted_value);
+
+  if (change_in_bytes < 0) {
+    return napi_set_last_error(env, napi_invalid_arg, 0, NULL);
+  }
+
+  size_t old_size = __builtin_wasm_memory_size(0) << 16;
+  size_t new_size = old_size + (size_t) change_in_bytes;
+#ifdef __EMSCRIPTEN__
+  if (!emscripten_resize_heap(new_size)) {
+    return napi_set_last_error(env, napi_generic_failure, 0, NULL);
+  }
+#else
+  new_size = new_size + (PAGESIZE - new_size % PAGESIZE) % PAGESIZE;
+  if (-1 == __builtin_wasm_memory_grow(0, (new_size - old_size + 65535) >> 16)) {
+    return napi_set_last_error(env, napi_generic_failure, 0, NULL);
+  }
+#endif
+
+  *adjusted_value = (int64_t) (__builtin_wasm_memory_size(0) << 16);
+
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_get_version(napi_env env, uint32_t* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+  *result = NAPI_VERSION;
+  return napi_clear_last_error(env);
+}
+
+EXTERN_C_END

package/src/node_api.c

@@ -0,0 +1,73 @@
+#include "emnapi_common.h"
+#include "node_api.h"
+
+#if EMNAPI_HAVE_THREADS
+#include "uv.h"
+#endif
+
+EXTERN_C_START
+
+EMNAPI_INTERNAL_EXTERN void _emnapi_get_node_version(uint32_t* major,
+                                     uint32_t* minor,
+                                     uint32_t* patch);
+
+napi_status
+napi_get_node_version(napi_env env,
+                      const napi_node_version** version) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, version);
+  static napi_node_version node_version = {
+    0,
+    0,
+    0,
+    "node"
+  };
+  _emnapi_get_node_version(&node_version.major,
+                           &node_version.minor,
+                           &node_version.patch);
+  *version = &node_version;
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_get_uv_event_loop(napi_env env,
+                                   struct uv_loop_s** loop) {
+#if EMNAPI_HAVE_THREADS
+  CHECK_ENV(env);
+  CHECK_ARG(env, loop);
+  // Though this is fake libuv loop
+  *loop = uv_default_loop();
+  return napi_clear_last_error(env);
+#else
+  return napi_set_last_error(env, napi_generic_failure, 0, NULL);
+#endif
+}
+
+EMNAPI_INTERNAL_EXTERN int _emnapi_get_filename(char* buf, int len);
+
+napi_status node_api_get_module_file_name(napi_env env,
+                                          const char** result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+
+  static char* filename = NULL;
+  static const char* empty_string = "";
+
+  if (filename != NULL) {
+    free(filename);
+    filename = NULL;
+  }
+
+  int len = _emnapi_get_filename(NULL, 0);
+  if (len == 0) {
+    *result = empty_string;
+  } else {
+    filename = (char*) malloc(len + 1);
+    len = _emnapi_get_filename(filename, len + 1);
+    *(filename + len) = '\0';
+    *result = filename;
+  }
+
+  return napi_clear_last_error(env);
+}
+
+EXTERN_C_END