emnapi 1.9.2 → 2.0.0-alpha.1

package/emnapi.gyp

@@ -144,6 +144,43 @@
           }],
         ]
       },
+    },
+    {
+      'target_name': 'v8',
+      'type': 'static_library',
+      'sources': [
+        'array.cc',
+        'external.cc',
+        'exception.cc',
+        'date.cc',
+        'function.cc',
+        'handle_scope.cc',
+        'internal.cc',
+        'isolate.cc',
+        'json.cc',
+        'object.cc',
+        'string.cc',
+        'value.cc',
+        'boolean.cc',
+        'number.cc',
+        'template.cc',
+        'try_catch.cc',
+        'node.cc',
+        'script.cc'
+      ],
+      'defines': [
+        'V8_ENABLE_DIRECT_LOCAL'
+      ],
+      'link_settings': {
+        'target_conditions': [
+          ['_type == "executable" and OS == "emscripten"', {
+            'libraries': [
+              '--js-library=<(emnapi_js_library)',
+              '--js-library=<(v8_js_library)',
+            ]
+          }],
+        ]
+      },
     }
   ]
 }

package/include/node/emnapi.h

@@ -5,9 +5,9 @@
 #include "js_native_api_types.h"
 #include "emnapi_common.h"
 
-#define EMNAPI_MAJOR_VERSION 1
-#define EMNAPI_MINOR_VERSION 9
-#define EMNAPI_PATCH_VERSION 2
+#define EMNAPI_MAJOR_VERSION 2
+#define EMNAPI_MINOR_VERSION 0
+#define EMNAPI_PATCH_VERSION 0
 
 typedef enum {
   emnapi_runtime,
@@ -82,6 +82,42 @@ napi_status emnapi_get_memory_address(napi_env env,
                                       emnapi_ownership* ownership,
                                       bool* runtime_allocated);
 
+EMNAPI_EXTERN void emnapi_debug(
+  const char* file,
+  int lineno,
+  const char* str,
+  void* value,
+  int type
+);
+
+/**
+ * Get the handle for an external SharedArrayBuffer.
+ * This function must be called on the emnapi main thread.
+ */
+EMNAPI_EXTERN
+napi_status emnapi_get_external_sharedarraybuffer_handle(
+    napi_env env,
+    napi_value sharedarraybuffer,
+    void** handle);
+
+/**
+ * Acquire a reference to an external SharedArrayBuffer handle.
+ * This function may be called from any thread.
+ */
+EMNAPI_EXTERN
+void emnapi_acquire_external_sharedarraybuffer(void* handle);
+
+/**
+ * Release a reference to an external SharedArrayBuffer handle.
+ * When the refcount reaches zero, finalize_cb is invoked.
+ * This function may be called from any thread.
+ */
+EMNAPI_EXTERN
+void emnapi_release_external_sharedarraybuffer(void* handle);
+
+#define DEBUGGER_LOG(str, value, type) \
+  emnapi_debug(__FILE__, __LINE__, str, value, type)
+
 EXTERN_C_END
 
 #endif

package/include/node/js_native_api.h

@@ -443,6 +443,16 @@ napi_create_external_arraybuffer(napi_env env,
                                  node_api_basic_finalize finalize_cb,
                                  void* finalize_hint,
                                  napi_value* result);
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_CREATE_EXTERNAL_SHAREDARRAYBUFFER
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_create_external_sharedarraybuffer(napi_env env,
+                                           void* external_data,
+                                           size_t byte_length,
+                                           node_api_noenv_finalize finalize_cb,
+                                           void* finalize_hint,
+                                           napi_value* result);
+#endif  // NAPI_EXPERIMENTAL
 #endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
 NAPI_EXTERN napi_status NAPI_CDECL napi_get_arraybuffer_info(
     napi_env env, napi_value arraybuffer, void** data, size_t* byte_length);

package/include/node/js_native_api_types.h

@@ -188,6 +188,10 @@ typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env,
 #endif
 typedef node_api_nogc_finalize node_api_basic_finalize;
 
+// A finalizer that can be called from any thread and at any time.
+typedef void(NAPI_CDECL* node_api_noenv_finalize)(void* finalize_data,
+                                                  void* finalize_hint);
+
 typedef struct {
   // One of utf8name or name should be NULL.
   const char* utf8name;
@@ -237,4 +241,26 @@ typedef struct {
 } napi_type_tag;
 #endif  // NAPI_VERSION >= 8
 
+#ifndef EMNAPI_UNMODIFIED_UPSTREAM
+// Sentinel format: "NODE_VT" (7 bytes) + marker byte.
+// Marker byte = (version << 1) | 1
+//   - Bit 0 is always 1: ensures the sentinel can never match a C++ vtable
+//     pointer (which is always pointer-aligned, thus bit 0 = 0).
+//   - Bits 1-7: struct version number (0-127).
+#define NODE_API_VT_SENTINEL_VERSION 0
+#define NODE_API_VT_SENTINEL_MAKE(version)                                     \
+  (0x4E4F44455F565400ULL | (((version) << 1) | 1))
+#define NODE_API_VT_SENTINEL                                                   \
+  NODE_API_VT_SENTINEL_MAKE(NODE_API_VT_SENTINEL_VERSION)
+
+#define EMNAPI_NAPI_ENV_FIELDS                        \
+  uint64_t sentinel;                                  \
+  const struct node_api_js_vtable* js_vtable;         \
+  const struct node_api_module_vtable* module_vtable;
+
+struct napi_env__ {
+  EMNAPI_NAPI_ENV_FIELDS
+};
+#endif
+
 #endif  // SRC_JS_NATIVE_API_TYPES_H_

package/include/node/node.h

@@ -0,0 +1,198 @@
+#ifndef SRC_NODE_H_
+#define SRC_NODE_H_
+
+#if !defined(NODE_EXTERN)
+#define NODE_EXTERN __attribute__((__import_module__("env")))
+#endif
+
+#include "v8.h"
+#include "v8-platform.h"
+#include "node_version.h"
+#include "node_api_types.h"
+
+// Forward-declare libuv loop
+struct uv_loop_s;
+struct napi_module;
+
+namespace node {
+
+inline void NODE_SET_METHOD(v8::Local<v8::Object> recv,
+                            const char* name,
+                            v8::FunctionCallback callback) {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate,
+                                                                callback);
+  v8::Local<v8::Function> fn = t->GetFunction(context).ToLocalChecked();
+  v8::Local<v8::String> fn_name = v8::String::NewFromUtf8(isolate, name,
+      v8::NewStringType::kInternalized).ToLocalChecked();
+  fn->SetName(fn_name);
+  recv->Set(context, fn_name, fn).Check();
+}
+#define NODE_SET_METHOD node::NODE_SET_METHOD
+
+#ifdef _WIN32
+# define NODE_MODULE_EXPORT __declspec(dllexport)
+#else
+#ifdef __EMSCRIPTEN__
+#define NODE_MODULE_EXPORT                                                     \
+  __attribute__((visibility("default"))) __attribute__((used))
+#else
+# define NODE_MODULE_EXPORT __attribute__((visibility("default")))
+#endif
+#endif
+
+#define NODE_DEPRECATED(message, declarator) declarator
+
+typedef void (*addon_register_func)(
+    v8::Local<v8::Object> exports,
+    v8::Local<v8::Value> module,
+    void* priv);
+
+// BINARY is a deprecated alias of LATIN1.
+// BASE64URL is not currently exposed to the JavaScript side.
+enum encoding {
+  ASCII,
+  UTF8,
+  BASE64,
+  UCS2,
+  BINARY,
+  HEX,
+  BUFFER,
+  BASE64URL,
+  LATIN1 = BINARY
+};
+
+NODE_EXTERN v8::Local<v8::Value> ErrnoException(v8::Isolate* isolate,
+                                                int errorno,
+                                                const char* syscall = nullptr,
+                                                const char* message = nullptr,
+                                                const char* path = nullptr);
+NODE_EXTERN v8::Local<v8::Value> UVException(v8::Isolate* isolate,
+                                             int errorno,
+                                             const char* syscall = nullptr,
+                                             const char* message = nullptr,
+                                             const char* path = nullptr,
+                                             const char* dest = nullptr);
+
+NODE_DEPRECATED("Use ErrnoException(isolate, ...)",
+                inline v8::Local<v8::Value> ErrnoException(
+      int errorno,
+      const char* syscall = nullptr,
+      const char* message = nullptr,
+      const char* path = nullptr) {
+  return ErrnoException(v8::Isolate::GetCurrent(),
+                        errorno,
+                        syscall,
+                        message,
+                        path);
+})
+
+NODE_DEPRECATED("Use UVException(isolate, ...)",
+                inline v8::Local<v8::Value> UVException(int errorno,
+                                        const char* syscall = nullptr,
+                                        const char* message = nullptr,
+                                        const char* path = nullptr) {
+  return UVException(v8::Isolate::GetCurrent(),
+                     errorno,
+                     syscall,
+                     message,
+                     path);
+})
+
+NODE_EXTERN struct uv_loop_s* GetCurrentEventLoop(v8::Isolate* isolate);
+
+typedef double async_id;
+struct async_context {
+  ::node::async_id async_id;
+  ::node::async_id trigger_async_id;
+};
+
+NODE_EXTERN async_context EmitAsyncInit(v8::Isolate* isolate,
+                                        v8::Local<v8::Object> resource,
+                                        const char* name,
+                                        async_id trigger_async_id = -1);
+
+NODE_EXTERN async_context EmitAsyncInit(v8::Isolate* isolate,
+                                        v8::Local<v8::Object> resource,
+                                        v8::Local<v8::String> name,
+                                        async_id trigger_async_id = -1);
+
+NODE_EXTERN void EmitAsyncDestroy(v8::Isolate* isolate,
+                                  async_context asyncContext);
+
+NODE_EXTERN void FatalException(v8::Isolate* isolate,
+                                const v8::TryCatch& try_catch);
+
+NODE_EXTERN v8::Local<v8::Value> Encode(v8::Isolate* isolate,
+                                        const char* buf,
+                                        size_t len,
+                                        enum encoding encoding = LATIN1);
+
+// Warning: This reverses endianness on Big Endian platforms, even though the
+// signature using uint16_t implies that it should not.
+NODE_EXTERN v8::Local<v8::Value> Encode(v8::Isolate* isolate,
+                                        const uint16_t* buf,
+                                        size_t len);
+
+// Returns -1 if the handle was not valid for decoding
+NODE_EXTERN ssize_t DecodeBytes(v8::Isolate* isolate,
+                                v8::Local<v8::Value>,
+                                enum encoding encoding = LATIN1);
+// returns bytes written.
+NODE_EXTERN ssize_t DecodeWrite(v8::Isolate* isolate,
+                                char* buf,
+                                size_t buflen,
+                                v8::Local<v8::Value>,
+                                enum encoding encoding = LATIN1);
+
+#define NODE_MODULE(modname, regfunc)                                 \
+  NODE_MODULE_INIT() { ((node::addon_register_func)regfunc)(exports, module, NULL); }
+
+#define NODE_MODULE_VERSION 127
+
+#define NODE_MODULE_INITIALIZER_BASE node_register_module_v
+
+#define NODE_MODULE_INITIALIZER_X(base, version)                      \
+    NODE_MODULE_INITIALIZER_X_HELPER(base, version)
+
+#define NODE_MODULE_INITIALIZER_X_HELPER(base, version) base##version
+
+#define NODE_MODULE_INITIALIZER                                       \
+  NODE_MODULE_INITIALIZER_X(NODE_MODULE_INITIALIZER_BASE,             \
+      NODE_MODULE_VERSION)
+
+#define NODE_MODULE_INIT()                                            \
+  extern "C" NODE_MODULE_EXPORT void                                  \
+  NODE_MODULE_INITIALIZER(v8::Local<v8::Object> exports,              \
+                          v8::Local<v8::Value> module,                \
+                          v8::Local<v8::Context> context);            \
+  void NODE_MODULE_INITIALIZER(v8::Local<v8::Object> exports,         \
+                               v8::Local<v8::Value> module,           \
+                               v8::Local<v8::Context> context)
+
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       v8::Local<v8::Function> callback,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_context asyncContext);
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       const char* method,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_context asyncContext);
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       v8::Local<v8::String> symbol,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_context asyncContext);
+}  // namespace node
+
+#endif

