emnapi 1.11.0 → 2.0.0-alpha.2

package/include/node/uv/version.h

@@ -0,0 +1,43 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * 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 UV_VERSION_H
+#define UV_VERSION_H
+
+ /*
+ * Versions with the same major number are ABI stable. API is allowed to
+ * evolve between minor releases, but only in a backwards compatible way.
+ * Make sure you update the -soname directives in configure.ac
+ * whenever you bump UV_VERSION_MAJOR or UV_VERSION_MINOR (but
+ * not UV_VERSION_PATCH.)
+ */
+
+#define UV_VERSION_MAJOR 1
+#define UV_VERSION_MINOR 48
+#define UV_VERSION_PATCH 0
+#define UV_VERSION_IS_RELEASE 1
+#define UV_VERSION_SUFFIX ""
+
+#define UV_VERSION_HEX  ((UV_VERSION_MAJOR << 16) | \
+                         (UV_VERSION_MINOR <<  8) | \
+                         (UV_VERSION_PATCH))
+
+#endif /* UV_VERSION_H */

package/include/node/uv.h

@@ -7,6 +7,7 @@
 extern "C" {
 #endif
 
+#include "uv/version.h"
 #include <stddef.h>
 #include <stdint.h>
 
@@ -80,6 +81,11 @@ UV_EXTERN void uv_cond_destroy(uv_cond_t* cond);
 
 UV_EXTERN void uv_once(uv_once_t* guard, void (*callback)(void));
 
+UV_EXTERN int uv_key_create(uv_key_t* key);
+UV_EXTERN void uv_key_delete(uv_key_t* key);
+UV_EXTERN void* uv_key_get(uv_key_t* key);
+UV_EXTERN void uv_key_set(uv_key_t* key, void* value);
+
 struct uv_work_s {
   UV_REQ_FIELDS
   uv_loop_t* loop;

package/index.js

@@ -34,17 +34,21 @@ exports.requiredConfig = {
     settings: {
       WASM_BIGINT: '1',
       ALLOW_MEMORY_GROWTH: '1',
+      ALLOW_TABLE_GROWTH: '1',
       MIN_CHROME_VERSION: '85',
       EXPORTED_RUNTIME_METHODS: [
-        'emnapiInit'
+        'emnapiInit',
       ],
       EXPORTED_FUNCTIONS: [
         '_malloc',
         '_free',
         '_napi_register_wasm_v1',
-        '_node_api_module_get_api_version_v1'
-      ]
-    }
+        '_node_api_module_get_api_version_v1',
+        '_emnapi_create_env',
+        '_emnapi_delete_env',
+        '_uv_library_shutdown'
+      ],
+    },
   },
   clang: {
     target: 'wasm32-wasip1-threads',
@@ -54,13 +58,17 @@ exports.requiredConfig = {
       '--import-memory',
       '--shared-memory',
       '--export-table',
+      '--growable-table',
       '--export=malloc',
       '--export=free',
       '--export=napi_register_wasm_v1',
       '--export-if-defined=node_api_module_get_api_version_v1',
       '--export=emnapi_thread_crashed',
       '--export-if-defined=emnapi_async_worker_create',
-      '--export-if-defined=emnapi_async_worker_init'
-    ]
-  }
+      '--export-if-defined=emnapi_async_worker_init',
+      '--export-if-defined=uv_library_shutdown',
+      '--export=emnapi_create_env',
+      '--export=emnapi_delete_env',
+    ],
+  },
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emnapi",
-  "version": "1.11.0",
+  "version": "2.0.0-alpha.2",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "gypfile": false,

package/src/async_cleanup_hook.c

