wasmtime-c-api-impl 45.0.0

C API to expose the Wasmtime runtime
Documentation 
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

/**
 * \file wasmtime/val.hh
 */

#ifndef WASMTIME_VAL_HH
#define WASMTIME_VAL_HH

#include <wasmtime/_anyref_class.hh>
#include <wasmtime/_externref_class.hh>
#include <wasmtime/_func_class.hh>
#include <wasmtime/_val_class.hh>

namespace wasmtime {

inline Val::Val(std::optional<Func> func) : val{} {
  val.kind = WASMTIME_FUNCREF;
  if (func) {
    val.of.funcref = (*func).func;
  } else {
    wasmtime_funcref_set_null(&val.of.funcref);
  }
}

inline Val::Val(Func func) : Val(std::optional(func)) {}

inline std::optional<Func> Val::funcref() const {
  if (val.kind != WASMTIME_FUNCREF) {
    std::abort();
  }
  if (val.of.funcref.store_id == 0) {
    return std::nullopt;
  }
  return Func(val.of.funcref);
}

#ifdef WASMTIME_FEATURE_GC

inline Val::Val(std::optional<AnyRef> ptr) : val{} {
  val.kind = WASMTIME_ANYREF;
  if (ptr) {
    val.of.anyref = *ptr->capi();
    wasmtime_anyref_set_null(ptr->capi());
  } else {
    wasmtime_anyref_set_null(&val.of.anyref);
  }
}

inline Val::Val(AnyRef ptr) : Val(std::optional(ptr)) {}

inline std::optional<AnyRef> Val::anyref() const {
  if (val.kind != WASMTIME_ANYREF) {
    std::abort();
  }
  if (wasmtime_anyref_is_null(&val.of.anyref)) {
    return std::nullopt;
  }
  wasmtime_anyref_t other;
  wasmtime_anyref_clone(&val.of.anyref, &other);
  return AnyRef(other);
}

inline Val::Val(std::optional<ExternRef> ptr) : val{} {
  val.kind = WASMTIME_EXTERNREF;
  if (ptr) {
    val.of.externref = *ptr->capi();
    wasmtime_externref_set_null(ptr->capi());
  } else {
    wasmtime_externref_set_null(&val.of.externref);
  }
}

inline Val::Val(ExternRef ptr) : Val(std::optional(ptr)) {}

inline std::optional<ExternRef> Val::externref() const {
  if (val.kind != WASMTIME_EXTERNREF) {
    std::abort();
  }
  if (wasmtime_externref_is_null(&val.of.externref)) {
    return std::nullopt;
  }
  wasmtime_externref_t other;
  wasmtime_externref_clone(&val.of.externref, &other);
  return ExternRef(other);
}

#endif // WASMTIME_FEATURE_GC

/// Type information for the `V128` host value used as a wasm value.
template <> struct detail::WasmType<V128> {
  static const bool valid = true;
  static ValType valtype() { return ValType::v128(); }
  static void store(Store::Context cx, wasmtime_val_raw_t *p, const V128 &t) {
    (void)cx;
    memcpy(&p->v128[0], &t.v128[0], sizeof(wasmtime_v128));
  }
  static V128 load(Store::Context cx, wasmtime_val_raw_t *p) {
    (void)cx;
    return p->v128;
  }
};

} // namespace wasmtime

#endif // WASMTIME_VAL_HH