chore: More wit -> wamr thunking

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

Author: GordonSmith

include/cmcpp/list.hpp

@@ -82,6 +82,10 @@ namespace cmcpp
         list_t<T> lift_flat(const CallContext &cx, const CoreValueIter &vi)
         {
             auto ptr = vi.next<int32_t>();
+            if (vi.done())
+            {
+                return cmcpp::list::load<T>(cx, ptr);
+            }
             auto length = vi.next<int32_t>();
             return load_from_range<T>(cx, ptr, length);
         }

include/cmcpp/string.hpp

@@ -319,8 +319,11 @@ namespace cmcpp
         template <String T>
         T lift_flat(const CallContext &cx, const CoreValueIter &vi)
         {
-
             auto ptr = vi.next<int32_t>();
+            if (vi.done())
+            {
+                return cmcpp::string::load<T>(cx, ptr);
+            }
             auto packed_length = vi.next<int32_t>();
             return load_from_range<T>(cx, ptr, packed_length);
         }

include/cmcpp/traits.hpp

@@ -137,6 +137,7 @@ namespace cmcpp
         Option,
         Result,
         Flags,
+        Func,
         Own,
         Borrow,
         LAST
@@ -690,6 +691,21 @@ namespace cmcpp
     template <typename T>
     concept Option = ValTrait<T>::type == ValType::Option;
 
+    //  Func  --------------------------------------------------------------------
+    template <Field R, Field... Args>
+    using func_t = std::function<R(Args...)>;
+    template <Field R, Field... Args>
+    struct ValTrait<func_t<R, Args...>>
+    {
+        static constexpr ValType type = ValType::Func;
+        using params_t = tuple_t<Args...>;
+        using result_t = R;
+        static constexpr auto flat_params_types = ValTrait<params_t>::flat_types;
+        static constexpr auto flat_result_types = ValTrait<result_t>::flat_types;
+    };
+    template <typename T>
+    concept Func = ValTrait<T>::type == ValType::Func;
+
     //  --------------------------------------------------------------------
 
     using offset = uint32_t;

include/cmcpp/util.hpp

@@ -64,6 +64,10 @@ namespace cmcpp
             assert(it != end);
             return *it++;
         }
+        bool done() const
+        {
+            return !(it != end);
+        }
     };
 
 }

samples/wamr/main.cpp

@@ -51,14 +51,78 @@ 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);
+        }
+    }
+    // for (size_t i = count; i < target_count; i++)
+    // {
+    //     result[i] = (int32_t)(std::get<int32_t>(result[count - 1]) + (i * alignment));
+    // }
+    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 +168,101 @@ int main()
         .post_return = nullptr,
     };
 
