quickcpplib::_xxx::signal_guard Namespace Reference

The namespace for signal_guard. More...

Namespaces
namespace	detail

Classes
class	signal_guard_global_decider
	Install a global signal continuation decider. More...
class	signal_guard_install
	On platforms where it is necessary (POSIX), installs, and potentially enables, the global signal handlers for the signals specified by guarded. Each signal installed is threadsafe reference counted, so this is safe to call from multiple threads or instantiate multiple times. It is also guaranteed safe to call from within static data init or deinit, so a very common use case is simply to place an instance into global static data. This ensures that dynamically loaded and unloaded shared objects compose signal guards appropriately. More...
class	signal_guard_watchdog
	Call an optional specified routine after a period of time, possibly on another thread. Async signal safe. More...
class	signal_raised
	Thrown by the default signal handler to abort the current operation. More...

Typedefs
using	raised_signal_info = ::raised_signal_info

Enumerations
enum class	signalc {   none = 0 , abort_process = SIGABRT , undefined_memory_access = SIGBUS , illegal_instruction = SIGILL ,   interrupt , broken_pipe = SIGPIPE , segmentation_fault = SIGSEGV , floating_point_error = SIGFPE ,   process_terminate , timer_expire = SIGALRM , child_exit = SIGCHLD , process_continue = SIGCONT ,   tty_hangup = SIGHUP , process_kill = SIGKILL , profile_event = SIGPROF , process_quit = SIGQUIT ,   process_stop = SIGSTOP , tty_stop = SIGTSTP , bad_system_call = SIGSYS , process_trap = SIGTRAP ,   tty_input = SIGTTIN , tty_output = SIGTTOU , urgent_condition = SIGURG , user_defined1 = SIGUSR1 ,   user_defined2 = SIGUSR2 , virtual_alarm_clock = SIGVTALRM , cpu_time_limit_exceeded = SIGXCPU , file_size_limit_exceeded = SIGXFSZ ,   cxx_out_of_memory = 32 , cxx_termination = 33 , _max_value }
	The signals which are supported. More...

Functions
	QUICKCPPLIB_BITFIELD_BEGIN_T (signalc_set, uint64_t)
	Bitfield for the signals which are supported.
template<class U , typename = decltype( std::declval<U>()((raised_signal_info *) 0) )>
signal_guard_global_decider< std::decay_t< U > >	make_signal_guard_global_decider (signalc_set guarded, U &&f, bool callfirst=false)
	Convenience instantiator of signal_guard_global_decider.
SIGNALGUARD_FUNC_DECL bool	thrd_raise_signal (signalc signo, void *raw_info=nullptr, void *raw_context=nullptr)
	Call the currently installed signal handler for a signal (POSIX), or raise a Win32 structured exception (Windows), returning false if no handler was called due to the currently installed handler being SIG_IGN (POSIX).
QUICKCPPLIB_NORETURN SIGNALGUARD_FUNC_DECL void	terminate_process_immediately (const char *msg=nullptr) noexcept
	This initiates a fast fail process termination which immediately exits the process without calling any handlers: on POSIX, this is SIGKILL, on Windows this is TerminateProcess().
template<class U , typename = decltype( std::declval<U>()() )>
signal_guard_watchdog< std::decay_t< U > >	make_signal_guard_watchdog (U &&f, unsigned ms=3000)
	Convenience instantiator of signal_guard_watchdog.
signal_guard_watchdog< detail::invoke_terminate_process_immediately >	make_signal_guard_watchdog (unsigned ms=3000)
	Convenience instantiator of signal_guard_watchdog.
