val.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_VAL_HH
#define WASMTIME_VAL_HH
 
#include <optional>
#include <wasmtime/store.hh>
#include <wasmtime/types/val.hh>
#include <wasmtime/val.h>
 
namespace wasmtime {
 
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) {}
 
  template <typename T> explicit ExternRef(Store::Context cx, T val) {
    void *ptr = std::make_unique<std::any>(std::move(val)).release();
    bool ok = wasmtime_externref_new(cx.ptr, ptr, finalizer, &this->val);
    if (!ok) {
      fprintf(stderr, "failed to allocate a new externref");
      abort();
    }
  }
 
  ExternRef clone(Store::Context cx) {
    wasmtime_externref_t other;
    wasmtime_externref_clone(cx.ptr, &val, &other);
    return ExternRef(other);
  }
 
  std::any &data(Store::Context cx) {
    return *static_cast<std::any *>(wasmtime_externref_data(cx.ptr, &val));
  }
 
  void unroot(Store::Context cx) { wasmtime_externref_unroot(cx.ptr, &val); }
 
  const wasmtime_externref_t *raw() const { return &val; }
};
 
class AnyRef {
  friend class Val;
 
  wasmtime_anyref_t val;
 
public:
  explicit AnyRef(wasmtime_anyref_t val) : val(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);
  }
 
  AnyRef clone(Store::Context cx) {
    wasmtime_anyref_t other;
    wasmtime_anyref_clone(cx.ptr, &val, &other);
    return AnyRef(other);
  }
 
  void unroot(Store::Context cx) { wasmtime_anyref_unroot(cx.ptr, &val); }
 
  const wasmtime_anyref_t *raw() const { return &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;
  }
};
 
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;
 
  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;
    } 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;
    } else {
      wasmtime_anyref_set_null(&val.of.anyref);
    }
  }
  Val(ExternRef ptr);
  Val(AnyRef ptr);
 
  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_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(Store::Context cx) 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(cx.ptr, &val.of.externref, &other);
    return ExternRef(other);
  }
 
  std::optional<AnyRef> anyref(Store::Context cx) 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(cx.ptr, &val.of.anyref, &other);
    return AnyRef(other);
  }
 
  std::optional<Func> funcref() const;
 
  void unroot(Store::Context cx) { wasmtime_val_unroot(cx.ptr, &val); }
};
 
} // namespace wasmtime
 
// fill in `Func` constructors for `Val`
#include <wasmtime/func.hh>
 
#endif // WASMTIME_VAL_HH