Simplify passing array of imported functions

Author: gumb0

include/fizzy/fizzy.h

@@ -45,17 +45,9 @@ typedef struct fizzy_external_function
     void* context;
 } fizzy_external_function;
 
-struct fizzy_external_function_vector;
-
-struct fizzy_external_function_vector* fizzy_new_external_function_vector(
-    const struct fizzy_external_function* functions, uint32_t size);
-
-void fizzy_free_external_function_vector(struct fizzy_external_function_vector*);
-
-// Takes ownership of module and imported_functions.
-// imported_functions may be NULL.
-struct fizzy_instance* fizzy_instantiate(
-    struct fizzy_module* module, struct fizzy_external_function_vector* imported_functions);
+// Takes ownership of module.
+struct fizzy_instance* fizzy_instantiate(struct fizzy_module* module,
+    const struct fizzy_external_function* imported_functions, uint32_t imported_functions_size);
 
 void fizzy_free_instance(struct fizzy_instance*);
 

lib/fizzy/capi.cpp

@@ -59,23 +59,22 @@ void fizzy_free_module(fizzy_module* module)
     delete module;
 }
 
-struct fizzy_external_function_vector
-{
-    std::vector<fizzy::ExternalFunction> vector;
-};
-
 struct fizzy_instance
 {
     fizzy::Instance* instance;
 };
 
-fizzy_external_function_vector* fizzy_new_external_function_vector(
-    const fizzy_external_function* cfunctions, uint32_t size)
+fizzy_instance* fizzy_instantiate(fizzy_module* module,
+    const fizzy_external_function* imported_functions, uint32_t imported_functions_size)
 {
-    std::vector<fizzy::ExternalFunction> functions(size);
-    std::transform(
-        cfunctions, cfunctions + size, functions.begin(), [](const fizzy_external_function& cfunc) {
-            auto func = [cfunc](fizzy::Instance& instance, fizzy::span<const fizzy::Value> args,
+    try
+    {
+        std::vector<fizzy::ExternalFunction> functions(imported_functions_size);
+        for (size_t imported_func_idx = 0; imported_func_idx < imported_functions_size;
+             ++imported_func_idx)
+        {
+            auto func = [cfunc = imported_functions[imported_func_idx]](fizzy::Instance& instance,
+                            fizzy::span<const fizzy::Value> args,
                             int depth) -> fizzy::ExecutionResult {
                 fizzy_instance cinstance{&instance};
                 const auto cres = cfunc.function(cfunc.context, &cinstance,
@@ -89,43 +88,20 @@ fizzy_external_function_vector* fizzy_new_external_function_vector(
                 else
                     return bit_cast<fizzy::Value>(cres.value);
             };
-            // TODO leave type empty for now
-            return fizzy::ExternalFunction{std::move(func), {}};
-        });
-
-    return new fizzy_external_function_vector{std::move(functions)};
-}
 
-void fizzy_free_external_function_vector(fizzy_external_function_vector* vector)
-{
-    delete vector;
-}
+            // TODO get type from input array
+            auto func_type = module->module.imported_function_types[imported_func_idx];
 
-fizzy_instance* fizzy_instantiate(
-    fizzy_module* module, fizzy_external_function_vector* imported_functions)
-{
-    try
-    {
-        // TODO temp: fill types of imported funcs
-        if (imported_functions)
-        {
-            for (size_t imported_func_idx = 0;
-                 imported_func_idx < imported_functions->vector.size(); ++imported_func_idx)
-            {
-                imported_functions->vector[imported_func_idx].type =
-                    module->module.imported_function_types[imported_func_idx];
-            }
+            functions[imported_func_idx] =
+                fizzy::ExternalFunction{std::move(func), std::move(func_type)};
         }
 
-        auto instance = fizzy::instantiate(
-            std::move(module->module), imported_functions ? std::move(imported_functions->vector) :
-                                                            std::vector<fizzy::ExternalFunction>{});
+        auto instance = fizzy::instantiate(std::move(module->module), std::move(functions));
 
         auto cinstance = std::make_unique<fizzy_instance>();
         cinstance->instance = instance.release();
 
         fizzy_free_module(module);
-        fizzy_free_external_function_vector(imported_functions);
         return cinstance.release();
     }
     catch (...)

test/unittests/capi_test.cpp

@@ -29,7 +29,7 @@ TEST(capi, instantiate)
     uint8_t wasm_prefix[]{0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00};
     auto module = fizzy_parse(wasm_prefix, sizeof(wasm_prefix));
 
-    auto instance = fizzy_instantiate(module, nullptr);
+    auto instance = fizzy_instantiate(module, nullptr, 0);
     EXPECT_TRUE(instance);
 
     fizzy_free_instance(instance);
@@ -48,7 +48,7 @@ TEST(capi, execute)
 
     auto module = fizzy_parse(wasm.data(), wasm.size());
 
-    auto instance = fizzy_instantiate(module, nullptr);
+    auto instance = fizzy_instantiate(module, nullptr, 0);
 
     auto res = fizzy_execute(instance, 0, nullptr, 0, 0);
     EXPECT_FALSE(res.trapped);
@@ -86,9 +86,7 @@ TEST(capi, execute_with_host_function)
          },
             nullptr}};
 
-    auto imported_funcs = fizzy_new_external_function_vector(host_funcs, 2);
-
-    auto instance = fizzy_instantiate(module, imported_funcs);
+    auto instance = fizzy_instantiate(module, host_funcs, 2);
 
     auto res = fizzy_execute(instance, 0, nullptr, 0, 0);
     EXPECT_FALSE(res.trapped);
@@ -119,7 +117,7 @@ TEST(capi, imported_function_from_another_module)
     const auto bin1 = from_hex(
         "0061736d0100000001070160027f7f017f030201000707010373756200000a09010700200020016b0b");
     auto module1 = fizzy_parse(bin1.data(), bin1.size());
-    auto instance1 = fizzy_instantiate(module1, nullptr);
+    auto instance1 = fizzy_instantiate(module1, nullptr, 0);
 
     /* wat2wasm
     (module
@@ -146,9 +144,7 @@ TEST(capi, imported_function_from_another_module)
     };
     fizzy_external_function host_funcs[] = {{sub, instance1}};
 
-    auto imported_funcs = fizzy_new_external_function_vector(host_funcs, 1);
-
-    auto instance2 = fizzy_instantiate(module2, imported_funcs);
+    auto instance2 = fizzy_instantiate(module2, host_funcs, 1);
 
     fizzy_value args[] = {{44}, {2}};
     auto res2 = fizzy_execute(instance2, 1, args, 2, 0);