template<class F , class H , class C , class... Args, class R = decltype(std::declval<F>()(std::declval<Args>()...)), typename std::enable_if<(detail::is_constructible_or_void< R, decltype(std::declval< H >()(std::declval< const raised_signal_info * >()))>::value), bool >::type = true, typename std::enable_if<(detail::is_constructible_or_void< bool, decltype(std::declval< C >()(std::declval< raised_signal_info * >()))>::value), bool >::type = true>
R	signal_guard (signalc_set guarded, F &&f, H &&h, C &&c, Args &&...args)
template<class F , class R = decltype(std::declval<F>()())>
R	signal_guard (signalc_set guarded, F &&f)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<class F , class H , class R = decltype(std::declval<F>()()), typename std::enable_if<(detail::is_constructible_or_void< R, decltype(std::declval< H >()(std::declval< const raised_signal_info * >()))>::value), bool >::type = true>
auto	signal_guard (signalc_set guarded, F &&f, H &&h)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Detailed Description

The namespace for signal_guard.

Typedef Documentation

raised_signal_info

using quickcpplib::_xxx::signal_guard::raised_signal_info = typedef ::raised_signal_info

Enumeration Type Documentation

signalc

enum class quickcpplib::_xxx::signal_guard::signalc

strong

The signals which are supported.