package/include/node/node_api.h

@@ -1,16 +1,6 @@
 #ifndef SRC_NODE_API_H_
 #define SRC_NODE_API_H_
 
-#ifndef EMNAPI_UNMODIFIED_UPSTREAM
-#ifndef BUILDING_NODE_EXTENSION
-#define BUILDING_NODE_EXTENSION
-#endif
-
-#if !defined(NAPI_EXTERN) && defined(__EMSCRIPTEN__)
-#define NAPI_EXTERN __attribute__((__import_module__("env")))
-#endif
-#endif
-
 #if defined(BUILDING_NODE_EXTENSION) && !defined(NAPI_EXTERN)
 #ifdef _WIN32
 // Building native addon against node

package/include/node/node_buffer.h

@@ -0,0 +1,92 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_NODE_BUFFER_H_
+#define SRC_NODE_BUFFER_H_
+
+#include "node.h"
+#include "v8.h"
+
+namespace node {
+
+namespace Buffer {
+
+static const size_t kMaxLength = v8::Uint8Array::kMaxLength;
+
+typedef void (*FreeCallback)(char* data, void* hint);
+
+NODE_EXTERN bool HasInstance(v8::Local<v8::Value> val);
+NODE_EXTERN bool HasInstance(v8::Local<v8::Object> val);
+NODE_EXTERN char* Data(v8::Local<v8::Value> val);
+NODE_EXTERN char* Data(v8::Local<v8::Object> val);
+NODE_EXTERN size_t Length(v8::Local<v8::Value> val);
+NODE_EXTERN size_t Length(v8::Local<v8::Object> val);
+
+// public constructor - data is copied
+NODE_EXTERN v8::MaybeLocal<v8::Object> Copy(v8::Isolate* isolate,
+                                            const char* data,
+                                            size_t len);
+
+// public constructor
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate, size_t length);
+
+// public constructor from string
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
+                                           v8::Local<v8::String> string,
+                                           enum encoding enc = UTF8);
+
+// public constructor - data is used, callback is passed data on object gc
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
+                                           char* data,
+                                           size_t length,
+                                           FreeCallback callback,
+                                           void* hint);
+
+// public constructor - data is used.
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
+                                           char* data,
+                                           size_t len);
+
+// Creates a Buffer instance over an existing ArrayBuffer.
+NODE_EXTERN v8::MaybeLocal<v8::Uint8Array> New(v8::Isolate* isolate,
+                                               v8::Local<v8::ArrayBuffer> ab,
+                                               size_t byte_offset,
+                                               size_t length);
+
+// This is verbose to be explicit with inline commenting
+static inline bool IsWithinBounds(size_t off, size_t len, size_t max) {
+  // Asking to seek too far into the buffer
+  // check to avoid wrapping in subsequent subtraction
+  if (off > max)
+    return false;
+
+  // Asking for more than is left over in the buffer
+  if (max - off < len)
+    return false;
+
+  // Otherwise we're in bounds
+  return true;
+}
+
+}  // namespace Buffer
+}  // namespace node
+
+#endif  // SRC_NODE_BUFFER_H_

