test: nannew (#179)

Author: toyobayashi

packages/emnapi/src/v8/array.cc

@@ -4,11 +4,16 @@ 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);
+}
+
 }

packages/emnapi/src/v8/array.ts

@@ -5,3 +5,12 @@
 export function _v8_array_new (context: Ptr, value: int): Ptr {
   return emnapiCtx.napiValueFromJsValue(Array(value))
 }
+
+/**
+ * @__deps $emnapiCtx
+ * @__sig ip
+ */
+export function _v8_array_length (array: Ptr): int {
+  const arr = emnapiCtx.jsValueFromNapiValue(array) as any[]
+  return arr.length
+}

packages/emnapi/src/v8/boolean.cc

@@ -4,6 +4,7 @@ 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);
 }
 
@@ -18,4 +19,8 @@ Local<Value> BooleanObject::New(Isolate* isolate, bool value) {
   return v8impl::V8LocalValueFromAddress(n);
 }
 
+bool BooleanObject::ValueOf() const {
+  return static_cast<bool>(_v8_boolean_object_value_of(this));
+}
+
 }

packages/emnapi/src/v8/boolean.ts

@@ -15,3 +15,12 @@ export function _v8_boolean_object_new (isolate: Ptr, value: number): Ptr {
   // eslint-disable-next-line no-new-wrappers
   return emnapiCtx.napiValueFromJsValue(new Boolean(value))
 }
+
+/**
+ * @__deps $emnapiCtx
+ * @__sig ip
+ */
+export function _v8_boolean_object_value_of (self: Ptr): number {
+  const boolObj = emnapiCtx.jsValueFromNapiValue(self)
+  return boolObj.valueOf() ? 1 : 0
+}

packages/emnapi/src/v8/function.cc

@@ -6,6 +6,9 @@ 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*) {}
@@ -20,4 +23,13 @@ MaybeLocal<Object> Function::NewInstance(
     _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);
+}
+
 }

packages/emnapi/src/v8/function.ts

@@ -18,6 +18,7 @@ export function _v8_function_set_name (fn: Ptr, name: Ptr): void {
  * @__sig ppppp
  */
 export function _v8_function_new_instance (fn: Ptr, ctx: Ptr, argc: number, argv: Ptr): Ptr {
+  if (emnapiCtx.isolate.hasPendingException()) return 1
   const Ctor = emnapiCtx.jsValueFromNapiValue(fn)
   from64('argv')
 
@@ -48,3 +49,30 @@ export function _v8_function_new_instance (fn: Ptr, ctx: Ptr, argc: number, argv
 
   return emnapiCtx.napiValueFromJsValue(ret)
 }
+
+/**
+ * @__deps $emnapiCtx
+ * @__sig ppppip
+ */
+export function _v8_function_call (fn: Ptr, ctx: Ptr, recv: Ptr, argc: number, argv: Ptr): Ptr {
+  if (emnapiCtx.isolate.hasPendingException()) return 1
+  const func = emnapiCtx.jsValueFromNapiValue(fn)
+  const thisArg = emnapiCtx.jsValueFromNapiValue(recv)
+  from64('argv')
+
+  let i: number
+  let ret: any
+  try {
+    const argList = Array(argc)
+    for (i = 0; i < argc; i++) {
+      const argVal = makeGetValue('argv', 'i * ' + POINTER_SIZE, '*')
+      argList[i] = emnapiCtx.jsValueFromNapiValue(argVal)!
+    }
+    ret = func.apply(thisArg, argList)
+  } catch (err) {
+    emnapiCtx.isolate.throwException(err)
+    return 1
+  }
+
+  return emnapiCtx.napiValueFromJsValue(ret)
+}

packages/emnapi/src/v8/isolate.cc

@@ -14,6 +14,10 @@ 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);

packages/emnapi/src/v8/string.cc

@@ -11,6 +11,7 @@ extern "C" {
   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*) {}
@@ -46,6 +47,11 @@ Local<Value> StringObject::New(Isolate* isolate, Local<String> 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);
 }

packages/emnapi/src/v8/string.ts

@@ -21,6 +21,15 @@ export function _v8_string_object_new (isolate: Ptr, value: Ptr): Ptr {
   return emnapiCtx.napiValueFromJsValue(new String(emnapiCtx.jsValueFromNapiValue(value)))
 }
 
+/**
+ * @__deps $emnapiCtx
+ * @__sig pp
+ */
+export function _v8_string_object_value_of (self: Ptr): Ptr {
+  const strObj = emnapiCtx.jsValueFromNapiValue(self)
+  return emnapiCtx.napiValueFromJsValue(strObj.valueOf())
+}
+
 /**
  * @__deps $emnapiCtx
  * @__deps $emnapiString

packages/emnapi/src/v8/template.cc

@@ -35,6 +35,14 @@ extern "C" {
     SideEffectType getter_side_effect_type,
     SideEffectType setter_side_effect_type
   );
+  V8_EXTERN internal::Address _v8_function_new(
+    Context* context,
+    internal::Address (*callback)(internal::Address info, v8::FunctionCallback cb),
+    v8::FunctionCallback cb,
+    internal::Address data,
+    int length,
+    int behavior,
+    int side_effect_type);
 }
 
 namespace {
@@ -211,4 +219,16 @@ void ObjectTemplate::SetInternalFieldCount(int value) {
   _v8_object_template_set_internal_field_count(this, value);
 }
 
+MaybeLocal<Function> Function::New(
+      Local<Context> context, FunctionCallback callback,
+      Local<Value> data, int length,
+      ConstructorBehavior behavior,
+      SideEffectType side_effect_type) {
+  internal::Address func_value = _v8_function_new(
+    *context, CallbackWrap, callback, reinterpret_cast<internal::Address>(*data),
+    length, static_cast<int>(behavior), static_cast<int>(side_effect_type));
+  if (!func_value) return MaybeLocal<Function>();
+  return v8impl::V8LocalValueFromAddress(func_value).As<Function>();
+}
+
 }