chore: More wit -> wamr thunking

Signed-off-by: Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

samples/wamr/main.cpp

@@ -51,14 +51,74 @@ std::pair<void *, size_t> convert(void *dest, uint32_t dest_byte_len, const void
     assert(false);
 }
 
-int main()
+std::vector<wasm_val_t> toWamr(const WasmValVector &values)
+{
+    std::vector<wasm_val_t> result(values.size());
+    for (size_t i = 0; i < values.size(); i++)
+    {
+        switch (values[i].index())
+        {
+        case WASM_I32:
+            result[i].kind = WASM_I32;
+            result[i].of.i32 = std::get<int32_t>(values[i]);
+            break;
+        case WASM_I64:
+            result[i].kind = WASM_I64;
+            result[i].of.i64 = std::get<int64_t>(values[i]);
+            break;
+        case WASM_F32:
+            result[i].kind = WASM_F32;
+            result[i].of.f32 = std::get<float>(values[i]);
+            break;
+        case WASM_F64:
+            result[i].kind = WASM_F64;
+            result[i].of.f64 = std::get<double>(values[i]);
+            break;
+        default:
+            assert(false);
+        }
+    }
+    return result;
+}
+
+template <typename T>
+WasmValVector fromWamr(size_t count, const wasm_val_t *values)
 {
-    std::cout << "Hello, World!" << std::endl;
+    auto size = ValTrait<T>::size;
+    auto alignment = ValTrait<T>::alignment;
+    auto target_count = ValTrait<T>::flat_types.size();
 
+    WasmValVector result(count);
+    for (size_t i = 0; i < count; i++)
+    {
+        switch (values[i].kind)
+        {
+        case WASM_I32:
+            result[i] = values[i].of.i32;
+            break;
+        case WASM_I64:
+            result[i] = values[i].of.i64;
+            break;
+        case WASM_F32:
+            result[i] = values[i].of.f32;
+            break;
+        case WASM_F64:
+            result[i] = values[i].of.f64;
+            break;
+        default:
+            std::cout << "values[i].kind: " << values[i].kind << std::endl;
+            assert(false);
+        }
+    }
+    return result;
+}
+
+int main()
+{
     char *buffer, error_buf[128];
     wasm_module_t module;
     wasm_module_inst_t module_inst;
-    wasm_function_inst_t cabi_realloc, func;
+    wasm_function_inst_t cabi_realloc;
     wasm_exec_env_t exec_env;
     uint32_t size, stack_size = 8092, heap_size = 8092;
 
@@ -104,19 +164,59 @@ int main()
         .post_return = nullptr,
     };
 
-    func = wasm_runtime_lookup_function(module_inst, "example:sample/boolean#and");
-
-    // bool_t arg1 = true;
-    // bool_t arg2 = false;
-    // auto args_flat = cmcpp::lower_flat(callContext, args);
-    uint32_t argv[2] = {true, false};
+    auto and_func = wasm_runtime_lookup_function(module_inst, "example:sample/booleans#and");
+    auto call_and = [&](bool_t input1, bool_t input2)
+    {
+        using inputs_t = tuple_t<bool_t, bool_t>;
+        using outputs_t = bool_t;
+
+        auto inputs = toWamr(lower_flat(callContext, inputs_t{input1, input2}));
+        auto output_size = 1;
+        wasm_val_t outputs[output_size];
+        auto call_result = wasm_runtime_call_wasm_a(exec_env, and_func, output_size, outputs, inputs.size(), inputs.data());
+        auto result = lift_flat<outputs_t>(callContext, fromWamr<outputs_t>(output_size, outputs));
+        std::cout << "and_func(" << input1 << ", " << input2 << "): " << result << std::endl;
+        return result;
+    };
+    call_and(false, false);
+    call_and(false, true);
+    call_and(true, false);
+    call_and(true, true);
+
+    auto reverse_func = wasm_runtime_lookup_function(module_inst, "example:sample/strings#reverse");
+    auto reverse_cleanup_func = wasm_runtime_lookup_function(module_inst, "cabi_post_example:sample/strings#reverse");
+    auto call_reverse = [&](const std::string &input1)
+    {
+        using inputs_t = string_t;
+        using outputs_t = string_t;
+
+        auto and_inputs = toWamr(lower_flat(callContext, inputs_t{input1}));
+        auto output_size = 1;
+        wasm_val_t outputs[output_size];
+        auto call_result = wasm_runtime_call_wasm_a(exec_env, reverse_func, output_size, outputs, and_inputs.size(), and_inputs.data());
+        auto result = load<outputs_t>(callContext, outputs[0].of.i32);
+        std::cout << "reverse_string(" << input1 << "): " << result << std::endl;
+        call_result = wasm_runtime_call_wasm_a(exec_env, reverse_cleanup_func, 0, nullptr, 0, nullptr);
+        return result;
+    };
+    call_reverse("Hello World!");
 
