_val_class.hh

#ifndef WASMTIME_VAL_CLASS_HH
#define WASMTIME_VAL_CLASS_HH
 
#include <optional>
#include <wasmtime/_anyref_class.hh>
#include <wasmtime/_arrayref_class.hh>
#include <wasmtime/_eqref_class.hh>
#include <wasmtime/_exnref_class.hh>
#include <wasmtime/_externref_class.hh>
#include <wasmtime/_func_class.hh>
#include <wasmtime/_store_class.hh>
#include <wasmtime/_structref_class.hh>
#include <wasmtime/types/val.hh>
#include <wasmtime/val.h>
 
namespace wasmtime {
 
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));
  }
};
 
enum class ValKind {
  I32 = WASMTIME_I32,
  I64 = WASMTIME_I64,
  F32 = WASMTIME_F32,
  F64 = WASMTIME_F64,
  V128 = WASMTIME_V128,
  FuncRef = WASMTIME_FUNCREF,
  ExternRef = WASMTIME_EXTERNREF,
  AnyRef = WASMTIME_ANYREF,
  ExnRef = WASMTIME_EXNREF,
};
 
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;
  }
 
public:
  Val(wasmtime_val_t val) : val(val) {}
 
  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);
#ifdef WASMTIME_FEATURE_GC
  Val(std::optional<ExternRef> ptr);
  Val(std::optional<AnyRef> ptr);
  Val(ExternRef ptr);
  Val(AnyRef ptr);
  Val(std::optional<ExnRef> ptr);
  Val(ExnRef ptr);
#endif
 
  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;
  }
 
#ifdef WASMTIME_FEATURE_GC
  std::optional<ExternRef> externref() const;
 
  std::optional<AnyRef> anyref() const;
 
  std::optional<ExnRef> exnref() const;
#endif
 
  std::optional<Func> funcref() const;
 
  using Raw = wasmtime_val_t;
 
  const Raw *capi() const { return &val; }
 
  Raw *capi() { return &val; }
};
 
} // namespace wasmtime
 
#endif // WASMTIME_VAL_CLASS_HH