emnapi 1.11.0 → 2.0.0-alpha.2

package/src/v8/internal.cc

@@ -0,0 +1,126 @@
+#include "v8_impl.h"
+#include "internal.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_globalize_reference(
+    internal::Isolate* isolate, internal::Address value);
+  V8_EXTERN internal::Address _v8_copy_global_reference(internal::Address from);
+  V8_EXTERN internal::Address _v8_local_from_global_reference(internal::Address ref);
+  V8_EXTERN void _v8_move_global_reference(internal::Address from,
+                                           internal::Address to);
+  V8_EXTERN void _v8_dispose_global(internal::Address global_handle);
+  V8_EXTERN void _v8_make_weak(internal::Address location,
+                               void* data,
+                               void (*callback)(
+                                WeakCallbackInfo<void>::Callback weak_callback,
+                                void* data, WeakCallbackType type,
+                                void* internal_field1, void* internal_field2),
+                               WeakCallbackInfo<void>::Callback weak_callback,
+                               WeakCallbackType type);
+  V8_EXTERN void* _v8_clear_weak(internal::Address location);
+}
+
+namespace internal {
+
+Isolate* IsolateFromNeverReadOnlySpaceObject(unsigned long obj) {
+  return reinterpret_cast<Isolate*>(v8::Isolate::GetCurrent());
+}
+
+void Internals::CheckInitializedImpl(v8::Isolate*) {}
+
+void VerifyHandleIsNonEmpty(bool is_empty) {
+  if (is_empty) {
+    abort();
+  }
+}
+
+Isolate::Isolate(): data_{} {
+  *reinterpret_cast<internal::Address*>(data_ + internal::Internals::kIsolateRootsOffset + v8::internal::kApiSystemPointerSize * v8::internal::Internals::kUndefinedValueRootIndex) = static_cast<internal::Address>(v8impl::Constant::kUndefined);
+  *reinterpret_cast<internal::Address*>(data_ + internal::Internals::kIsolateRootsOffset + v8::internal::kApiSystemPointerSize * v8::internal::Internals::kTheHoleValueRootIndex) = static_cast<internal::Address>(v8impl::Constant::kHole);
+  *reinterpret_cast<internal::Address*>(data_ + internal::Internals::kIsolateRootsOffset + v8::internal::kApiSystemPointerSize * v8::internal::Internals::kNullValueRootIndex) = static_cast<internal::Address>(v8impl::Constant::kNull);
+  *reinterpret_cast<internal::Address*>(data_ + internal::Internals::kIsolateRootsOffset + v8::internal::kApiSystemPointerSize * v8::internal::Internals::kFalseValueRootIndex) = static_cast<internal::Address>(v8impl::Constant::kFalse);
+  *reinterpret_cast<internal::Address*>(data_ + internal::Internals::kIsolateRootsOffset + v8::internal::kApiSystemPointerSize * v8::internal::Internals::kTrueValueRootIndex) = static_cast<internal::Address>(v8impl::Constant::kTrue);
+  *reinterpret_cast<internal::Address*>(data_ + internal::Internals::kIsolateRootsOffset + v8::internal::kApiSystemPointerSize * v8::internal::Internals::kEmptyStringRootIndex) = static_cast<internal::Address>(v8impl::Constant::kEmptyString);
+}
+
+struct GlobalHandle {
+  Address object;
+  Address ref;
+};
+
+}
+
+namespace api_internal {
+
+void ToLocalEmpty() {
+  abort();
+}
+
+void FromJustIsNothing() {
+  abort();
+}
+
+internal::Address* GlobalizeReference(internal::Isolate* isolate,
+                                      internal::Address value) {
+  internal::Address ref_id = _v8_globalize_reference(isolate, value);
+  return reinterpret_cast<internal::Address*>(new internal::GlobalHandle{0x80000000u + ref_id, ref_id});
+}
+
+void DisposeGlobal(internal::Address* global_handle) {
+  _v8_dispose_global(reinterpret_cast<internal::GlobalHandle*>(global_handle)->ref);
+  delete reinterpret_cast<internal::GlobalHandle*>(global_handle);
+}
+
+internal::Address* CopyGlobalReference(internal::Address* from) {
+  internal::Address ref_id = _v8_copy_global_reference(reinterpret_cast<internal::GlobalHandle*>(from)->ref);
+  return reinterpret_cast<internal::Address*>(new internal::GlobalHandle{0x80000000u + ref_id, ref_id});
+}
+
+internal::Address LocalFromGlobalReference(internal::Address global_handle) {
+  return _v8_local_from_global_reference(global_handle);
+}
+
+void MoveGlobalReference(internal::Address** from, internal::Address** to) {
+  if (*from == *to) {
+    return;
+  }
+  *to = *from;
+  *from = nullptr;
+  // _v8_move_global_reference(**from, **to);
+}
+
+namespace {
+static void WeakCallback(WeakCallbackInfo<void>::Callback weak_callback,
+                         void* data,
+                         WeakCallbackType type,
+                         void* internal_field1,
+                         void* internal_field2) {
+  void* embedder_fields[kEmbedderFieldsInWeakCallback] = {
+    internal_field1, internal_field2
+  };
+  WeakCallbackInfo<void>::Callback second = nullptr;
+  WeakCallbackInfo<void> info(
+    Isolate::GetCurrent(), data,
+    embedder_fields, &second);
+  weak_callback(info);
+  if (second != nullptr) {
+    second(info);
+  }
+}
+}
+
+void MakeWeak(internal::Address* location, void* data,
+              WeakCallbackInfo<void>::Callback weak_callback,
+              WeakCallbackType type) {
+  _v8_make_weak(*location, data, WeakCallback, weak_callback, type);
+}
+
+void* ClearWeak(internal::Address* location) {
+  return _v8_clear_weak(*location);
+};
+
+}  // namespace api_internal
+
+}  // namespace v8