@@ -8,7 +8,7 @@ EXTERN_C_START
 typedef void (*async_cleanup_hook)(void* arg, void(*)(void*), void*);
 
 struct async_cleanup_hook_info {
-  napi_env env;
+  node_api_basic_env env;
   async_cleanup_hook fun;
   void* arg;
   bool started;
@@ -16,7 +16,7 @@ struct async_cleanup_hook_info {
 
 struct napi_async_cleanup_hook_handle__ {
   struct async_cleanup_hook_info* handle_;
-  napi_env env_;
+  node_api_basic_env env_;
   napi_async_cleanup_hook user_hook_;
   void* user_data_;
   void (*done_cb_)(void*);
@@ -46,7 +46,7 @@ static void _emnapi_run_async_cleanup_hook(void* arg) {
 }
 
 static struct async_cleanup_hook_info*
-_emnapi_add_async_environment_cleanup_hook(napi_env env,
+_emnapi_add_async_environment_cleanup_hook(node_api_basic_env env,
                                            async_cleanup_hook fun,
                                            void* arg) {
   struct async_cleanup_hook_info* info =
@@ -68,7 +68,7 @@ static void _emnapi_remove_async_environment_cleanup_hook(
 }
 
 static napi_async_cleanup_hook_handle
-_emnapi_ach_handle_create(napi_env env,
+_emnapi_ach_handle_create(node_api_basic_env env,
                           napi_async_cleanup_hook user_hook,
                           void* user_data) {
   napi_async_cleanup_hook_handle handle =
@@ -83,7 +83,7 @@ _emnapi_ach_handle_create(napi_env env,
 }
 
 static void _emnapi_ach_handle_env_unref(void* arg) {
-  napi_env env = (napi_env) arg;
+  node_api_basic_env env = (node_api_basic_env) arg;
   _emnapi_env_unref(env);
 }
 
@@ -92,7 +92,7 @@ _emnapi_ach_handle_delete(napi_async_cleanup_hook_handle handle) {
   _emnapi_remove_async_environment_cleanup_hook(handle->handle_);
   if (handle->done_cb_ != NULL) handle->done_cb_(handle->done_data_);
 
-  _emnapi_set_immediate(_emnapi_ach_handle_env_unref, handle->env_);
+  _emnapi_set_immediate(_emnapi_ach_handle_env_unref, (void*) handle->env_);
 
   free(handle->handle_);
   free(handle);

package/src/emnapi_internal.h

@@ -75,12 +75,6 @@ EXTERN_C_END
 
 EXTERN_C_START
 
-EMNAPI_INTERNAL_EXTERN napi_status napi_set_last_error(node_api_basic_env env,
-                                       napi_status error_code,
-                                       uint32_t engine_error_code,
-                                       void* engine_reserved);
-EMNAPI_INTERNAL_EXTERN napi_status napi_clear_last_error(node_api_basic_env env);
-
 #ifdef __EMSCRIPTEN__
 #if __EMSCRIPTEN_major__ * 10000 + __EMSCRIPTEN_minor__ * 100 + __EMSCRIPTEN_tiny__ >= 30114  // NOLINT
 #define EMNAPI_KEEPALIVE_PUSH emscripten_runtime_keepalive_push
@@ -103,8 +97,8 @@ EMNAPI_INTERNAL_EXTERN void _emnapi_runtime_keepalive_pop();
 
 EMNAPI_INTERNAL_EXTERN napi_handle_scope _emnapi_open_handle_scope();
 EMNAPI_INTERNAL_EXTERN void _emnapi_close_handle_scope(napi_handle_scope scope);
-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_env_ref(node_api_basic_env env);
+EMNAPI_INTERNAL_EXTERN void _emnapi_env_unref(node_api_basic_env env);
 EMNAPI_INTERNAL_EXTERN void _emnapi_ctx_increase_waiting_request_counter();
 EMNAPI_INTERNAL_EXTERN void _emnapi_ctx_decrease_waiting_request_counter();
 
@@ -113,8 +107,7 @@ EMNAPI_INTERNAL_EXTERN int _emnapi_is_main_runtime_thread();
 EMNAPI_INTERNAL_EXTERN double _emnapi_get_now();
 EMNAPI_INTERNAL_EXTERN void _emnapi_unwind();
 EMNAPI_INTERNAL_EXTERN void _emnapi_set_immediate(void (*callback)(void*), void* data);
-EMNAPI_INTERNAL_EXTERN napi_status _emnapi_create_function(napi_env env,
-                                                           const char* utf8name,
+EMNAPI_INTERNAL_EXTERN napi_status _emnapi_create_function(const char* utf8name,
                                                            size_t length,
                                                            napi_callback cb,
                                                            void* data,
@@ -197,4 +190,6 @@ void _emnapi_env_check_gc_access(napi_env env);
 
 EXTERN_C_END
 
+#include "js_native_api_internal.h"
+
 #endif

package/src/js_native_api.c

@@ -2,6 +2,34 @@
 
 EXTERN_C_START
 
+struct node_api_base_env__vtable node_api_base_env__vtable_instance = {
+  .offset_to_top = offsetof(node_api_base_env__, vptr),
+  .type_info = NULL,
+  .cdtor = node_api_base_env__cdtor,
+  .ddtor = node_api_base_env__ddtor,
+};
+
+__attribute__((visibility("default")))
+node_api_base_env__* emnapi_create_env() {
+  node_api_base_env__* env = (node_api_base_env__*) calloc(1, sizeof(node_api_base_env__));
+  node_api_base_env__ctor(env);
+  return env;
+}
+
+__attribute__((visibility("default")))
+void emnapi_delete_env(node_api_base_env__* env) {
+  node_api_base_env__ddtor(env);
+}
+
+node_api_base_env__* node_api_base_env__cdtor(node_api_base_env__* self) {
+  return self;
+}
+
+void node_api_base_env__ddtor(node_api_base_env__* self) {
+  node_api_base_env__cdtor(self);
+  free(self);
+}
+
 static const char* emnapi_error_messages[] = {
   NULL,
   "Invalid argument",
@@ -29,17 +57,12 @@ static const char* emnapi_error_messages[] = {
   "Cannot run JavaScript",
 };
 
-EMNAPI_INTERNAL_EXTERN void _emnapi_get_last_error_info(napi_env env,
-                                        napi_status* error_code,
-                                        uint32_t* engine_error_code,
-                                        void** engine_reserved);
-
+__attribute__((visibility("default")))
 napi_status napi_get_last_error_info(
     node_api_basic_env basic_env, const napi_extended_error_info** result) {
-  static napi_extended_error_info last_error;
-  napi_env env = (napi_env) basic_env;
-  CHECK_ENV(env);
-  CHECK_ARG(env, result);
+  CHECK_ENV(basic_env);
+  CHECK_ARG(basic_env, result);
+  node_api_base_env__* env = EMNAPI_AS_NODE_API_BASE_ENV(basic_env);
 
   const int last_status = napi_cannot_run_js;
 
@@ -48,21 +71,14 @@ napi_status napi_get_last_error_info(
                 "Count of error messages must match count of error values");
 #endif
 
-  _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);
+  CHECK_LE(env->last_error.error_code, last_status);
 
-  last_error.error_message = emnapi_error_messages[last_error.error_code];
+  env->last_error.error_message = emnapi_error_messages[env->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;
+  if (env->last_error.error_code == napi_ok) {
+    napi_clear_last_error(basic_env);
   }
-  *result = &last_error;
+  *result = &(env->last_error);
   return napi_ok;
 }
 

package/src/js_native_api_internal.h

@@ -0,0 +1,66 @@
+#ifndef SRC_JS_NATIVE_API_INTERNAL_H_
+#define SRC_JS_NATIVE_API_INTERNAL_H_
+
+#include "js_native_api_types.h"
+
+typedef struct node_api_base_env__ {
+  void* vptr;
+  EMNAPI_NAPI_ENV_FIELDS;
+  uint32_t id;
+  napi_extended_error_info last_error;
+} node_api_base_env__;
+
+#define EMNAPI_AS_NODE_API_BASE_ENV(env) \
+  ((node_api_base_env__*)((char*)(env) - offsetof(node_api_base_env__, sentinel)))
+
+struct node_api_base_env__vtable {
+  size_t offset_to_top;
+  void* type_info;
+  node_api_base_env__* (*cdtor)(node_api_base_env__* self);
+  void (*ddtor)(node_api_base_env__* self);
+};
+
+EXTERN_C_START
+
+extern struct node_api_base_env__vtable node_api_base_env__vtable_instance;
+
+// EMNAPI_INTERNAL_EXTERN
+// const struct node_api_js_vtable* _emnapi_get_node_api_js_vtable();
+
+// EMNAPI_INTERNAL_EXTERN
+// const struct node_api_module_vtable* _emnapi_get_node_api_module_vtable();
+
+node_api_base_env__* node_api_base_env__cdtor(node_api_base_env__* self);
+void node_api_base_env__ddtor(node_api_base_env__* self);
+
+static inline
+node_api_base_env__* node_api_base_env__ctor(node_api_base_env__* self) {
+  self->vptr = &node_api_base_env__vtable_instance.cdtor;
+  self->sentinel = NODE_API_VT_SENTINEL;
+  return self;
+}
+
+static inline napi_status napi_clear_last_error(node_api_basic_env basic_env) {
+  node_api_base_env__* env = EMNAPI_AS_NODE_API_BASE_ENV(basic_env);
+  env->last_error.error_code = napi_ok;
+  env->last_error.engine_error_code = 0;
+  env->last_error.engine_reserved = NULL;
+  env->last_error.error_message = NULL;
+  return napi_ok;
+}
+
+static inline napi_status
+napi_set_last_error(node_api_basic_env basic_env,
+                    napi_status error_code,
+                    uint32_t engine_error_code,
+                    void* engine_reserved) {
+  node_api_base_env__* env = EMNAPI_AS_NODE_API_BASE_ENV(basic_env);
+  env->last_error.error_code = error_code;
+  env->last_error.engine_error_code = engine_error_code;
+  env->last_error.engine_reserved = engine_reserved;
+  return error_code;
+}
+
+EXTERN_C_END
+
+#endif

package/src/node_api.c

@@ -36,7 +36,7 @@ napi_status napi_get_uv_event_loop(node_api_basic_env env,
   return napi_clear_last_error(env);
 }
 
-EMNAPI_INTERNAL_EXTERN int _emnapi_get_filename(napi_env env, char* buf, int len);
+EMNAPI_INTERNAL_EXTERN int _emnapi_get_filename(node_api_basic_env env, char* buf, int len);
 
 napi_status node_api_get_module_file_name(node_api_basic_env env,
                                           const char** result) {

package/src/threadsafe_function.c

@@ -215,7 +215,7 @@ static void _emnapi_tsfn_finalize(napi_threadsafe_function func) {
     if (emnapi_is_node_binding_available()) {
       napi_value resource, cb;
       EMNAPI_ASSERT_CALL(napi_get_reference_value(func->env, func->async_resource.resource_, &resource));
-      EMNAPI_ASSERT_CALL(_emnapi_create_function(func->env, NULL, 0, _emnapi_tsfn_finalize_in_callback_scope, func, &cb));
+      EMNAPI_ASSERT_CALL(_emnapi_create_function(NULL, 0, _emnapi_tsfn_finalize_in_callback_scope, func, &cb));
       _emnapi_node_make_callback(func->env,
                                 resource,
                                 cb,
@@ -337,7 +337,7 @@ static bool _emnapi_tsfn_dispatch_one(napi_threadsafe_function func) {
     if (emnapi_is_node_binding_available()) {
       napi_value resource, cb;
       EMNAPI_ASSERT_CALL(napi_get_reference_value(func->env, func->async_resource.resource_, &resource));
-      EMNAPI_ASSERT_CALL(_emnapi_create_function(func->env, NULL, 0, _emnapi_tsfn_call_js_cb_in_callback_scope, jscb_data, &cb));
+      EMNAPI_ASSERT_CALL(_emnapi_create_function(NULL, 0, _emnapi_tsfn_call_js_cb_in_callback_scope, jscb_data, &cb));
       _emnapi_node_make_callback(func->env,
                                 resource,
                                 cb,

package/src/uv/unix/thread.c

@@ -188,4 +188,25 @@ int uv_thread_join(uv_thread_t *tid) {
   return pthread_join(*tid, NULL);
 }
 
+int uv_key_create(uv_key_t* key) {
+  return pthread_key_create(key, NULL);
+}
+
+
+void uv_key_delete(uv_key_t* key) {
+  if (pthread_key_delete(*key))
+    abort();
+}
+
+
+void* uv_key_get(uv_key_t* key) {
+  return pthread_getspecific(*key);
+}
+
+
+void uv_key_set(uv_key_t* key, void* value) {
+  if (pthread_setspecific(*key, value))
+    abort();
+}
+
 #endif

package/src/v8/array.cc

@@ -0,0 +1,19 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_array_new(Isolate* isolate, int length);
+  V8_EXTERN uint32_t _v8_array_length(const Array* array);
+}
+
+Local<Array> Array::New(Isolate* isolate, int length) {
+  auto n = _v8_array_new(isolate, length);
+  return v8impl::V8LocalValueFromAddress(n).As<Array>();
+}
+
+uint32_t Array::Length() const {
+  return _v8_array_length(this);
+}
+
+}

package/src/v8/boolean.cc

@@ -0,0 +1,26 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN bool _v8_boolean_value(const Boolean*);
+  V8_EXTERN int _v8_boolean_object_value_of(const BooleanObject*);
+  V8_EXTERN internal::Address _v8_boolean_object_new(Isolate* isolate, int value);
+}
+
+void Boolean::CheckCast(v8::Data*) {}
+
+bool Boolean::Value() const {
+  return _v8_boolean_value(this);
+}
+
+Local<Value> BooleanObject::New(Isolate* isolate, bool value) {
+  auto n = _v8_boolean_object_new(isolate, static_cast<int>(value));
+  return v8impl::V8LocalValueFromAddress(n);
+}
+
+bool BooleanObject::ValueOf() const {
+  return static_cast<bool>(_v8_boolean_object_value_of(this));
+}
+
+}

package/src/v8/date.cc

@@ -0,0 +1,15 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_date_new(Context* context, double value);
+}
+
+MaybeLocal<Value> Date::New(Local<Context> context, double time) {
+  auto n = _v8_date_new(*context, time);
+  if (!n) return MaybeLocal<Value>();
+  return v8impl::V8LocalValueFromAddress(n);
+}
+
+}

package/src/v8/exception.cc

@@ -0,0 +1,48 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_exception_error(internal::Address message, internal::Address options);
+  V8_EXTERN internal::Address _v8_exception_type_error(internal::Address message, internal::Address options);
+  V8_EXTERN internal::Address _v8_exception_range_error(internal::Address message, internal::Address options);
+  V8_EXTERN internal::Address _v8_exception_reference_error(internal::Address message, internal::Address options);
+  V8_EXTERN internal::Address _v8_exception_syntax_error(internal::Address message, internal::Address options);
+}
+
+Local<Value> Exception::Error(Local<String> message, Local<Value> options) {
+  return v8impl::V8LocalValueFromAddress(
+      _v8_exception_error(
+          v8impl::AddressFromV8LocalValue(message),
+          v8impl::AddressFromV8LocalValue(options)));
+}
+
+Local<Value> Exception::TypeError(Local<String> message, Local<Value> options) {
+  return v8impl::V8LocalValueFromAddress(
+      _v8_exception_type_error(
+          v8impl::AddressFromV8LocalValue(message),
+          v8impl::AddressFromV8LocalValue(options)));
+}
+
+Local<Value> Exception::RangeError(Local<String> message, Local<Value> options) {
+  return v8impl::V8LocalValueFromAddress(
+      _v8_exception_range_error(
+          v8impl::AddressFromV8LocalValue(message),
+          v8impl::AddressFromV8LocalValue(options)));
+}
+
+Local<Value> Exception::ReferenceError(Local<String> message, Local<Value> options) {
+  return v8impl::V8LocalValueFromAddress(
+      _v8_exception_reference_error(
+          v8impl::AddressFromV8LocalValue(message),
+          v8impl::AddressFromV8LocalValue(options)));
+}
+
+Local<Value> Exception::SyntaxError(Local<String> message, Local<Value> options) {
+  return v8impl::V8LocalValueFromAddress(
+      _v8_exception_syntax_error(
+          v8impl::AddressFromV8LocalValue(message),
+          v8impl::AddressFromV8LocalValue(options)));
+}
+
+}

package/src/v8/external.cc

@@ -0,0 +1,23 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_external_new(Isolate* isolate, void* data);
+  V8_EXTERN void* _v8_external_value(const External* obj);
+}
+
+void External::CheckCast(v8::Value* that) {}
+
+Local<External> External::New(v8::Isolate* isolate, void* value) {
+  internal::Address obj_value = _v8_external_new(isolate, value);
+  if (!obj_value) return Local<External>();
+  auto obj = v8impl::V8LocalValueFromAddress(obj_value).As<External>();
+  return obj;
+}
+
+void* External::Value() const {
+  return _v8_external_value(this);
+}
+
+}

package/src/v8/function.cc

@@ -0,0 +1,35 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN void _v8_function_set_name(Function* func, internal::Address name);
+  V8_EXTERN internal::Address _v8_function_new_instance(
+    const Function* func, Context* context, int argc, internal::Address* argv);
+  V8_EXTERN internal::Address _v8_function_call(
+    Function* func, Context* context, internal::Address recv, int argc,
+    internal::Address* argv);
+}
+
+void Function::CheckCast(v8::Value*) {}
+
+void Function::SetName(v8::Local<v8::String> name) {
+  _v8_function_set_name(this, v8impl::AddressFromV8LocalValue(name));
+}
+
+MaybeLocal<Object> Function::NewInstance(
+  Local<Context> context, int argc, Local<Value> argv[]) const {
+  return v8impl::V8LocalValueFromAddress(
+    _v8_function_new_instance(this, *context, argc, reinterpret_cast<internal::Address*>(argv))).As<Object>();
+}
+
+MaybeLocal<Value> Function::Call(Local<Context> context,
+                                 Local<Value> recv, int argc,
+                                 Local<Value> argv[]) {
+  internal::Address result = _v8_function_call(
+      this, *context, v8impl::AddressFromV8LocalValue(recv), argc,
+      reinterpret_cast<internal::Address*>(argv));
+  return v8impl::V8LocalValueFromAddress(result);
+}
+
+}

package/src/v8/handle_scope.cc

@@ -0,0 +1,46 @@
+#include "v8_impl.h"
+#include "internal.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_open_handle_scope(Isolate* isolate);
+  V8_EXTERN internal::Address _v8_handle_scope_escape(internal::Address scope, internal::Address value);
+  V8_EXTERN void _v8_close_handle_scope(internal::Address scope);
+}
+
+HandleScope::HandleScope(Isolate* isolate)
+  : i_isolate_(reinterpret_cast<internal::Isolate*>(isolate)),
+    prev_next_(reinterpret_cast<internal::Address*>(_v8_open_handle_scope(isolate))),
+    prev_limit_(nullptr)
+#ifdef V8_ENABLE_CHECKS
+    , scope_level_(0)
+#endif
+    {
+#ifdef V8_ENABLE_CHECKS
+      internal::HandleScopeData* current = i_isolate_->handle_scope_data();
+      current->level++;
+      scope_level_ = current->level;
+#endif
+    }
+
+HandleScope::~HandleScope() {
+#ifdef V8_ENABLE_CHECKS
+  i_isolate_->handle_scope_data()->level--;
+#endif
+  _v8_close_handle_scope(reinterpret_cast<internal::Address>(prev_next_));
+}
+
+EscapableHandleScopeBase::EscapableHandleScopeBase(Isolate* isolate): HandleScope(isolate), escape_slot_(nullptr) {}
+
+internal::Address* EscapableHandleScopeBase::EscapeSlot(internal::Address* escape_value) {
+  if (escape_slot_ != nullptr) {
+    abort();
+  }
+  internal::Address* prev_next_ = *reinterpret_cast<internal::Address**>(reinterpret_cast<internal::Address>(this) + internal::kApiSystemPointerSize * 1);
+  escape_slot_ = reinterpret_cast<internal::Address*>(
+    _v8_handle_scope_escape(reinterpret_cast<internal::Address>(prev_next_), reinterpret_cast<internal::Address>(escape_value)));
+  return escape_slot_;
+}
+
+}