capi: Instantiate with resolving host functions

Author: gumb0

include/fizzy/fizzy.h

@@ -81,6 +81,17 @@ typedef struct FizzyExternalFunction
     void* context;
 } FizzyExternalFunction;
 
+/// Imported function.
+typedef struct FizzyImportedFunction
+{
+    /// Module name. NULL-terminated string. Cannot be NULL.
+    const char* module;
+    /// Function name. NULL-terminated string. Cannot be NULL.
+    const char* name;
+    /// External function, defining its type, pointer to function and context for calling it.
+    FizzyExternalFunction external_function;
+} FizzyImportedFunction;
+
 /// Validate binary module.
 bool fizzy_validate(const uint8_t* wasm_binary, size_t wasm_binary_size);
 
@@ -130,6 +141,9 @@ bool fizzy_find_exported_function(
 FizzyInstance* fizzy_instantiate(const FizzyModule* module,
     const FizzyExternalFunction* imported_functions, size_t imported_functions_size);
 
+struct FizzyInstance* fizzy_resolve_instantiate(const FizzyModule* module,
+    const FizzyImportedFunction* imported_functions, size_t imported_functions_size);
+
 /// Free resources associated with the instance.
 /// If passed pointer is NULL, has no effect.
 void fizzy_free_instance(FizzyInstance* instance);

lib/fizzy/capi.cpp

@@ -111,6 +111,23 @@ inline fizzy::ExternalFunction unwrap(const FizzyExternalFunction& external_func
     return fizzy::ExternalFunction{
         unwrap(external_func.function, external_func.context), unwrap(external_func.type)};
 }
+
+inline fizzy::ImportedFunction unwrap(const FizzyImportedFunction& imported_func)
+{
+    fizzy::ImportedFunction result;
+    result.module = imported_func.module ? std::string{imported_func.module} : std::string{};
+    result.name = imported_func.name ? std::string{imported_func.name} : std::string{};
+
+    fizzy::FuncType type = unwrap(imported_func.external_function.type);
+    result.inputs = std::move(type.inputs);
+    result.output = type.outputs.empty() ? std::nullopt : std::make_optional(type.outputs[0]);
+
+    result.function =
+        unwrap(imported_func.external_function.function, imported_func.external_function.context);
+
+    return result;
+}
+
 }  // namespace
 
 extern "C" {
@@ -182,6 +199,29 @@ FizzyInstance* fizzy_instantiate(const FizzyModule* module,
     }
 }
 
+FizzyInstance* fizzy_resolve_instantiate(const FizzyModule* module,
+    const FizzyImportedFunction* imported_functions, size_t imported_functions_size)
+{
+    try
+    {
+        std::vector<fizzy::ImportedFunction> unwrapped_funcs(imported_functions_size);
+        fizzy::ImportedFunction (*unwrap_imported_func_fn)(const FizzyImportedFunction&) = &unwrap;
+        std::transform(imported_functions, imported_functions + imported_functions_size,
+            unwrapped_funcs.begin(), unwrap_imported_func_fn);
+
+        std::unique_ptr<const fizzy::Module> unwrapped_module{unwrap(module)};
+        auto imports = fizzy::resolve_imported_functions(*unwrapped_module, unwrapped_funcs);
+
+        auto instance = fizzy::instantiate(std::move(unwrapped_module), std::move(imports));
+
+        return wrap(instance.release());
+    }
+    catch (...)
+    {
+        return nullptr;
+    }
+}
+
 void fizzy_free_instance(FizzyInstance* instance)
 {
     delete unwrap(instance);