package/src/v8/internal.h

@@ -0,0 +1,41 @@
+#ifndef EMNAPI_V8_INTERNAL_H_
+#define EMNAPI_V8_INTERNAL_H_
+
+#include "v8.h"
+
+namespace v8 {
+
+namespace internal {
+
+struct HandleScopeData final {
+  static constexpr uint32_t kSizeInBytes =
+      2 * v8::internal::kApiSystemPointerSize + 2 * v8::internal::kApiInt32Size;
+
+  Address* next;
+  Address* limit;
+  int level;
+  int sealed_level;
+
+  void Initialize() {
+    next = limit = nullptr;
+    sealed_level = level = 0;
+  }
+};
+
+class Isolate {
+ private:
+  char data_[1024];
+
+ public:
+  explicit Isolate();
+
+  V8_INLINE HandleScopeData* handle_scope_data() {
+    return reinterpret_cast<HandleScopeData*>(data_ + internal::Internals::kIsolateHandleScopeDataOffset);
+  }
+};
+
+}
+
+}
+
+#endif

package/src/v8/isolate.cc

@@ -0,0 +1,35 @@
+#include "v8_impl.h"
+#include "internal.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_isolate_get_current_context(const Isolate* isolate);
+  V8_EXTERN internal::Address _v8_isolate_throw_exception(v8::internal::Address);
+}
+
+void Context::CheckCast(v8::Data*) {}
+
+Isolate* Context::GetIsolate() {
+  return v8::Isolate::GetCurrent();
+}
+
+Local<Context> Context::New(v8::Isolate*, v8::ExtensionConfiguration*, v8::MaybeLocal<v8::ObjectTemplate>, v8::MaybeLocal<v8::Value>, v8::DeserializeInternalFieldsCallback, v8::MicrotaskQueue*, v8::DeserializeContextDataCallback) {
+  return v8impl::V8LocalValueFromAddress(_v8_isolate_get_current_context(nullptr)).As<Context>();
+}
+
+Isolate* Isolate::GetCurrent() {
+  static internal::Isolate current_isolate;
+  return reinterpret_cast<Isolate*>(&current_isolate);
+}
+
+Local<Context> Isolate::GetCurrentContext() {
+  return v8impl::V8LocalValueFromAddress(_v8_isolate_get_current_context(this)).As<Context>();
+}
+
+Local<Value> Isolate::ThrowException(Local<Value> error) {
+  return v8impl::V8LocalValueFromAddress(
+    _v8_isolate_throw_exception(v8impl::AddressFromV8LocalValue(error)));
+}
+
+}

package/src/v8/json.cc

