val.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_VAL_HH
#define WASMTIME_VAL_HH
 
#include <optional>
#ifdef WASMTIME_FEATURE_GC
#include <wasmtime/gc.h>
#endif // WASMTIME_FEATURE_GC
#include <wasmtime/store.hh>
#include <wasmtime/types/val.hh>
#include <wasmtime/val.h>
 
namespace wasmtime {
 
class EqRef;
class StructRef;
class ArrayRef;
 
#ifdef WASMTIME_FEATURE_GC
class ExternRef {
  friend class Val;
 
  wasmtime_externref_t val;
 
  static void finalizer(void *ptr) {
    std::unique_ptr<std::any> _ptr(static_cast<std::any *>(ptr));
  }
 
public:
  explicit ExternRef(wasmtime_externref_t val) : val(val) {}
 
  ExternRef(const ExternRef &other) {
    wasmtime_externref_clone(&other.val, &val);
  }
 
  ExternRef &operator=(const ExternRef &other) {
    wasmtime_externref_unroot(&val);
    wasmtime_externref_clone(&other.val, &val);
    return *this;
  }
 
  ExternRef(ExternRef &&other) {
    val = other.val;
    wasmtime_externref_set_null(&other.val);
  }
 
  ExternRef &operator=(ExternRef &&other) {
    wasmtime_externref_unroot(&val);
    val = other.val;
    wasmtime_externref_set_null(&other.val);
    return *this;
  }
 
  ~ExternRef() { wasmtime_externref_unroot(&val); }
 
  explicit ExternRef(Store::Context cx, std::any val) {
    void *ptr = std::make_unique<std::any>(val).release();
    bool ok = wasmtime_externref_new(cx.ptr, ptr, finalizer, &this->val);
    if (!ok) {
      fprintf(stderr, "failed to allocate a new externref");
      abort();
    }
  }
 
  std::any &data(Store::Context cx) {
    return *static_cast<std::any *>(wasmtime_externref_data(cx.ptr, &val));
  }
 
  uint32_t take_raw(Store::Context cx) {
    uint32_t ret = wasmtime_externref_to_raw(cx.capi(), &val);
    wasmtime_externref_set_null(&val);
    return ret;
  }
 
  uint32_t borrow_raw(Store::Context cx) const {
    return wasmtime_externref_to_raw(cx.capi(), &val);
  }
};
#endif // WASMTIME_FEATURE_GC
 
class EqRef;
 
#ifdef WASMTIME_FEATURE_GC
class AnyRef {
  friend class Val;
 
  wasmtime_anyref_t val;
 
public:
  explicit AnyRef(wasmtime_anyref_t val) : val(val) {}
 
  AnyRef(const AnyRef &other) { wasmtime_anyref_clone(&other.val, &val); }
 
  AnyRef &operator=(const AnyRef &other) {
    wasmtime_anyref_unroot(&val);
    wasmtime_anyref_clone(&other.val, &val);
    return *this;
  }
 
  AnyRef(AnyRef &&other) {
    val = other.val;
    wasmtime_anyref_set_null(&other.val);
  }
 
  AnyRef &operator=(AnyRef &&other) {
    wasmtime_anyref_unroot(&val);
    val = other.val;
    wasmtime_anyref_set_null(&other.val);
    return *this;
  }
 
  ~AnyRef() { wasmtime_anyref_unroot(&val); }
 
  static AnyRef i31(Store::Context cx, uint32_t value) {
    wasmtime_anyref_t other;
    wasmtime_anyref_from_i31(cx.ptr, value, &other);
    return AnyRef(other);
  }
 
  uint32_t take_raw(Store::Context cx) {
    uint32_t ret = wasmtime_anyref_to_raw(cx.capi(), &val);
    wasmtime_anyref_set_null(&val);
    return ret;
  }
 
  uint32_t borrow_raw(Store::Context cx) const {
    return wasmtime_anyref_to_raw(cx.capi(), &val);
  }
 
  std::optional<uint32_t> u31(Store::Context cx) const {
    uint32_t ret = 0;
    if (wasmtime_anyref_i31_get_u(cx.ptr, &val, &ret))
      return ret;
    return std::nullopt;
  }
 
  std::optional<int32_t> i31(Store::Context cx) const {
    int32_t ret = 0;
    if (wasmtime_anyref_i31_get_s(cx.ptr, &val, &ret))
      return ret;
    return std::nullopt;
  }
 
  bool is_i31(Store::Context cx) const {
    return wasmtime_anyref_is_i31(cx.ptr, &val);
  }
 
  inline bool is_eqref(Store::Context cx) const;
 
  inline bool is_struct(Store::Context cx) const;
 
  inline bool is_array(Store::Context cx) const;
 
  inline std::optional<EqRef> as_eqref(Store::Context cx) const;
 
