types/val.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_TYPES_VAL_HH
#define WASMTIME_TYPES_VAL_HH
 
#include <memory>
#include <ostream>
#include <wasm.h>
#include <wasmtime/val.h>
 
namespace wasmtime {
 
enum class ValKind {
  I32,
  I64,
  F32,
  F64,
  V128,
  ExternRef,
  FuncRef,
  AnyRef,
  ExnRef,
};
 
#define WASMTIME_FOR_EACH_VAL_KIND(X)                                          \
  X(I32, "i32", WASM_I32)                                                      \
  X(I64, "i64", WASM_I64)                                                      \
  X(F32, "f32", WASM_F32)                                                      \
  X(F64, "f64", WASM_F64)                                                      \
  X(ExternRef, "externref", WASM_EXTERNREF)                                    \
  X(FuncRef, "funcref", WASM_FUNCREF)                                          \
  X(AnyRef, "anyref", WASMTIME_ANYREF)                                         \
  X(ExnRef, "exnref", WASMTIME_EXNREF)                                         \
  X(V128, "v128", WASMTIME_V128)
 
inline std::ostream &operator<<(std::ostream &os, const ValKind &e) {
  switch (e) {
#define CASE_KIND_PRINT_NAME(kind, name, ignore)                               \
  case ValKind::kind:                                                          \
    os << name;                                                                \
    break;
    WASMTIME_FOR_EACH_VAL_KIND(CASE_KIND_PRINT_NAME)
#undef CASE_KIND_PRINT_NAME
  default:
    abort();
  }
  return os;
}
 
class ValType {
  friend class TableType;
  friend class GlobalType;
  friend class FuncType;
  struct deleter {
    void operator()(wasm_valtype_t *p) const { wasm_valtype_delete(p); }
  };
 
  std::unique_ptr<wasm_valtype_t, deleter> ptr;
 
  static wasm_valkind_t kind_to_c(ValKind kind) {
    switch (kind) {
#define CASE_KIND_TO_C(kind, ignore, ckind)                                    \
  case ValKind::kind:                                                          \
    return ckind;
      WASMTIME_FOR_EACH_VAL_KIND(CASE_KIND_TO_C)
#undef CASE_KIND_TO_C
    default:
      abort();
    }
  }
 
public:
  class Ref {
    friend class ValType;
 
    const wasm_valtype_t *ptr;
 
  public:
    Ref(const wasm_valtype_t *ptr) : ptr(ptr) {}
    Ref(const ValType &ty) : Ref(ty.ptr.get()) {}
 
    ValKind kind() const {
      switch (wasm_valtype_kind(ptr)) {
#define CASE_C_TO_KIND(kind, ignore, ckind)                                    \
  case ckind:                                                                  \
    return ValKind::kind;
        WASMTIME_FOR_EACH_VAL_KIND(CASE_C_TO_KIND)
#undef CASE_C_TO_KIND
      }
      std::abort();
    }
  };
 
  class ListRef {
    const wasm_valtype_vec_t *list;
 
  public:
    ListRef(const wasm_valtype_vec_t *list) : list(list) {}
 
    typedef const Ref *iterator;
 
    iterator begin() const {
      return reinterpret_cast<Ref *>(&list->data[0]); // NOLINT
    }
 
    iterator end() const {
      return reinterpret_cast<Ref *>(&list->data[list->size]); // NOLINT
    }
 
    size_t size() const { return list->size; }
  };
 
private:
  Ref ref;
  ValType(wasm_valtype_t *ptr) : ptr(ptr), ref(ptr) {}
 
public:
  ValType(ValKind kind) : ValType(wasm_valtype_new(kind_to_c(kind))) {}
  ValType(Ref other) : ValType(wasm_valtype_copy(other.ptr)) {}
  ValType(const ValType &other) : ValType(wasm_valtype_copy(other.ptr.get())) {}
  ValType &operator=(const ValType &other) {
    ptr.reset(wasm_valtype_copy(other.ptr.get()));
    ref = other.ref;
    return *this;
  }
  ~ValType() = default;
  ValType(ValType &&other) = default;
  ValType &operator=(ValType &&other) = default;
 
  Ref *operator->() { return &ref; }
  Ref *operator*() { return &ref; }
};
 
#undef WASMTIME_FOR_EACH_VAL_KIND
 
}; // namespace wasmtime
 
#endif // WASMTIME_TYPES_VAL_HH