Get string results from wasm working

Author: RoyalIcing

lib/components_guide/rustler/math.ex

@@ -23,12 +23,14 @@ defmodule ComponentsGuide.Rustler.Math do
   def wasm_example_1_i32(_, _, _), do: error()
   def wasm_example_2_i32(_, _, _, _), do: error()
   def wasm_buffer_2_i32(_, _, _, _), do: error()
+  def wasm_string_2_i32(_, _, _, _), do: error()
 
   def wasm_example(source, f), do: wasm_example_0(source, f)
   def wasm_example(source, f, a), do: wasm_example_1_i32(source, f, a)
   def wasm_example(source, f, a, b), do: wasm_example_2_i32(source, f, a, b)
 
   def wasm_buffer(source, f, a, b), do: wasm_buffer_2_i32(source, f, a, b)
+  def wasm_string(source, f, a, b), do: wasm_string_2_i32(source, f, a, b)
 
   defp error, do: :erlang.nif_error(:nif_not_loaded)
 end

native/componentsguide_rustler_math/src/lib.rs

@@ -1,6 +1,7 @@
 use wasmtime::*;
 //use anyhow::Error as anyhowError;
 use rustler::{Atom, Env, Error, NifStruct, ResourceArc, Term};
+use std::convert::TryInto;
 
 #[rustler::nif]
 fn add(a: i64, b: i64) -> i64 {
@@ -121,6 +122,14 @@ fn wasm_buffer_2_i32(wat_source: String, f: String, a: i32, b: i32) -> Result<Ve
     }
 }
 
+#[rustler::nif]
+fn wasm_string_2_i32(wat_source: String, f: String, a: i32, b: i32) -> Result<String, Error> {
+    return match wasm_example_2_i32_string_internal(wat_source, f, a, b) {
+      Ok(v) => Ok(v),
+      Err(e) => Err(Error::Term(Box::new(e.to_string())))
+    }
+}
+
 fn wasm_example_2_i32_internal(wat_source: String, buffer: bool, f: String, a: i32, b: i32) -> Result<i32, anyhow::Error> {
     let engine = Engine::default();
 
@@ -222,11 +231,62 @@ fn wasm_example_2_i32_n_internal(wat_source: String, buffer: bool, f: String, a:
     return Ok(result);
 }
 
+fn wasm_example_2_i32_string_internal(wat_source: String, f: String, a: i32, b: i32) -> Result<String, anyhow::Error> {
+  let engine = Engine::default();
+
+  // A `Store` is what will own instances, functions, globals, etc. All wasm
+  // items are stored within a `Store`, and it's what we'll always be using to
+  // interact with the wasm world. Custom data can be stored in stores but for
+  // now we just use `()`.
+  let mut store = Store::new(&engine, ());
+  let mut linker = Linker::new(&engine);
+
+  let memory_ty = MemoryType::new(1, None);
+  let memory = Memory::new(&mut store, memory_ty)?;
+  linker.define(&store, "env", "buffer", memory)?;
+
+  // We start off by creating a `Module` which represents a compiled form
+  // of our input wasm module. In this case it'll be JIT-compiled after
+  // we parse the text format.
+  let module = Module::new(&engine, wat_source)?;
+  
+  // With a compiled `Module` we can then instantiate it, creating
+  // an `Instance` which we can actually poke at functions on.
+  // let instance = Instance::new(&mut store, &module, &[])?;
+  let instance = linker.instantiate(&mut store, &module)?;
+
+  // The `Instance` gives us access to various exported functions and items,
+  // which we access here to pull out our `answer` exported function and
+  // run it.
+  let answer = instance
+      .get_func(&mut store, &f)
+      .expect(&format!("{} was not an exported function", f));
+
+  // There's a few ways we can call the `answer` `Func` value. The easiest
+  // is to statically assert its signature with `typed` (in this case
+  // asserting it takes no arguments and returns one i32) and then call it.
+  let answer = answer.typed::<(i32, i32), (i32, i32)>(&store)?;
+
+  // And finally we can call our function! Note that the error propagation
+  // with `?` is done to handle the case where the wasm function traps.
+  let (start, length) = answer.call(&mut store, (a, b))?;
+  let start: usize = start.try_into().unwrap();
+  let length: usize = length.try_into().unwrap();
+
+  let mut string_buffer: Vec<u8> = Vec::with_capacity(length);
+  string_buffer.resize(length, 0);
+  memory.read(&store, start, &mut string_buffer)?;
+  let string = String::from_utf8(string_buffer)?;
+
+  return Ok(string);
+}
+
 rustler::init!("Elixir.ComponentsGuide.Rustler.Math", [
   add,
   reverse_string,
   wasm_example_0,
   wasm_example_1_i32,
   wasm_example_2_i32,
-  wasm_buffer_2_i32
+  wasm_buffer_2_i32,
+  wasm_string_2_i32
 ]);

test/components_guide/rustler/math_test.exs

@@ -108,6 +108,7 @@ defmodule ComponentsGuide.Rustler.MathTest do
     """
 
     assert Math.wasm_buffer(wasm_source, "main", 0, 0) == [256, 30]
+    assert Math.wasm_string(wasm_source, "main", 0, 0) == "Know the length of this string"
   end
 
   # defwasm multiply(a, b) do