im gay

jumpman.hpp

class Jumpman {
  using default_throw_t = void(*)(void*);

  default_throw_t default_throw;
  void* default_throw_arg;

  std::exception_ptr current_exception;
  std::jmp_buf jmp;
  bool jump_active;

  [[noreturn]] void rethrow_exception();

public:
  Jumpman(default_throw_t default_throw, void* default_throw_arg) noexcept :
    default_throw { default_throw },
    default_throw_arg { default_throw_arg },
    jump_active { }
  { }

  [[noreturn]] void execute_jump();

  void store_exception();

  template <class T, class ...Args>
  decltype(auto) call(T&& func, Args &&...args) {
    if (setjmp(this->jmp)) {
      this->jump_active = false;
      this->rethrow_exception();
    }

    this->current_exception = nullptr;
    this->jump_active = true;

    // We can't use a scope_exit because if an exception is thrown, the entire
    // program unwinds. Otherwise this would be simpler at the end.
    auto cleanup = [&] {
      this->jump_active = false;
      if (this->current_exception) { this->rethrow_exception(); }
    };

    if constexpr (std::is_void_v<std::invoke_result_t<T, Args...>>) {
      std::invoke(std::forward<T>(func), std::forward<Args>(args)...);
      cleanup();
    } else {
      decltype(auto) result = std::invoke(std::forward<T>(func), std::forward<Args>(args)...);
      cleanup();
      return std::forward<decltype(result)>(result);
    }
  }
};