Enumerator
none
abort_process	The process is aborting (SIGABRT)
undefined_memory_access	Attempt to access a memory location which can't exist (SIGBUS)
illegal_instruction	Execution of illegal instruction (SIGILL)
interrupt	The process is interrupted (SIGINT). Note on Windows the continuation decider is ALWAYS called from a separate thread, and the process exits after you return (or take too long executing).
broken_pipe	Reader on a pipe vanished (SIGPIPE). Note that Windows never raises this signal.
segmentation_fault	Attempt to access a memory page whose permissions disallow (SIGSEGV)
floating_point_error	Floating point error (SIGFPE)
process_terminate	Process termination requested (SIGTERM). Note on Windows the handler is ALWAYS called from a separate thread, and the process exits after you return (or take too long executing).
timer_expire	Timer has expired (SIGALRM). POSIX only.
child_exit	Child has exited (SIGCHLD). POSIX only.
process_continue	Process is being continued (SIGCONT). POSIX only.
tty_hangup	Controlling terminal has hung up (SIGHUP). POSIX only.
process_kill	Process has received kill signal (SIGKILL). POSIX only.
profile_event	Profiling timer expired (SIGPROF). POSIX only.
process_quit	Process is being quit (SIGQUIT). POSIX only.
process_stop	Process is being stopped (SIGSTOP). POSIX only.
tty_stop	Terminal requests stop (SIGTSTP). POSIX only.
bad_system_call	Bad system call (SIGSYS). POSIX only.
process_trap	Process has reached a breakpoint (SIGTRAP). POSIX only.
tty_input	Terminal has input (SIGTTIN). POSIX only.
tty_output	Terminal ready for output (SIGTTOU). POSIX only.
urgent_condition	Urgent condition (SIGURG). POSIX only.
user_defined1	User defined 1 (SIGUSR1). POSIX only.
user_defined2	User defined 2 (SIGUSR2). POSIX only.
virtual_alarm_clock	Virtual alarm clock (SIGVTALRM). POSIX only.
cpu_time_limit_exceeded	CPU time limit exceeded (SIGXCPU). POSIX only.
file_size_limit_exceeded	File size limit exceeded (SIGXFSZ). POSIX only.
cxx_out_of_memory	A call to operator new failed, and a throw is about to occur.
cxx_termination	A call to std::terminate() was made. NOT SIGTERM.
_max_value

  {
    none = 0,
 
    abort_process = SIGABRT,           //!< The process is aborting (`SIGABRT`)
    undefined_memory_access = SIGBUS,  //!< Attempt to access a memory location which can't exist (`SIGBUS`)
    illegal_instruction = SIGILL,      //!< Execution of illegal instruction (`SIGILL`)
    interrupt =
    SIGINT,  //!< The process is interrupted (`SIGINT`). Note on Windows the continuation decider is ALWAYS called from a separate thread, and the process exits after you return (or take too long executing).
    broken_pipe = SIGPIPE,  //!< Reader on a pipe vanished (`SIGPIPE`). Note that Windows never raises this signal.
    segmentation_fault = SIGSEGV,   //!< Attempt to access a memory page whose permissions disallow (`SIGSEGV`)
    floating_point_error = SIGFPE,  //!< Floating point error (`SIGFPE`)
    process_terminate =
    SIGTERM,  //!< Process termination requested (`SIGTERM`). Note on Windows the handler is ALWAYS called from a separate thread, and the process exits after you return (or take too long executing).
 
#ifndef _WIN32
    timer_expire = SIGALRM,      //!< Timer has expired (`SIGALRM`). POSIX only.
    child_exit = SIGCHLD,        //!< Child has exited (`SIGCHLD`). POSIX only.
    process_continue = SIGCONT,  //!< Process is being continued (`SIGCONT`). POSIX only.
    tty_hangup = SIGHUP,         //!< Controlling terminal has hung up (`SIGHUP`). POSIX only.
    process_kill = SIGKILL,      //!< Process has received kill signal (`SIGKILL`). POSIX only.
#ifdef SIGPOLL
    pollable_event = SIGPOLL,  //!< i/o is now possible (`SIGPOLL`). POSIX only.
#endif
    profile_event = SIGPROF,             //!< Profiling timer expired (`SIGPROF`). POSIX only.
    process_quit = SIGQUIT,              //!< Process is being quit (`SIGQUIT`). POSIX only.
    process_stop = SIGSTOP,              //!< Process is being stopped (`SIGSTOP`). POSIX only.
    tty_stop = SIGTSTP,                  //!< Terminal requests stop (`SIGTSTP`). POSIX only.
    bad_system_call = SIGSYS,            //!< Bad system call (`SIGSYS`). POSIX only.
    process_trap = SIGTRAP,              //!< Process has reached a breakpoint (`SIGTRAP`). POSIX only.
    tty_input = SIGTTIN,                 //!< Terminal has input (`SIGTTIN`). POSIX only.
    tty_output = SIGTTOU,                //!< Terminal ready for output (`SIGTTOU`). POSIX only.
    urgent_condition = SIGURG,           //!< Urgent condition (`SIGURG`). POSIX only.
    user_defined1 = SIGUSR1,             //!< User defined 1 (`SIGUSR1`). POSIX only.
    user_defined2 = SIGUSR2,             //!< User defined 2 (`SIGUSR2`). POSIX only.
    virtual_alarm_clock = SIGVTALRM,     //!< Virtual alarm clock (`SIGVTALRM`). POSIX only.
    cpu_time_limit_exceeded = SIGXCPU,   //!< CPU time limit exceeded (`SIGXCPU`). POSIX only.
    file_size_limit_exceeded = SIGXFSZ,  //!< File size limit exceeded (`SIGXFSZ`). POSIX only.
#endif
 
    /* C++ handlers
    On all the systems I examined, all signal numbers are <= 30 in order to fit inside a sigset_t.
    Note that apparently IBM uses the full 32 bit range in its signal numbers.
    */
    cxx_out_of_memory = 32,  //!< A call to operator new failed, and a throw is about to occur
    cxx_termination = 33,    //!< A call to std::terminate() was made. NOT `SIGTERM`.
 
    _max_value
  };

Function Documentation

QUICKCPPLIB_BITFIELD_BEGIN_T()

quickcpplib::_xxx::signal_guard::QUICKCPPLIB_BITFIELD_BEGIN_T	(	signalc_set	,
		uint64_t
	)

Bitfield for the signals which are supported.

< The process is aborting (SIGABRT)

< Attempt to access a memory location which can't exist (SIGBUS)

< Execution of illegal instruction (SIGILL)

< The process is interrupted (SIGINT). Note on Windows the handler is ALWAYS called from a separate thread, and the process exits after you return (or take too long executing).

< Reader on a pipe vanished (SIGPIPE). Note that Windows never raises this signal.

