Method v8_callback

src/wasm-v8.cc:1790–1836

}

void FuncData::v8_callback(const v8::FunctionCallbackInfo<v8::Value>& info) {
  auto v8_data = v8::Local<v8::Object>::Cast(info.Data());
  auto self = reinterpret_cast<FuncData*>(wasm_v8::foreign_get(v8_data));
  auto store = impl(self->store);
  auto isolate = store->isolate();
  v8::HandleScope handle_scope(isolate);

  auto& param_types = self->type->params();
  auto& result_types = self->type->results();

  assert(param_types.size() == info.Length());

  // TODO: cache params and result arrays per thread.
  auto args = vec<Val>::make_uninitialized(param_types.size());
  auto results = vec<Val>::make_uninitialized(result_types.size());
  for (size_t i = 0; i < param_types.size(); ++i) {
    args[i] = v8_to_val(store, info[i], param_types[i].get());
  }

  own<Trap> trap;
  if (self->kind == CALLBACK_WITH_ENV) {
    trap = self->callback_with_env(self->env, args, results);
  } else {
    trap = self->callback(args, results);
  }

  if (trap) {
    isolate->ThrowException(impl(trap.get())->v8_object());
    return;
  }

  auto ret = info.GetReturnValue();
  if (result_types.size() == 0) {
    ret.SetUndefined();
  } else if (result_types.size() == 1) {
    assert(results[0].kind() == result_types[0]->kind());
    ret.Set(val_to_v8(store, results[0]));
  } else {
    auto context = store->context();
    auto array = v8::Array::New(isolate, result_types.size());
    for (size_t i = 0; i < result_types.size(); ++i) {
      auto success = array->Set(context, i, val_to_v8(store, results[i]));
      assert(success.IsJust() && success.ToChecked());
    }
    ret.Set(array);
  }
}

void FuncData::finalize_func_data(void* data) {
  delete reinterpret_cast<FuncData*>(data);