@@ -0,0 +1,25 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_json_parse(Context* context, internal::Address json_string);
+  V8_EXTERN internal::Address _v8_json_stringify(Context* context, internal::Address json_object, internal::Address gap);
+}
+
+MaybeLocal<Value> JSON::Parse(
+      Local<Context> context, Local<String> json_string) {
+  internal::Address value_address = _v8_json_parse(*context, v8impl::AddressFromV8LocalValue(json_string));
+  if (!value_address) return MaybeLocal<Value>();
+  return v8impl::V8LocalValueFromAddress(value_address);
+}
+
+MaybeLocal<String> JSON::Stringify(
+      Local<Context> context, Local<Value> json_object,
+      Local<String> gap) {
+  internal::Address value_address = _v8_json_stringify(*context, v8impl::AddressFromV8LocalValue(json_object), v8impl::AddressFromV8LocalValue(gap));
+  if (!value_address) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(value_address).As<String>();
+}
+
+}

package/src/v8/node.cc

@@ -0,0 +1,24 @@
+#include "node.h"
+#include "v8_impl.h"
+
+namespace node {
+
+extern "C" {
+  V8_EXTERN v8::internal::Address _node_encode(v8::Isolate*, const void* buf, size_t len, int encoding);
+}
+
+v8::Local<v8::Value> Encode(v8::Isolate* isolate,
+                            const char* buf,
+                            size_t len,
+                            enum encoding encoding) {
+  return v8::v8impl::V8LocalValueFromAddress(
+      _node_encode(isolate, buf, len, static_cast<int>(encoding)));
+}
+
+v8::Local<v8::Value> Encode(v8::Isolate* isolate,
+                            const uint16_t* buf,
+                            size_t len) {
+  return v8::v8impl::V8LocalValueFromAddress(_node_encode(isolate, buf, len, -1));
+}
+
+}

package/src/v8/number.cc

@@ -0,0 +1,62 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_integer_new(Isolate*, int32_t);
+  V8_EXTERN internal::Address _v8_integer_new_from_unsigned(Isolate*, uint32_t);
+  V8_EXTERN internal::Address _v8_number_new(Isolate*, double);
+  V8_EXTERN double _v8_number_value(const Number*);
+  V8_EXTERN void _v8_integer_value(const Integer*, int64_t*);
+  V8_EXTERN uint32_t _v8_uint32_value(const Uint32*);
+  V8_EXTERN int32_t _v8_int32_value(const Int32*);
+  V8_EXTERN internal::Address _v8_number_object_new(Isolate* isolate, double value);
+}
+
+void Number::CheckCast(v8::Data*) {}
+void Integer::CheckCast(v8::Data*) {}
+void Uint32::CheckCast(v8::Data*) {}
+void Int32::CheckCast(v8::Data*) {}
+
+double Number::Value() const {
+  return _v8_number_value(this);
+}
+
+int64_t Integer::Value() const {
+  int64_t ret = 0;
+  _v8_integer_value(this, &ret);
+  return ret;
+}
+
+uint32_t Uint32::Value() const {
+  return _v8_uint32_value(this);
+}
+
+int32_t Int32::Value() const {
+  return _v8_int32_value(this);
+}
+
+Local<Number> Number::New(Isolate* isolate, double value) {
+  internal::Address number_value = _v8_number_new(isolate, value);
+  if (!number_value) return Local<Number>();
+  return v8impl::V8LocalValueFromAddress(number_value).As<Number>();
+}
+
+Local<Integer> Integer::NewFromUnsigned(Isolate* isolate, uint32_t value) {
+  internal::Address number_value = _v8_integer_new_from_unsigned(isolate, value);
+  if (!number_value) return Local<Integer>();
+  return v8impl::V8LocalValueFromAddress(number_value).As<Integer>();
+}
+
+Local<Integer> Integer::New(Isolate* isolate, int32_t value) {
+  internal::Address number_value = _v8_integer_new(isolate, value);
+  if (!number_value) return Local<Integer>();
+  return v8impl::V8LocalValueFromAddress(number_value).As<Integer>();
+}
+
+Local<Value> NumberObject::New(Isolate* isolate, double value) {
+  auto n = _v8_number_object_new(isolate, value);
+  return v8impl::V8LocalValueFromAddress(n);
+}
+
+}