< Attempt to access a memory page whose permissions disallow (SIGSEGV)

< Floating point error (SIGFPE)

< Process termination requested (SIGTERM). Note on Windows the handler is ALWAYS called from a separate thread, and the process exits after you return (or take too long executing).

< Timer has expired (SIGALRM). POSIX only.

< Child has exited (SIGCHLD). POSIX only.

< Process is being continued (SIGCONT). POSIX only.

< Controlling terminal has hung up (SIGHUP). POSIX only.

< Process has received kill signal (SIGKILL). POSIX only.

< Profiling timer expired (SIGPROF). POSIX only.

< Process is being quit (SIGQUIT). POSIX only.

< Process is being stopped (SIGSTOP). POSIX only.

< Terminal requests stop (SIGTSTP). POSIX only.

< Bad system call (SIGSYS). POSIX only.

< Process has reached a breakpoint (SIGTRAP). POSIX only.

< Terminal has input (SIGTTIN). POSIX only.

< Terminal ready for output (SIGTTOU). POSIX only.

< Urgent condition (SIGURG). POSIX only.

< User defined 1 (SIGUSR1). POSIX only.

< User defined 2 (SIGUSR2). POSIX only.

< Virtual alarm clock (SIGVTALRM). POSIX only.

< CPU time limit exceeded (SIGXCPU). POSIX only.

< File size limit exceeded (SIGXFSZ). POSIX only.

< A call to operator new failed, and a throw is about to occur

