capi: Add FizzyFunctionType

Author: gumb0

include/fizzy/fizzy.h

@@ -55,18 +55,18 @@ static const FizzyValueType FizzyValueTypeI32 = 0x7f;
 static const FizzyValueType FizzyValueTypeI64 = 0x7e;
 static const FizzyValueType FizzyValueTypeF32 = 0x7d;
 static const FizzyValueType FizzyValueTypeF64 = 0x7c;
+/// Special value, can be used only as function output type.
+static const FizzyValueType FizzyValueTypeVoid = 0;
 
 /// Function type.
 typedef struct FizzyFunctionType
 {
+    /// Output type, equals to FizzyValueTypeVoid, iff function has no output.
+    FizzyValueType output;
     /// Pointer to input types array.
     const FizzyValueType* inputs;
     /// Input types array size.
     size_t inputs_size;
-    /// Pointer to output types array.
-    const FizzyValueType* outputs;
-    /// Output types array size.
-    size_t outputs_size;
 } FizzyFunctionType;
 
 /// External function.

lib/fizzy/capi.cpp

@@ -27,27 +27,31 @@ inline const FizzyValueType* wrap(const fizzy::ValType* value_types) noexcept
     return reinterpret_cast<const FizzyValueType*>(value_types);
 }
 
+inline FizzyValueType wrap(fizzy::ValType value_type) noexcept
+{
+    return static_cast<FizzyValueType>(value_type);
+}
+
 inline fizzy::ValType unwrap(FizzyValueType value_type) noexcept
 {
     return static_cast<fizzy::ValType>(value_type);
 }
 
 inline FizzyFunctionType wrap(const fizzy::FuncType& type) noexcept
 {
-    return {(type.inputs.empty() ? nullptr : wrap(&type.inputs[0])), type.inputs.size(),
-        (type.outputs.empty() ? nullptr : wrap(&type.outputs[0])), type.outputs.size()};
+    return {(type.outputs.empty() ? FizzyValueTypeVoid : wrap(type.outputs[0])),
+        (type.inputs.empty() ? nullptr : wrap(&type.inputs[0])), type.inputs.size()};
 }
 
 inline fizzy::FuncType unwrap(const FizzyFunctionType& type)
 {
     fizzy::FuncType func_type{std::vector<fizzy::ValType>(type.inputs_size),
-        std::vector<fizzy::ValType>(type.outputs_size)};
+        (type.output == FizzyValueTypeVoid ? std::vector<fizzy::ValType>{} :
+                                             std::vector<fizzy::ValType>{unwrap(type.output)})};
 
     fizzy::ValType (*unwrap_valtype_fn)(FizzyValueType value) = &unwrap;
     std::transform(
         type.inputs, type.inputs + type.inputs_size, func_type.inputs.begin(), unwrap_valtype_fn);
-    std::transform(type.outputs, type.outputs + type.outputs_size, func_type.outputs.begin(),
-        unwrap_valtype_fn);
 
     return func_type;
 }

test/unittests/capi_test.cpp

@@ -48,25 +48,23 @@ TEST(capi, get_function_type)
 
     const auto type0 = fizzy_get_function_type(module, 0);
     EXPECT_EQ(type0.inputs_size, 0);
-    EXPECT_EQ(type0.outputs_size, 0);
+    EXPECT_EQ(type0.output, FizzyValueTypeVoid);
 
     const auto type1 = fizzy_get_function_type(module, 1);
     EXPECT_EQ(type1.inputs_size, 2);
     EXPECT_EQ(type1.inputs[0], FizzyValueTypeI32);
     EXPECT_EQ(type1.inputs[1], FizzyValueTypeI32);
-    EXPECT_EQ(type1.outputs_size, 1);
-    EXPECT_EQ(type1.outputs[0], FizzyValueTypeI32);
+    EXPECT_EQ(type1.output, FizzyValueTypeI32);
 
     const auto type2 = fizzy_get_function_type(module, 2);
     EXPECT_EQ(type2.inputs_size, 1);
     EXPECT_EQ(type2.inputs[0], FizzyValueTypeI64);
-    EXPECT_EQ(type2.outputs_size, 0);
+    EXPECT_EQ(type2.output, FizzyValueTypeVoid);
 
     const auto type3 = fizzy_get_function_type(module, 3);
     EXPECT_EQ(type3.inputs_size, 1);
     EXPECT_EQ(type3.inputs[0], FizzyValueTypeF64);
-    EXPECT_EQ(type3.outputs_size, 1);
-    EXPECT_EQ(type3.outputs[0], FizzyValueTypeF32);
+    EXPECT_EQ(type3.output, FizzyValueTypeF32);
 
     fizzy_free_module(module);
 }
@@ -126,9 +124,7 @@ TEST(capi, instantiate_imported_function)
     module = fizzy_parse(wasm.data(), wasm.size());
     ASSERT_NE(module, nullptr);
 
-    const auto output = FizzyValueTypeI32;
-
-    FizzyExternalFunction host_funcs[] = {{{nullptr, 0, &output, 1},
+    FizzyExternalFunction host_funcs[] = {{{FizzyValueTypeI32, nullptr, 0},
         [](void*, FizzyInstance*, const FizzyValue*, int) {
             return FizzyExecutionResult{false, true, {42}};
         },
@@ -252,14 +248,13 @@ TEST(capi, execute_with_host_function)
     ASSERT_NE(module, nullptr);
 
     const FizzyValueType inputs[] = {FizzyValueTypeI32, FizzyValueTypeI32};
-    const FizzyValueType output = FizzyValueTypeI32;
 
-    FizzyExternalFunction host_funcs[] = {{{nullptr, 0, &output, 1},
+    FizzyExternalFunction host_funcs[] = {{{FizzyValueTypeI32, nullptr, 0},
                                               [](void*, FizzyInstance*, const FizzyValue*, int) {
                                                   return FizzyExecutionResult{false, true, {42}};
                                               },
                                               nullptr},
-        {{&inputs[0], 2, &output, 1},
+        {{FizzyValueTypeI32, &inputs[0], 2},
             [](void*, FizzyInstance*, const FizzyValue* args, int) {
                 return FizzyExecutionResult{false, true, {args[0].i64 / args[1].i64}};
             },
@@ -289,9 +284,7 @@ TEST(capi, imported_function_traps)
     auto module = fizzy_parse(wasm.data(), wasm.size());
     ASSERT_NE(module, nullptr);
 
-    const FizzyValueType output = FizzyValueTypeI32;
-
-    FizzyExternalFunction host_funcs[] = {{{nullptr, 0, &output, 1},
+    FizzyExternalFunction host_funcs[] = {{{FizzyValueTypeI32, nullptr, 0},
         [](void*, FizzyInstance*, const FizzyValue*, int) {
             return FizzyExecutionResult{true, false, {}};
         },
@@ -384,9 +377,8 @@ TEST(capi, imported_function_from_another_module)
     };
 
     const FizzyValueType inputs[] = {FizzyValueTypeI32, FizzyValueTypeI32};
-    const FizzyValueType output = FizzyValueTypeI32;
 
-    FizzyExternalFunction host_funcs[] = {{{&inputs[0], 2, &output, 1}, sub, &host_context}};
+    FizzyExternalFunction host_funcs[] = {{{FizzyValueTypeI32, &inputs[0], 2}, sub, &host_context}};
 
     auto instance2 = fizzy_instantiate(module2, host_funcs, 1);
     ASSERT_NE(instance2, nullptr);