package/src/v8/object.cc

@@ -0,0 +1,106 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN int _v8_object_set(Object* obj, Context* context, internal::Address key, internal::Address value, int* success);
+  V8_EXTERN void _v8_object_set_internal_field(Object* obj, int index, internal::Address data);
+  V8_EXTERN void _v8_object_set_aligned_pointer_in_internal_field(Object* obj, int index, void* data);
+  V8_EXTERN void* _v8_object_get_aligned_pointer_in_internal_field(Object* obj, int index);
+  V8_EXTERN internal::Address _v8_object_get_internal_field(Object* obj, int index);
+  V8_EXTERN internal::Address _v8_object_get_key(Object* obj, Context* context, internal::Address index);
+  V8_EXTERN internal::Address _v8_object_get_index(Object* obj, Context* context, uint32_t index);
+  V8_EXTERN int _v8_object_internal_field_count(const Object* obj);
+  V8_EXTERN int _v8_object_set_private(Object* obj, Context* context, internal::Address key, internal::Address value, int* success);
+  V8_EXTERN int _v8_object_has_private(Object* obj, Context* context, internal::Address key, int* has);
+  V8_EXTERN internal::Address _v8_object_get_private(Object* obj, Context* context, internal::Address key);
+  V8_EXTERN int _v8_object_delete_private(Object* obj, Context* context, internal::Address key, int* success);
+  V8_EXTERN internal::Address _v8_object_new(Isolate* isolate);
+  V8_EXTERN internal::Address _v8_private_for_api(Isolate* isolate, internal::Address name);
+}
+
+void Object::CheckCast(v8::Value*) {}
+
+MaybeLocal<Value> Object::Get(v8::Local<v8::Context> context, uint32_t index) {
+  internal::Address value_address = _v8_object_get_index(this, *context, index);
+  if (!value_address) return MaybeLocal<Value>();
+  return v8impl::V8LocalValueFromAddress(value_address).As<Value>();
+}
+
+MaybeLocal<Value> Object::Get(v8::Local<v8::Context> context, v8::Local<v8::Value> key) {
+  internal::Address value_address = _v8_object_get_key(this, *context, v8impl::AddressFromV8LocalValue(key));
+  if (!value_address) return MaybeLocal<Value>();
+  return v8impl::V8LocalValueFromAddress(value_address).As<Value>();
+}
+
+Maybe<bool> Object::Set(v8::Local<v8::Context> context, v8::Local<v8::Value> key, v8::Local<v8::Value> value) {
+  int success = 0;
+  int r = _v8_object_set(this, *context,
+    v8impl::AddressFromV8LocalValue(key), v8impl::AddressFromV8LocalValue(value), &success);
+  if (r != 0) return Nothing<bool>();
+  return Just<bool>(success);
+}
+
+Maybe<bool> Object::SetPrivate(Local<Context> context, Local<Private> key, Local<Value> value) {
+  int success = 0;
+  int r = _v8_object_set_private(this, *context, reinterpret_cast<internal::Address>(*key), reinterpret_cast<internal::Address>(*value), &success);
+  if (r != 0) return Nothing<bool>();
+  return Just<bool>(success);
+}
+
+Maybe<bool> Object::HasPrivate(Local<Context> context, Local<Private> key) {
+  int has = 0;
+  int r = _v8_object_has_private(this, *context, reinterpret_cast<internal::Address>(*key), &has);
+  if (r != 0) return Nothing<bool>();
+  return Just<bool>(has != 0);
+}
+
+MaybeLocal<Value> Object::GetPrivate(Local<Context> context, Local<Private> key) {
+  internal::Address value_address = _v8_object_get_private(this, *context, reinterpret_cast<internal::Address>(*key));
+  if (!value_address) return MaybeLocal<Value>();
+  return v8impl::V8LocalValueFromAddress(value_address).As<Value>();
+}
+
+Maybe<bool> Object::DeletePrivate(Local<Context> context, Local<Private> key) {
+  int success = 0;
+  int r = _v8_object_delete_private(this, *context, reinterpret_cast<internal::Address>(*key), &success);
+  if (r != 0) return Nothing<bool>();
+  return Just<bool>(success);
+}
+
+Local<Object> Object::New(Isolate* isolate) {
+  internal::Address v = _v8_object_new(isolate);
+  return v8impl::V8LocalValueFromAddress(v).As<Object>();
+}
+
+Local<Private> Private::ForApi(Isolate* isolate, Local<String> name) {
+  internal::Address addr = _v8_private_for_api(isolate, v8impl::AddressFromV8LocalValue(name));
+  if (!addr) return Local<Private>();
+  return v8impl::V8LocalValueFromAddress(addr).As<Private>();
+}
+
+void Object::SetInternalField(int index, v8::Local<v8::Data> data) {
+  _v8_object_set_internal_field(this, index, reinterpret_cast<internal::Address>(*data));
+}
+
+void Object::SetAlignedPointerInInternalField(int index, void* data) {
+  _v8_object_set_aligned_pointer_in_internal_field(this, index, data);
+}
+
+void* Object::SlowGetAlignedPointerFromInternalField(int index) {
+  return _v8_object_get_aligned_pointer_in_internal_field(this, index);
+}
+
+int Object::InternalFieldCount() const {
+  return _v8_object_internal_field_count(this);
+}
+
+Local<Data> Object::SlowGetInternalField(int index) {
+  internal::Address data_value = _v8_object_get_internal_field(this, index);
+  Local<Data> data;
+  if (!data_value) return data;
+  memcpy(static_cast<void*>(&data), &data_value, sizeof(data_value));
+  return data;
+}
+
+}