< A call to std::terminate() was made

                                                     {
  none = 0,
 
  abort_process = (1ULL << static_cast<int>(signalc::abort_process)),  //!< The process is aborting (`SIGABRT`)
  undefined_memory_access =
  (1ULL << static_cast<int>(
   signalc::undefined_memory_access)),  //!< Attempt to access a memory location which can't exist (`SIGBUS`)
  illegal_instruction =
  (1ULL << static_cast<int>(signalc::illegal_instruction)),  //!< Execution of illegal instruction (`SIGILL`)
  interrupt =
  (1ULL << static_cast<int>(
   signalc::
   interrupt)),  //!< The process is interrupted (`SIGINT`). Note on Windows the handler is ALWAYS called from a separate thread, and the process exits after you return (or take too long executing).
  broken_pipe =
  (1ULL << static_cast<int>(
   signalc::broken_pipe)),  //!< Reader on a pipe vanished (`SIGPIPE`). Note that Windows never raises this signal.
  segmentation_fault =
  (1ULL << static_cast<int>(
   signalc::segmentation_fault)),  //!< Attempt to access a memory page whose permissions disallow (`SIGSEGV`)
  floating_point_error =
  (1ULL << static_cast<int>(signalc::floating_point_error)),  //!< Floating point error (`SIGFPE`)
  process_terminate =
  (1ULL << static_cast<int>(
   signalc::
   process_terminate)),  //!< Process termination requested (`SIGTERM`). Note on Windows the handler is ALWAYS called from a separate thread, and the process exits after you return (or take too long executing).
 
 
#ifndef _WIN32
  timer_expire = (1ULL << static_cast<int>(signalc::timer_expire)),  //!< Timer has expired (`SIGALRM`). POSIX only.
  child_exit = (1ULL << static_cast<int>(signalc::child_exit)),      //!< Child has exited (`SIGCHLD`). POSIX only.
  process_continue =
  (1ULL << static_cast<int>(signalc::process_continue)),  //!< Process is being continued (`SIGCONT`). POSIX only.
  tty_hangup =
  (1ULL << static_cast<int>(signalc::tty_hangup)),  //!< Controlling terminal has hung up (`SIGHUP`). POSIX only.
  process_kill =
  (1ULL << static_cast<int>(signalc::process_kill)),  //!< Process has received kill signal (`SIGKILL`). POSIX only.
#ifdef SIGPOLL
  pollable_event =
  (1ULL << static_cast<int>(signalc::pollable_event)),  //!< i/o is now possible (`SIGPOLL`). POSIX only.
#endif
  profile_event =
  (1ULL << static_cast<int>(signalc::profile_event)),  //!< Profiling timer expired (`SIGPROF`). POSIX only.
  process_quit = (1ULL << static_cast<int>(signalc::process_quit)),  //!< Process is being quit (`SIGQUIT`). POSIX only.
  process_stop =
  (1ULL << static_cast<int>(signalc::process_stop)),         //!< Process is being stopped (`SIGSTOP`). POSIX only.
  tty_stop = (1ULL << static_cast<int>(signalc::tty_stop)),  //!< Terminal requests stop (`SIGTSTP`). POSIX only.
  bad_system_call = (1ULL << static_cast<int>(signalc::bad_system_call)),  //!< Bad system call (`SIGSYS`). POSIX only.
  process_trap =
  (1ULL << static_cast<int>(signalc::process_trap)),  //!< Process has reached a breakpoint (`SIGTRAP`). POSIX only.
  tty_input = (1ULL << static_cast<int>(signalc::tty_input)),    //!< Terminal has input (`SIGTTIN`). POSIX only.
  tty_output = (1ULL << static_cast<int>(signalc::tty_output)),  //!< Terminal ready for output (`SIGTTOU`). POSIX only.
  urgent_condition =
  (1ULL << static_cast<int>(signalc::urgent_condition)),               //!< Urgent condition (`SIGURG`). POSIX only.
  user_defined1 = (1ULL << static_cast<int>(signalc::user_defined1)),  //!< User defined 1 (`SIGUSR1`). POSIX only.
  user_defined2 = (1ULL << static_cast<int>(signalc::user_defined2)),  //!< User defined 2 (`SIGUSR2`). POSIX only.
  virtual_alarm_clock =
  (1ULL << static_cast<int>(signalc::virtual_alarm_clock)),  //!< Virtual alarm clock (`SIGVTALRM`). POSIX only.
  cpu_time_limit_exceeded =
  (1ULL << static_cast<int>(signalc::cpu_time_limit_exceeded)),  //!< CPU time limit exceeded (`SIGXCPU`). POSIX only.
  file_size_limit_exceeded =
  (1ULL << static_cast<int>(signalc::file_size_limit_exceeded)),  //!< File size limit exceeded (`SIGXFSZ`). POSIX only.
#endif
 
  // C++ handlers
  cxx_out_of_memory = (1ULL << static_cast<int>(
                       signalc::cxx_out_of_memory)),  //!< A call to operator new failed, and a throw is about to occur
  cxx_termination = (1ULL << static_cast<int>(signalc::cxx_termination))  //!< A call to std::terminate() was made
 
  } QUICKCPPLIB_BITFIELD_END(signalc_set)

make_signal_guard_global_decider()

template<class U , typename = decltype( std::declval<U>()((raised_signal_info *) 0) )>

signal_guard_global_decider< std::decay_t< U > > quickcpplib::_xxx::signal_guard::make_signal_guard_global_decider ( signalc_set  guarded, U &&  f, bool  callfirst = false  )

inline

Convenience instantiator of signal_guard_global_decider.

  {
    return signal_guard_global_decider<std::decay_t<U>>(guarded, static_cast<U &&>(f), callfirst);
  }

thrd_raise_signal()

SIGNALGUARD_FUNC_DECL bool quickcpplib::_xxx::signal_guard::thrd_raise_signal	(	signalc	signo,
		void *	raw_info = nullptr,
		void *	raw_context = nullptr
	)

Call the currently installed signal handler for a signal (POSIX), or raise a Win32 structured exception (Windows), returning false if no handler was called due to the currently installed handler being SIG_IGN (POSIX).

Note that on POSIX, we fetch the currently installed signal handler and try to call it directly. This allows us to supply custom raw_info and raw_context, and we do all the things which the signal handler flags tell us to do beforehand [1]. If the current handler has been defaulted, we enable the signal and execute pthread_kill(pthread_self(), signo) in order to invoke the default handling.