-    func = wasm_runtime_lookup_function(module_inst, "example:sample/boolean#and");
+    using and_func_t = std::function<bool_t(bool_t, bool_t)>;
+    auto and_func = wasm_runtime_lookup_function(module_inst, "example:sample/booleans#and");
+    and_func_t call_and = [&](bool_t a, bool_t b) -> bool_t
+    {
+        using inputs_t = ValTrait<and_func_t>::params_t;
+        using outputs_t = ValTrait<and_func_t>::result_t;
+        auto inputs = toWamr(lower_flat(callContext, inputs_t{a, b}));
+        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(" << a << ", " << b << "): " << result << std::endl;
+        return result;
+    };
+    call_and(false, false);
+    call_and(false, true);
+    call_and(true, false);
+    call_and(true, true);
+
+    using add_func_t = std::function<float64_t(float64_t, float64_t)>;
+    auto add_func = wasm_runtime_lookup_function(module_inst, "example:sample/floats#add");
+    add_func_t call_add = [&](float64_t input1, float64_t input2) -> float64_t
+    {
+        using inputs_t = ValTrait<add_func_t>::params_t;
+        using outputs_t = ValTrait<add_func_t>::result_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, add_func, output_size, outputs, inputs.size(), inputs.data());
+        auto result = lift_flat<outputs_t>(callContext, fromWamr<outputs_t>(output_size, outputs));
+        std::cout << "add_func(" << input1 << ", " << input2 << "): " << result << std::endl;
+        return result;
+    };
+    call_add(3.1, 0.2);
+
+    using reverse_func_t = std::function<string_t(string_t)>;
+    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");
+    reverse_func_t call_reverse = [&](string_t input1) -> string_t
+    {
+        using inputs_t = ValTrait<reverse_func_t>::params_t;
+        using outputs_t = ValTrait<reverse_func_t>::result_t;
 
-    // bool_t arg1 = true;
-    // bool_t arg2 = false;
-    // auto args_flat = cmcpp::lower_flat(callContext, args);
-    uint32_t argv[2] = {true, false};
+        auto 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, inputs.size(), inputs.data());
+        // auto result = load<outputs_t>(callContext, outputs[0].of.i32);
+        auto result = lift_flat<outputs_t>(callContext, fromWamr<outputs_t>(output_size, outputs));
+        std::cout << "reverse_string(" << input1 << "): " << result << std::endl;
+        call_result = wasm_runtime_call_wasm_a(exec_env, reverse_cleanup_func, 0, nullptr, 1, outputs);
+        return result;
+    };
+    auto call_reverse_result = call_reverse("Hello World!");
+    call_reverse(call_reverse_result);
+
+    using reverse_tuple_func_t = std::function<tuple_t<string_t, bool_t>(tuple_t<bool_t, string_t>)>;
+    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");
+    reverse_tuple_func_t call_reverse_tuple = [&](tuple_t<bool_t, string_t> a) -> tuple_t<string_t, bool_t>
+    {
+        using inputs_t = ValTrait<reverse_tuple_func_t>::params_t;
+        using outputs_t = ValTrait<reverse_tuple_func_t>::result_t;
+
+        auto inputs = toWamr(lower_flat(callContext, a));
+        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, inputs.size(), inputs.data());
+        auto result = load<outputs_t>(callContext, outputs->of.i32);
+        std::cout << "reverse_tuple(" << std::get<0>(a) << ", " << std::get<1>(a) << "): " << std::get<0>(result) << ", " << std::get<1>(result) << std::endl;
+        call_result = wasm_runtime_call_wasm_a(exec_env, reverse_tuple_cleanup_func, 0, nullptr, 1, outputs);
+        return result;
+    };
+    auto call_reverse_tuple_result = call_reverse_tuple({false, "Hello World!"});
+    // call_reverse_tuple({std::get<1>(call_reverse_tuple_result), std::get<0>(call_reverse_tuple_result}));
+
+    using list_filter_bool_func_t = std::function<list_t<string_t>(list_t<variant_t<bool_t, string_t>>)>;
+    auto list_filter_bool_func = wasm_runtime_lookup_function(module_inst, "example:sample/lists#filter-bool");
+    auto list_filter_bool_cleanup_func = wasm_runtime_lookup_function(module_inst, "cabi_post_example:sample/lists#filter-bool");
+    auto call_list_filter_bool = [&](list_t<variant_t<bool_t, string_t>> a) -> list_t<string_t>
+    {
+        using inputs_t = ValTrait<list_filter_bool_func_t>::params_t;
+        using outputs_t = ValTrait<list_filter_bool_func_t>::result_t;
 
-    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 inputs = toWamr(lower_flat(callContext, a));
+        auto output_size = 1;
+        wasm_val_t outputs[output_size];
+        auto call_result = wasm_runtime_call_wasm_a(exec_env, list_filter_bool_func, output_size, outputs, inputs.size(), inputs.data());
+        auto result = lift_flat<outputs_t>(callContext, fromWamr<outputs_t>(output_size, outputs));
+        std::cout << "list_filter_bool(" << a.size() << "): " << result.size() << std::endl;
+        call_result = wasm_runtime_call_wasm_a(exec_env, list_filter_bool_cleanup_func, 0, nullptr, 1, outputs);
+        return result;
+    };
+    auto call_list_filter_bool_result = call_list_filter_bool({{false}, {"Hello World!"}});
 
     wasm_runtime_destroy_exec_env(exec_env);
     wasm_runtime_deinstantiate(module_inst);

samples/wasm/main.cpp

@@ -2,11 +2,16 @@
 
 #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;
 }
 
+double exports_example_sample_floats_add(double a, double b)
+{
+    return a + b;
+}
+
 void exports_example_sample_strings_reverse(sample_string_t *a, sample_string_t *ret)
 {
     ret->ptr = (uint8_t *)malloc(a->len);
@@ -15,4 +20,23 @@ 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);
+}
+
+void exports_example_sample_lists_filter_bool(exports_example_sample_lists_list_v_t *a, sample_list_string_t *ret)
+{
+    ret->ptr = (sample_string_t *)malloc(a->len * sizeof(sample_string_t));
+    ret->len = 0;
+    for (size_t i = 0; i < a->len; ++i)
+    {
+        if (a->ptr[i].tag == EXPORTS_EXAMPLE_SAMPLE_LISTS_V_S)
+        {
+            ret->ptr[ret->len++] = a->ptr[i].val.s;
+        }
+    }
+}

samples/wasm/sample.wit

@@ -1,16 +1,35 @@
 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;
 }
 
+interface floats {
+  add: func(a: f64, b: f64) -> f64;
+}
+
 interface strings {
   reverse: func(a: string) -> string;
 }
 
+interface tuples {
+  reverse: func(a: tuple<bool, string>) -> tuple<string, bool>;
+}
+
+interface lists {
+  variant v {
+    b(bool),
+    s(string)
+  }
+  filter-bool: func(a: list<v>) -> list<string>;
+}
+
 world sample {
-  export boolean;
+  export booleans;
+  export floats;
   export strings;
+  export tuples;
+  export lists;
 }