package/src/v8/script.cc

@@ -0,0 +1,75 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_unbound_script_bind_to_current_context(UnboundScript*);
+  V8_EXTERN internal::Address _v8_script_run(Script* self, Context* context);
+  V8_EXTERN internal::Address _v8_script_compiler_compile_unbound_script(
+    Isolate* isolate,
+    internal::Address source_string,
+    int options,
+    int no_cache_reason);
+}
+
+namespace internal {
+
+class BackgroundDeserializeTask {};
+
+}
+
+void ScriptOrigin::VerifyHostDefinedOptions() const {
+
+}
+
+Local<Script> UnboundScript::BindToCurrentContext() {
+  Local<Script> ret;
+  internal::Address v = _v8_unbound_script_bind_to_current_context(this);
+  memcpy(static_cast<void*>(&ret), &v, sizeof(v));
+  return ret;
+}
+
+MaybeLocal<Value> Script::Run(Local<Context> context) {
+  return v8impl::V8LocalValueFromAddress(_v8_script_run(this, *context));
+}
+
+MaybeLocal<Script> ScriptCompiler::Compile(Local<Context> context, Source* source, ScriptCompiler::CompileOptions options, v8::ScriptCompiler::NoCacheReason no_cache_reason) {
+  if (!source || source->source_string.IsEmpty()) return Local<Script>();
+  MaybeLocal<UnboundScript> unbound = CompileUnboundScript(
+    context->GetIsolate(), source, options, no_cache_reason);
+  if (unbound.IsEmpty()) return Local<Script>();
+  return unbound.ToLocalChecked()->BindToCurrentContext();
+}
+
+MaybeLocal<UnboundScript>
+ScriptCompiler::CompileUnboundScript(Isolate* isolate,
+                                     ScriptCompiler::Source* source,
+                                     ScriptCompiler::CompileOptions options,
+                                     ScriptCompiler::NoCacheReason reason) {
+  if (!source || source->source_string.IsEmpty()) return Local<UnboundScript>();
+  Local<UnboundScript> ret;
+  internal::Address v = _v8_script_compiler_compile_unbound_script(
+    isolate,
+    v8impl::AddressFromV8LocalValue(source->source_string),
+    options,
+    reason
+  );
+  memcpy(static_cast<void*>(&ret), &v, sizeof(v));
+  return ret;
+}
+
+ScriptCompiler::ConsumeCodeCacheTask::~ConsumeCodeCacheTask() {
+
+}
+
+ScriptCompiler::CachedData::~CachedData() {
+  if (buffer_policy == BufferOwned) {
+    if (data != nullptr) {
+      delete[] data;
+      data = nullptr;
+      length = 0;
+    }
+  }
+}
+
+}

package/src/v8/string.cc