Note that on Windows, raw_context is ignored as there is no way to override the context thrown with a Win32 structured exception.

[1]: We currently do not implement alternative stack switching. If a handler requests that, we simply abort the process. Code donations implementing support are welcome.

terminate_process_immediately()

QUICKCPPLIB_NORETURN SIGNALGUARD_FUNC_DECL void quickcpplib::_xxx::signal_guard::terminate_process_immediately ( const char *  msg = nullptr )

noexcept

This initiates a fast fail process termination which immediately exits the process without calling any handlers: on POSIX, this is SIGKILL, on Windows this is TerminateProcess().

If msg is specified, it async signal safely prints that message before termination. If you don't specify a message (nullptr), a default message is printed. A message of "" prints nothing.

make_signal_guard_watchdog() [1/2]

template<class U , typename = decltype( std::declval<U>()() )>

signal_guard_watchdog< std::decay_t< U > > quickcpplib::_xxx::signal_guard::make_signal_guard_watchdog ( U &&  f, unsigned  ms = 3000  )

inline

Convenience instantiator of signal_guard_watchdog.

  {
    return signal_guard_watchdog<std::decay_t<U>>(static_cast<U &&>(f), ms);
  }

make_signal_guard_watchdog() [2/2]

signal_guard_watchdog< detail::invoke_terminate_process_immediately > quickcpplib::_xxx::signal_guard::make_signal_guard_watchdog ( unsigned  ms = 3000 )

inline

Convenience instantiator of signal_guard_watchdog.

  {
    return signal_guard_watchdog<detail::invoke_terminate_process_immediately>(
    detail::invoke_terminate_process_immediately(), ms);
  }

signal_guard() [1/3]

template<class F , class H , class C , class... Args, class R = decltype(std::declval<F>()(std::declval<Args>()...)), typename std::enable_if<(detail::is_constructible_or_void< R, decltype(std::declval< H >()(std::declval< const raised_signal_info * >()))>::value), bool >::type = true, typename std::enable_if<(detail::is_constructible_or_void< bool, decltype(std::declval< C >()(std::declval< raised_signal_info * >()))>::value), bool >::type = true>

R quickcpplib::_xxx::signal_guard::signal_guard ( signalc_set  guarded, F &&  f, H &&  h, C &&  c, Args &&...  args  )

inline

Call a callable f with signals guarded protected for this thread only, returning whatever f or h returns.

Firstly, how to restore execution to this context is saved, and f(Args...) is executed, returning whatever f(Args...) returns if f completes execution successfully. This is usually inlined code, so it will be quite fast. No memory allocation is performed if a signal_guard_install for the guarded signal set is already instanced. Approximate best case overhead:

• Linux: 28 CPU cycles (Intel CPU), 53 CPU cycles (AMD CPU)
• Windows: 36 CPU cycles (Intel CPU), 68 CPU cycles (AMD CPU)

If during the execution of f, any one of the signals guarded is raised:

1. c, which must have the prototype bool(raised_signal_info *), is called with the signal which was raised. You can fix the cause of the signal and return true to continue execution, or else return false to halt execution. Note that the variety of code you can call in c is extremely limited, the same restrictions as for signal handlers apply. Note that on Windows only, signalc::interrupt and signalc::process_terminate call c from some other kernel thread, and the return value is always ignored (the process is always exited).
2. If c returned false, the execution of f is halted immediately without stack unwind, the thread is returned to the state just before the calling of f, and the callable g is called with the specific signal which occurred. g must have the prototype R(const raised_signal_info *) where R is the return type of f. g is called with this signal guard removed, though a signal guard higher in the call chain may instead be active.

Obviously all state which f may have been in the process of doing will be thrown away, in particular any stack allocated variables not marked volatile will have unspecified values. You should therefore make sure that f never causes side effects, including the interruption in the middle of some operation, which cannot be fixed by the calling of h. The default h simply throws a signal_raised C++ exception.

