emnapi 0.31.0

package/src/uv/unix/thread.c

@@ -0,0 +1,118 @@
+#if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
+
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <time.h>
+#include "uv.h"
+
+void uv_sem_post(sem_t* sem) {
+  if (sem_post(sem))
+    abort();
+}
+
+int uv_sem_init(sem_t* sem, unsigned int value) {
+  if (sem_init(sem, 0, value))
+    return errno;
+  return 0;
+}
+
+void uv_sem_wait(sem_t* sem) {
+  int r;
+
+  do {
+    r = sem_wait(sem);
+  } while (r == -1 && errno == EINTR);
+
+  if (r)
+    abort();
+}
+
+void uv_sem_destroy(sem_t* sem) {
+  if (sem_destroy(sem))
+    abort();
+}
+
+void uv_once(pthread_once_t* guard, void (*callback)(void)) {
+  if (pthread_once(guard, callback))
+    abort();
+}
+
+int uv_mutex_init(uv_mutex_t* mutex) {
+#if defined(NDEBUG) || !defined(PTHREAD_MUTEX_ERRORCHECK)
+  return pthread_mutex_init(mutex, NULL);
+#else
+  pthread_mutexattr_t attr;
+  int err;
+
+  if (pthread_mutexattr_init(&attr))
+    abort();
+
+  if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK))
+    abort();
+
+  err = pthread_mutex_init(mutex, &attr);
+
+  if (pthread_mutexattr_destroy(&attr))
+    abort();
+
+  return err;
+#endif
+}
+
+void uv_mutex_destroy(uv_mutex_t* mutex) {
+  if (pthread_mutex_destroy(mutex))
+    abort();
+}
+
+void uv_mutex_lock(uv_mutex_t* mutex) {
+  if (pthread_mutex_lock(mutex))
+    abort();
+}
+
+void uv_mutex_unlock(uv_mutex_t* mutex) {
+  if (pthread_mutex_unlock(mutex))
+    abort();
+}
+
+int uv_cond_init(uv_cond_t* cond) {
+  return pthread_cond_init(cond, NULL);
+}
+
+void uv_cond_signal(uv_cond_t* cond) {
+  if (pthread_cond_signal(cond))
+    abort();
+}
+
+void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex) {
+  if (pthread_cond_wait(cond, mutex))
+    abort();
+}
+
+int uv_thread_create_ex(uv_thread_t* tid,
+                        void* params,
+                        void (*entry)(void *arg),
+                        void *arg) {
+  int err;
+
+  /* Used to squelch a -Wcast-function-type warning. */
+  union {
+    void (*in)(void*);
+    void* (*out)(void*);
+  } f;
+
+  f.in = entry;
+  err = pthread_create(tid, NULL, f.out, arg);
+
+  return err;
+}
+
+int uv_thread_create(uv_thread_t *tid, void (*entry)(void *arg), void *arg) {
+  return uv_thread_create_ex(tid, NULL, entry, arg);
+}
+
+int uv_thread_join(uv_thread_t *tid) {
+  return pthread_join(*tid, NULL);
+}
+
+#endif

package/src/uv/uv-common.c

@@ -0,0 +1,51 @@
+#if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
+
+#include <errno.h>
+#include <string.h>
+#include "uv-common.h"
+
+static uv_loop_t default_loop_struct;
+static uv_loop_t* default_loop_ptr;
+
+
+uv_loop_t* uv_default_loop(void) {
+  if (default_loop_ptr != NULL)
+    return default_loop_ptr;
+
+  if (uv_loop_init(&default_loop_struct))
+    return NULL;
+
+  default_loop_ptr = &default_loop_struct;
+  return default_loop_ptr;
+}
+
+int uv_loop_close(uv_loop_t* loop) {
+  // QUEUE* q;
+  // uv_handle_t* h;
+#ifndef NDEBUG
+  void* saved_data;
+#endif
+
+  if (uv__has_active_reqs(loop))
+    return EBUSY;
+
+  // QUEUE_FOREACH(q, &loop->handle_queue) {
+  //   h = QUEUE_DATA(q, uv_handle_t, handle_queue);
+  //   if (!(h->flags & UV_HANDLE_INTERNAL))
+  //     return UV_EBUSY;
+  // }
+
+  uv__loop_close(loop);
+
+#ifndef NDEBUG
+  saved_data = loop->data;
+  memset(loop, -1, sizeof(*loop));
+  loop->data = saved_data;
+#endif
+  if (loop == default_loop_ptr)
+    default_loop_ptr = NULL;
+
+  return 0;
+}
+
+#endif

package/src/uv/uv-common.h

@@ -0,0 +1,68 @@
+#ifndef UV_COMMON_H_
+#define UV_COMMON_H_
+
+#if defined(__EMSCRIPTEN__)
+  #ifndef EMNAPI_USE_PROXYING
+    #include <emscripten.h> /* version.h */
+    #if __EMSCRIPTEN_major__ * 10000 + __EMSCRIPTEN_minor__ * 100 + __EMSCRIPTEN_tiny__ >= 30109
+    #define EMNAPI_USE_PROXYING 1
+    #else
+    #define EMNAPI_USE_PROXYING 0
+    #endif
+  #endif
+#else
+  #define EMNAPI_USE_PROXYING 0
+#endif
+
+#if defined(__EMSCRIPTEN_PTHREADS__) || defined(_REENTRANT)
+#include <assert.h>
+#include "uv.h"
+#include "queue.h"
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+// #define offsetof(s, m) __builtin_offsetof(s, m)
+#define container_of(ptr, type, member) \
+  ((type *) ((char *) (ptr) - offsetof(type, member)))
+
+#define UV_REQ_INIT(req, typ)                                                 \
+  do {                                                                        \
+    (req)->type = (typ);                                                      \
+  }                                                                           \
+  while (0)
+
+#define uv__has_active_reqs(loop)                                             \
+  ((loop)->active_reqs.count > 0)
+
+#define uv__req_register(loop, req)                                           \
+  do {                                                                        \
+    (loop)->active_reqs.count++;                                              \
+  }                                                                           \
+  while (0)
+
+#define uv__req_unregister(loop, req)                                         \
+  do {                                                                        \
+    assert(uv__has_active_reqs(loop));                                        \
+    (loop)->active_reqs.count--;                                              \
+  }                                                                           \
+  while (0)
+
+#define uv__req_init(loop, req, typ)                                          \
+  do {                                                                        \
+    UV_REQ_INIT(req, typ);                                                    \
+    uv__req_register(loop, req);                                              \
+  }                                                                           \
+  while (0)
+
+enum uv__work_kind {
+  UV__WORK_CPU,
+  UV__WORK_FAST_IO,
+  UV__WORK_SLOW_IO
+};
+
+void uv__work_done(uv_async_t* handle);
+void uv__loop_close(uv_loop_t* loop);
+void uv__async_close(uv_async_t* handle);
+
+#endif
+
+#endif /* UV_COMMON_H_ */