Use new execution_status

lib/fizzy/execute.cpp

@@ -276,16 +276,16 @@ bool invoke_function(
 
     const auto ret = func(instance, std::move(call_args), depth + 1);
     // Bubble up traps
-    if (ret.trapped)
+    if (ret.trapped())
         return false;
 
     const auto num_outputs = func_type.outputs.size();
     // NOTE: we can assume these two from validation
     assert(num_outputs <= 1);
-    assert(ret.result.has_value() == (num_outputs == 1));
+    assert(ret.has_value() == (num_outputs == 1));
     // Push back the result
     if (num_outputs != 0)
-        stack.push(*ret.result);
+        stack.push(ret.value());
 
     return true;
 }
@@ -564,7 +564,7 @@ std::unique_ptr<Instance> instantiate(Module module,
     {
         const auto funcidx = *instance->module.startfunc;
         assert(funcidx < instance->imported_functions.size() + instance->module.funcsec.size());
-        if (execute(*instance, funcidx, {}).trapped)
+        if (execute(*instance, funcidx, {}).trapped())
         {
             // When element section modified imported table, and then start function trapped,
             // modifications to the table are not rolled back.
@@ -604,7 +604,7 @@ execution_result execute(
 {
     assert(depth >= 0);
     if (depth > CallStackLimit)
-        return {true, {}};
+        return {execution_result::status::Trapped, 0};
 
     if (func_idx < instance.imported_functions.size())
         return instance.imported_functions[func_idx].function(instance, std::move(args), depth);
@@ -1462,10 +1462,11 @@ execution_result execute(
 end:
     assert(pc == &code.instructions[code.instructions.size()] || trap);
     if (trap)
+        return {execution_result::status::Trapped, 0};
     if (stack.size() == 0)
-        return {execution, std::nullopt};
+        return {execution_result::status::WithoutResult, 0};
     else
-        return {trap, stack.pop()};
+        return {execution_result::status::WithResult, stack.pop()};
 }
 
 std::vector<ExternalFunction> resolve_imported_functions(