Note

On POSIX, if a signal_guard_install is not already instanced for the guarded set, one is temporarily installed, which is not quick. You are therefore very strongly recommended, when on POSIX, to call this function with a signal_guard_install already installed for all the signals you will ever guard. signal_guard_install is guaranteed to be composable and be safe to use within static data init, so a common use pattern is simply to place a guard install into your static data init.

On MSVC because std::set_terminate() is thread local, we ALWAYS install our termination handler for every thread on creation and we never uninstall it.

On MSVC, you cannot pass a type with a non-trivial destructor through __try, so this will limit the complexity of types that can be returned directly by this function. You can usually work around this via an intermediate std::optional.

  {
    if(guarded == signalc_set::none)
    {
      return f(static_cast<Args &&>(args)...);
    }
    struct signal_guard_installer final : detail::thread_local_signal_guard
    {
      char _storage[sizeof(signal_guard_install)];
      signal_guard_install *sgi{nullptr};
      C &continuer;
 
      signal_guard_installer(signalc_set guarded, C &c)
          : detail::thread_local_signal_guard(guarded)
          , continuer(c)
      {
#ifndef _WIN32
        uint64_t oldinstalled(detail::signal_guards_installed().load(std::memory_order_relaxed));
        uint64_t newinstalled = oldinstalled | uint64_t(guarded);
        if(newinstalled != oldinstalled)
        {
          // Need a temporary signal guard install
          sgi = new(_storage) signal_guard_install(guarded);
        }
#endif
      }
      ~signal_guard_installer() { reset(); }
      void reset()
      {
#ifndef _WIN32
        if(nullptr != sgi)
        {
          sgi->~signal_guard_install();
        }
#endif
      }
      bool call_continuer() override { return continuer(&this->info); }
    } sgi(guarded, c);
    // Nothing in the C++ standard says that the compiler cannot reorder reads and writes
    // around a setjmp(), so let's prevent that. This is the weak form affecting the
    // compiler reordering only.
    std::atomic_signal_fence(std::memory_order_seq_cst);
    if(setjmp(sgi.info.buf))
    {
      // returning from longjmp, so unset the TLS and call failure handler
      sgi.reset();
      return h(&sgi.info);
    }
    std::atomic_signal_fence(std::memory_order_seq_cst);
#ifdef _WIN32
    // Cannot use __try in a function with non-trivial destructors
    return [&]
    {
      __try
      {
        static_assert(std::is_trivially_destructible<R>::value || std::is_void<R>::value,
                      "On MSVC, the return type of F must be trivially destructible, otherwise the compiler will "
                      "refuse to compile the code.");
        return f(static_cast<Args &&>(args)...);
      }
      __except(detail::win32_exception_filter_function(_exception_code(),
                                                       (struct detail::win32::_EXCEPTION_POINTERS *) _exception_info()))
      {
        longjmp(sgi.info.buf, 1);
      }
    }();
#else
    return f(static_cast<Args &&>(args)...);
#endif
  }

signal_guard() [2/3]

template<class F , class R = decltype(std::declval<F>()())>

R quickcpplib::_xxx::signal_guard::signal_guard ( signalc_set  guarded, F &&  f  )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

  {
    return signal_guard(guarded, static_cast<F &&>(f), detail::throw_signal_raised<R>, detail::continue_or_handle);
  }

signal_guard() [3/3]

template<class F , class H , class R = decltype(std::declval<F>()()), typename std::enable_if<(detail::is_constructible_or_void< R, decltype(std::declval< H >()(std::declval< const raised_signal_info * >()))>::value), bool >::type = true>

auto quickcpplib::_xxx::signal_guard::signal_guard ( signalc_set  guarded, F &&  f, H &&  h  )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

  {
    return signal_guard(guarded, static_cast<F &&>(f), static_cast<H &&>(h), detail::continue_or_handle);
  }