wasmtime-cli 42.0.2

/*
Example of instantiating a wasm module which uses WASI imports.

You can build the example using CMake:

mkdir build && (cd build && cmake .. && \
  cmake --build . --target wasmtime-wasip1-cpp)

And then run it:

build/wasmtime-wasip1-cpp
*/

#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>
#include <wasmtime.hh>

using namespace wasmtime;

static std::vector<uint8_t> read_binary_file(const char *path) {
  std::ifstream file(path, std::ios::in | std::ios::binary);
  if (!file.is_open()) {
    throw std::runtime_error(std::string("failed to open wasm file: ") + path);
  }
  std::vector<uint8_t> data((std::istreambuf_iterator<char>(file)),
                            std::istreambuf_iterator<char>());
  return data;
}

int main() {
  // Define the WASI functions globally on the `Config`.
  Engine engine;
  Linker linker(engine);
  linker.define_wasi().unwrap();

  // Create a WASI context and put it in a Store; all instances in the store
  // share this context. `WasiConfig` provides a number of ways to
  // configure what the target program will have access to.
  WasiConfig wasi;
  wasi.inherit_argv();
  wasi.inherit_stdin();
  wasi.inherit_stdout();
  wasi.inherit_stderr();

  Store store(engine);
  store.context().set_wasi(std::move(wasi)).unwrap();

  // Load and compile the wasm module.
  auto bytes = read_binary_file("target/wasm32-wasip1/debug/wasi.wasm");
  auto module =
      Module::compile(engine, Span<uint8_t>(bytes.data(), bytes.size()))
          .unwrap();

  // Define the module in the linker (anonymous name matches Rust example
  // usage).
  linker.module(store.context(), "", module).unwrap();

  // Get the default export (command entrypoint) and invoke it.
  Func default_func = linker.get_default(store.context(), "").unwrap();
  default_func.call(store, {}).unwrap();

  return 0;
}