@@ -0,0 +1,104 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_string_new_from_utf8(Isolate* isolate, const char* data, v8::NewStringType type, int length);
+  V8_EXTERN internal::Address _v8_string_new_from_one_byte(Isolate* isolate, const uint8_t* data, v8::NewStringType type, int length);
+  V8_EXTERN internal::Address _v8_string_new_from_two_byte(Isolate* isolate, const uint16_t* data, v8::NewStringType type, int length);
+  V8_EXTERN internal::Address _v8_string_new_external_one_byte(Isolate* isolate, const char* data, int length);
+  V8_EXTERN internal::Address _v8_string_new_external_two_byte(Isolate* isolate, const uint16_t* data, int length);
+  V8_EXTERN int _v8_string_utf8_length(const String* self, Isolate* isolate);
+  V8_EXTERN int _v8_string_length(const String* self);
+  V8_EXTERN int _v8_string_write_utf8(const String* self, Isolate* isolate, char* buffer, int length, int* nchars_ref, int options);
+  V8_EXTERN internal::Address _v8_regex_new(Context* context, internal::Address pattern, int flags);
+  V8_EXTERN internal::Address _v8_string_object_new(Isolate* isolate, internal::Address value);
+  V8_EXTERN internal::Address _v8_string_object_value_of(const StringObject* self);
+}
+
+void String::CheckCast(v8::Data*) {}
+
+MaybeLocal<String> String::NewFromUtf8(v8::Isolate* isolate, char const* data, v8::NewStringType type, int length) {
+  auto str = _v8_string_new_from_utf8(isolate, data, type, length);
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<String> String::NewFromOneByte(Isolate* isolate, const uint8_t* data, NewStringType type, int length) {
+  auto str = _v8_string_new_from_one_byte(isolate, reinterpret_cast<const uint8_t*>(data), type, length);
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<String> String::NewFromTwoByte(Isolate* isolate, const uint16_t* data, NewStringType type, int length) {
+  auto str = _v8_string_new_from_two_byte(isolate, data, type, length);
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<String> String::NewExternalOneByte(Isolate* isolate, ExternalOneByteStringResource* resource) {
+  auto str = _v8_string_new_external_one_byte(isolate, resource->data(), static_cast<int>(resource->length()));
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<String> String::NewExternalTwoByte(Isolate* isolate, ExternalStringResource* resource) {
+  auto str = _v8_string_new_external_two_byte(isolate, resource->data(), static_cast<int>(resource->length()));
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<RegExp> RegExp::New(Local<Context> context,
+                               Local<String> pattern,
+                               Flags flags) {
+  auto regex = _v8_regex_new(*context, v8impl::AddressFromV8LocalValue(pattern), flags);
+  if (!regex) return MaybeLocal<RegExp>();
+  return v8impl::V8LocalValueFromAddress(regex).As<RegExp>();
+}
+
+Local<Value> StringObject::New(Isolate* isolate, Local<String> value) {
+  auto str = _v8_string_object_new(isolate, v8impl::AddressFromV8LocalValue(value));
+  return v8impl::V8LocalValueFromAddress(str);
+}
+
+Local<String> StringObject::ValueOf() const {
+  auto str = _v8_string_object_value_of(this);
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+int String::Utf8Length(v8::Isolate* isolate) const {
+  return _v8_string_utf8_length(this, isolate);
+}
+
+int String::Length() const {
+  return _v8_string_length(this);
+}
+
+int String::WriteUtf8(Isolate* isolate, char* buffer, int length,
+                int* nchars_ref, int options) const {
+  return _v8_string_write_utf8(
+      this, isolate, buffer, length, nchars_ref, options);
+}
+
+String::Utf8Value::Utf8Value(Isolate* isolate, Local<v8::Value> obj) {
+  if (obj.IsEmpty() || !obj->IsString()) {
+    str_ = nullptr;
+    length_ = 0;
+    return;
+  }
+
+  Local<String> str = obj.As<String>();
+  length_ = str->Utf8Length(isolate);
+  str_ = new char[length_ + 1];
+  str->WriteUtf8(isolate, str_, length_ + 1);
+  str_[length_] = '\0';
+}
+
+String::Utf8Value::~Utf8Value() {
+  if (str_ == nullptr) return;
+  delete[] str_;
+  str_ = nullptr;
+  length_ = 0;
+}
+
+}