  inline std::optional<StructRef> as_struct(Store::Context cx) const;
 
  inline std::optional<ArrayRef> as_array(Store::Context cx) const;
};
#endif // WASMTIME_FEATURE_GC
 
struct V128 {
  wasmtime_v128 v128;
 
  V128() : v128{} { memset(&v128[0], 0, sizeof(wasmtime_v128)); }
 
  V128(const wasmtime_v128 &v) : v128{} {
    memcpy(&v128[0], &v[0], sizeof(wasmtime_v128));
  }
};
 
class Func;
 
class Val {
  friend class Global;
  friend class Table;
  friend class Func;
  friend class Exn;
  friend class StructRef;
  friend class ArrayRef;
 
  wasmtime_val_t val;
 
  Val() : val{} {
    val.kind = WASMTIME_I32;
    val.of.i32 = 0;
  }
  Val(wasmtime_val_t val) : val(val) {}
 
public:
  Val(int32_t i32) : val{} {
    val.kind = WASMTIME_I32;
    val.of.i32 = i32;
  }
  Val(int64_t i64) : val{} {
    val.kind = WASMTIME_I64;
    val.of.i64 = i64;
  }
  Val(float f32) : val{} {
    val.kind = WASMTIME_F32;
    val.of.f32 = f32;
  }
  Val(double f64) : val{} {
    val.kind = WASMTIME_F64;
    val.of.f64 = f64;
  }
  Val(const V128 &v128) : val{} {
    val.kind = WASMTIME_V128;
    memcpy(&val.of.v128[0], &v128.v128[0], sizeof(wasmtime_v128));
  }
  Val(std::optional<Func> func);
  Val(Func func);
  Val(std::optional<ExternRef> ptr) : val{} {
    val.kind = WASMTIME_EXTERNREF;
    if (ptr) {
      val.of.externref = ptr->val;
      wasmtime_externref_set_null(&ptr->val);
    } else {
      wasmtime_externref_set_null(&val.of.externref);
    }
  }
  Val(std::optional<AnyRef> ptr) : val{} {
    val.kind = WASMTIME_ANYREF;
    if (ptr) {
      val.of.anyref = ptr->val;
      wasmtime_anyref_set_null(&ptr->val);
    } else {
      wasmtime_anyref_set_null(&val.of.anyref);
    }
  }
  Val(ExternRef ptr);
  Val(AnyRef ptr);
 
  Val(const Val &other) { wasmtime_val_clone(&other.val, &val); }
 
  Val &operator=(const Val &other) {
    wasmtime_val_unroot(&val);
    wasmtime_val_clone(&other.val, &val);
    return *this;
  }
 
  Val(Val &&other) {
    val = other.val;
    other.val.kind = WASMTIME_I32;
    other.val.of.i32 = 0;
  }
 
  Val &operator=(Val &&other) {
    wasmtime_val_unroot(&val);
    val = other.val;
    other.val.kind = WASMTIME_I32;
    other.val.of.i32 = 0;
    return *this;
  }
 
  ~Val() { wasmtime_val_unroot(&val); }
 
  ValKind kind() const {
    switch (val.kind) {
    case WASMTIME_I32:
      return ValKind::I32;
    case WASMTIME_I64:
      return ValKind::I64;
    case WASMTIME_F32:
      return ValKind::F32;
    case WASMTIME_F64:
      return ValKind::F64;
    case WASMTIME_FUNCREF:
      return ValKind::FuncRef;
    case WASMTIME_EXTERNREF:
      return ValKind::ExternRef;
    case WASMTIME_ANYREF:
      return ValKind::AnyRef;
    case WASMTIME_EXNREF:
      return ValKind::ExnRef;
    case WASMTIME_V128:
      return ValKind::V128;
    }
    std::abort();
  }
 
  int32_t i32() const {
    if (val.kind != WASMTIME_I32) {
      std::abort();
    }
    return val.of.i32;
  }
 
  int64_t i64() const {
    if (val.kind != WASMTIME_I64) {
      std::abort();
    }
    return val.of.i64;
  }
 
  float f32() const {
    if (val.kind != WASMTIME_F32) {
      std::abort();
    }
    return val.of.f32;
  }
 
  double f64() const {
    if (val.kind != WASMTIME_F64) {
      std::abort();
    }
    return val.of.f64;
  }
 
  V128 v128() const {
    if (val.kind != WASMTIME_V128) {
      std::abort();
    }
    return val.of.v128;
  }
 
  std::optional<ExternRef> 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);
  }
 
  std::optional<AnyRef> 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);
  }
 
  std::optional<Func> funcref() const;
};
 
} // namespace wasmtime
 
// fill in `Func` constructors for `Val`
#include <wasmtime/func.hh>
 
#endif // WASMTIME_VAL_HH