wasmer-napi 0.702.0-alpha.3

NAPI library for Wasmer WebAssembly runtime
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#include "internal/napi_scope.h"

#include "internal/napi_env.h"
#include "internal/napi_lifetime_tracker.h"

napi_scope__::napi_scope__(napi_env env, napi_handle_scope parent)
    : values_{this}, env_{env}, parent_{parent}
{
  napi_scope__ *parent_scope = this->parent();
  level_ = parent_scope == nullptr ? 0 : parent_scope->level() + 1;
}

napi_scope__::~napi_scope__()
{
  close();
}

bool napi_scope__::is_active() const
{
  return env_ != nullptr;
}

size_t napi_scope__::level() const
{
  return level_;
}

napi_value napi_scope__::wrap_value(JSValue value, bool owned)
{
  return wrap_value(env_ == nullptr ? nullptr : env_->context(), value, owned);
}

napi_value napi_scope__::wrap_value(JSContext *context, JSValue value, bool owned)
{
  if (closed_)
  {
    if (owned && env_ != nullptr && context != nullptr)
      JS_FreeValue(context, value);
    return nullptr;
  }

  napi_value wrapped = values_.allocate(env_, context, value, owned);
  if (wrapped == nullptr)
  {
    if (owned && env_ != nullptr && context != nullptr)
      JS_FreeValue(context, value);
    return nullptr;
  }

  return wrapped;
}

napi_value napi_scope__::escape_value(napi_value value)
{
  auto record_escape = [this](napi_value escaped)
  {
    quickjs::detail::napi_lifetime_tracker__::record_scope_escape(env_, escaped != nullptr);
    return escaped;
  };

  if (parent_ == nullptr || value == nullptr)
    return record_escape(nullptr);

  napi_scope__ *owner = ValuesAllocator::unsafe_owner(value);
  assert(owner == this);

  if (owner != this)
    return record_escape(nullptr);

  napi_scope__ *parent_scope = parent();
  return record_escape(parent_scope == nullptr ? nullptr : parent_scope->wrap_value(value->context(), value->get_inner(), false));
}

void napi_scope__::delete_value(napi_value value)
{
  if (value == nullptr)
    return;

  napi_scope__ *owner = ValuesAllocator::unsafe_owner(value);

  if (owner == this)
  {
    values_.destroy(value);
  }
}

void napi_scope__::close()
{
  if (closed_)
    return;

  values_.close();
  closed_ = true;
}

size_t napi_scope__::value_slot_count() const
{
  return values_.slot_count();
}

size_t napi_scope__::value_storage_slot_count() const
{
  return values_.storage_slot_count();
}

size_t napi_scope__::active_value_count() const
{
  return values_.count_active();
}

napi_handle_scope napi_scope__::parent_handle() const
{
  return parent_;
}

napi_scope__ *napi_scope__::parent() const
{
  return env_ == nullptr || parent_ == nullptr ? nullptr : env_->scope_from_handle(parent_);
}

napi_env napi_scope__::env() const
{
  return env_;
}

bool napi_scope__::has_escaped() const
{
  return escaped_;
}

void napi_scope__::mark_escaped()
{
  escaped_ = true;
}