-    list_t<variant_t<bool_t>> args = {true, false};
-    auto args_flat = cmcpp::lower_flat(callContext, args);
-    auto call_result = wasm_runtime_call_wasm(exec_env, func, 2, (uint32_t *)args_flat.data());
-    args_flat.resize(1);
-    auto result = cmcpp::lift_flat<bool_t>(callContext, args_flat);
-    std::cout << "Result: " << result << std::endl;
+    auto reverse_tuple_func = wasm_runtime_lookup_function(module_inst, "example:sample/tuples#reverse");
+    auto reverse_tuple_cleanup_func = wasm_runtime_lookup_function(module_inst, "cabi_post_example:sample/tuples#reverse");
+    auto call_reverse_tuple = [&](bool in1, const std::string &in2)
+    {
+        using inputs_t = tuple_t<bool_t, string_t>;
+        using outputs_t = tuple_t<string_t, bool_t>;
+
+        auto and_inputs = toWamr(lower_flat(callContext, inputs_t{in1, in2}));
+        auto output_size = 1;
+        wasm_val_t outputs[output_size];
+        auto call_result = wasm_runtime_call_wasm_a(exec_env, reverse_tuple_func, output_size, outputs, and_inputs.size(), and_inputs.data());
+        auto result = load<outputs_t>(callContext, outputs[0].of.i32);
+        std::cout << "reverse_tuple(" << in1 << ", " << in2 << "): " << std::get<0>(result) << ", " << std::get<1>(result) << std::endl;
+        return result;
+    };
+    call_reverse_tuple(false, "Hello World!");
 
     wasm_runtime_destroy_exec_env(exec_env);
     wasm_runtime_deinstantiate(module_inst);

samples/wasm/main.cpp

@@ -2,7 +2,7 @@
 
 #include <cstdlib>
 
-bool exports_example_sample_boolean_and(bool a, bool b)
+bool exports_example_sample_booleans_and(bool a, bool b)
 {
     return a && b;
 }
@@ -15,4 +15,10 @@ void exports_example_sample_strings_reverse(sample_string_t *a, sample_string_t
     {
         ret->ptr[i] = a->ptr[a->len - i - 1];
     }
+}
+
+void exports_example_sample_tuples_reverse(sample_tuple2_bool_string_t *a, sample_tuple2_string_bool_t *ret)
+{
+    ret->f1 = !a->f0;
+    exports_example_sample_strings_reverse(&a->f1, &ret->f0);
 }

samples/wasm/sample.wit

@@ -1,6 +1,6 @@
 package example:sample;
 
-interface boolean {
+interface booleans {
   and: func(a: bool, b: bool) -> bool;
   // export or: func(a: bool, b: bool) -> bool;
   // export not: func(a: bool) -> bool;
@@ -10,7 +10,12 @@ interface strings {
   reverse: func(a: string) -> string;
 }
 
+interface tuples {
+  reverse: func(a: tuple<bool, string>) -> tuple<string, bool>;
+}
+
 world sample {
-  export boolean;
+  export booleans;
   export strings;
+  export tuples;
 }