package/include/node/node_object_wrap.h

@@ -0,0 +1,132 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_NODE_OBJECT_WRAP_H_
+#define SRC_NODE_OBJECT_WRAP_H_
+
+#include "v8.h"
+#include <cassert>
+
+
+namespace node {
+
+class ObjectWrap {
+ public:
+  ObjectWrap() {
+    refs_ = 0;
+  }
+
+
+  virtual ~ObjectWrap() {
+    if (persistent().IsEmpty())
+      return;
+    persistent().ClearWeak();
+    persistent().Reset();
+  }
+
+
+  template <class T>
+  static inline T* Unwrap(v8::Local<v8::Object> handle) {
+    assert(!handle.IsEmpty());
+    assert(handle->InternalFieldCount() > 0);
+    // Cast to ObjectWrap before casting to T.  A direct cast from void
+    // to T won't work right when T has more than one base class.
+    void* ptr = handle->GetAlignedPointerFromInternalField(0);
+    ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);
+    return static_cast<T*>(wrap);
+  }
+
+
+  inline v8::Local<v8::Object> handle() {
+    return handle(v8::Isolate::GetCurrent());
+  }
+
+
+  inline v8::Local<v8::Object> handle(v8::Isolate* isolate) {
+    return v8::Local<v8::Object>::New(isolate, persistent());
+  }
+
+
+  // NOLINTNEXTLINE(runtime/v8_persistent)
+  inline v8::Persistent<v8::Object>& persistent() {
+    return handle_;
+  }
+
+
+ protected:
+  inline void Wrap(v8::Local<v8::Object> handle) {
+    assert(persistent().IsEmpty());
+    assert(handle->InternalFieldCount() > 0);
+    handle->SetAlignedPointerInInternalField(0, this);
+    persistent().Reset(v8::Isolate::GetCurrent(), handle);
+    MakeWeak();
+  }
+
+
+  inline void MakeWeak() {
+    persistent().SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
+  }
+
+  /* Ref() marks the object as being attached to an event loop.
+   * Refed objects will not be garbage collected, even if
+   * all references are lost.
+   */
+  virtual void Ref() {
+    assert(!persistent().IsEmpty());
+    persistent().ClearWeak();
+    refs_++;
+  }
+
+  /* Unref() marks an object as detached from the event loop.  This is its
+   * default state.  When an object with a "weak" reference changes from
+   * attached to detached state it will be freed. Be careful not to access
+   * the object after making this call as it might be gone!
+   * (A "weak reference" means an object that only has a
+   * persistent handle.)
+   *
+   * DO NOT CALL THIS FROM DESTRUCTOR
+   */
+  virtual void Unref() {
+    assert(!persistent().IsEmpty());
+    assert(!persistent().IsWeak());
+    assert(refs_ > 0);
+    if (--refs_ == 0)
+      MakeWeak();
+  }
+
+  int refs_;  // ro
+
+ private:
+  static void WeakCallback(
+      const v8::WeakCallbackInfo<ObjectWrap>& data) {
+    ObjectWrap* wrap = data.GetParameter();
+    assert(wrap->refs_ == 0);
+    wrap->handle_.Reset();
+    delete wrap;
+  }
+
+  // NOLINTNEXTLINE(runtime/v8_persistent)
+  v8::Persistent<v8::Object> handle_;
+};
+
+}  // namespace node
+
+#endif  // SRC_NODE_OBJECT_WRAP_H_