Hello, World! - Wasmtime

# Hello, world!

You can also browse this source code online and clone the wasmtime repository to run the example locally.

This example shows off how to instantiate a simple wasm module and interact with it.

## `hello.wat`

    (module
      (func $hello (import "" "hello"))
      (func (export "run") (call $hello))
    )

## `hello.c`

    /*
    Example of instantiating of the WebAssembly module and invoking its exported
    function.

    You can compile and run this example on Linux with:

       cargo build --release -p wasmtime-c-api
       cc examples/hello.c \
           -I crates/c-api/include \
           target/release/libwasmtime.a \
           -lpthread -ldl -lm \
           -o hello
       ./hello

    Note that on Windows and macOS the command will be similar, but you'll need
    to tweak the `-lpthread` and such annotations as well as the name of the
    `libwasmtime.a` file on Windows.

    You can also build using cmake:

    mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-hello
    */

    #include <assert.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <wasm.h>
    #include <wasmtime.h>

    static void exit_with_error(const char *message, wasmtime_error_t *error,
                                wasm_trap_t *trap);

    static wasm_trap_t *hello_callback(void *env, wasmtime_caller_t *caller,
                                       const wasmtime_val_t *args, size_t nargs,
                                       wasmtime_val_t *results, size_t nresults) {
      printf("Calling back...\n");
      printf("> Hello World!\n");
      return NULL;
    }

    int main() {
      int ret = 0;
      // Set up our compilation context. Note that we could also work with a
      // `wasm_config_t` here to configure what feature are enabled and various
      // compilation settings.
      printf("Initializing...\n");
      wasm_engine_t *engine = wasm_engine_new();
      assert(engine != NULL);

      // With an engine we can create a *store* which is a long-lived group of wasm
      // modules. Note that we allocate some custom data here to live in the store,
      // but here we skip that and specify NULL.
      wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL);
      assert(store != NULL);
      wasmtime_context_t *context = wasmtime_store_context(store);

      // Read our input file, which in this case is a wasm text file.
      FILE *file = fopen("examples/hello.wat", "r");
      assert(file != NULL);
      fseek(file, 0L, SEEK_END);
      size_t file_size = ftell(file);
      fseek(file, 0L, SEEK_SET);
      wasm_byte_vec_t wat;
      wasm_byte_vec_new_uninitialized(&wat, file_size);
      if (fread(wat.data, file_size, 1, file) != 1) {
        printf("> Error loading module!\n");
        return 1;
      }
      fclose(file);

      // Parse the wat into the binary wasm format
      wasm_byte_vec_t wasm;
      wasmtime_error_t *error = wasmtime_wat2wasm(wat.data, wat.size, &wasm);
      if (error != NULL)
        exit_with_error("failed to parse wat", error, NULL);
      wasm_byte_vec_delete(&wat);

      // Now that we've got our binary webassembly we can compile our module.
      printf("Compiling module...\n");
      wasmtime_module_t *module = NULL;
      error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
      wasm_byte_vec_delete(&wasm);
      if (error != NULL)
        exit_with_error("failed to compile module", error, NULL);

      // Next up we need to create the function that the wasm module imports. Here
      // we'll be hooking up a thunk function to the `hello_callback` native
      // function above. Note that we can assign custom data, but we just use NULL
      // for now).
      printf("Creating callback...\n");
      wasm_functype_t *hello_ty = wasm_functype_new_0_0();
      wasmtime_func_t hello;
      wasmtime_func_new(context, hello_ty, hello_callback, NULL, NULL, &hello);

      // With our callback function we can now instantiate the compiled module,
      // giving us an instance we can then execute exports from. Note that
      // instantiation can trap due to execution of the `start` function, so we need
      // to handle that here too.
      printf("Instantiating module...\n");
      wasm_trap_t *trap = NULL;
      wasmtime_instance_t instance;
      wasmtime_extern_t import;
      import.kind = WASMTIME_EXTERN_FUNC;
      import.of.func = hello;
      error = wasmtime_instance_new(context, module, &import, 1, &instance, &trap);
      if (error != NULL || trap != NULL)
        exit_with_error("failed to instantiate", error, trap);

      // Lookup our `run` export function
      printf("Extracting export...\n");
      wasmtime_extern_t run;
      bool ok = wasmtime_instance_export_get(context, &instance, "run", 3, &run);
      assert(ok);
      assert(run.kind == WASMTIME_EXTERN_FUNC);

      // And call it!
      printf("Calling export...\n");
      error = wasmtime_func_call(context, &run.of.func, NULL, 0, NULL, 0, &trap);
      if (error != NULL || trap != NULL)
        exit_with_error("failed to call function", error, trap);

      // Clean up after ourselves at this point
      printf("All finished!\n");
      ret = 0;

      wasmtime_module_delete(module);
      wasmtime_store_delete(store);
      wasm_engine_delete(engine);
      return ret;
    }

    static void exit_with_error(const char *message, wasmtime_error_t *error,
                                wasm_trap_t *trap) {
      fprintf(stderr, "error: %s\n", message);
      wasm_byte_vec_t error_message;
      if (error != NULL) {
        wasmtime_error_message(error, &error_message);
        wasmtime_error_delete(error);
      } else {
        wasm_trap_message(trap, &error_message);
        wasm_trap_delete(trap);
      }
      fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
      wasm_byte_vec_delete(&error_message);
      exit(1);
    }