---

more/cf/signal.h

Go to the documentation of this file.

//  Copyright (C) 1999--2001  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This file is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: signal.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $



#ifndef MORE_CF_SIGNAL_H
#define MORE_CF_SIGNAL_H

#include <exception>
#include <csignal>

#define MORE_CF_POINTCHECKER_COUNT_MAX 64



namespace more {
namespace cf {

  ///\if bits
  namespace bits {
    extern int pending_signal;

    extern void (*pointcheckers[MORE_CF_POINTCHECKER_COUNT_MAX])();
    extern int n_pointcheckers;

    void dispatch_signal();
  }
  ///\endif

  /** Exception to be thrown upon signals.  This exception is thrown
      by pointchecker after a signal is raised which was earlier
      registered to be handled by calling handle_signal.  This
      exception is subclassed for a few selected signals. */
  struct signal_raised : std::exception
  {
      explicit signal_raised(int i) : m_signo(i) {}

      int which() const { return m_signo; }

      virtual char const* what() const throw();

    private:
      int m_signo;
  };

  /** Exception to be thrown upon SIGINT. */
  struct sigint_raised  : signal_raised { sigint_raised();  };  // SIGINT

  /** Exception to be thrown upon SIGFPE. */
  struct sigfpe_raised  : signal_raised { sigfpe_raised();  };  // SIGFPE

  /** Exception to be thrown upon SIGALRM. */
  struct sigalrm_raised : signal_raised { sigalrm_raised(); }; // SIGALRM

  /** Exception to be thrown upon SIGSEGV. */
  struct sigsegv_raised : signal_raised { sigsegv_raised(); }; // SIGSEGV

#if defined(MORE_BACKWARD) && MORE_BACKWARD < 20010522
  typedef sigint_raised program_interrupt;
  typedef sigfpe_raised float_error;
  typedef sigalrm_raised timeout;
  typedef sigsegv_raised segmentation_fault;
#endif

  /** Check for signals, thread cancels and such at this point.  The
      actual code that is run by checkpoint is registered with
      register_pointchecker.  It is typically used to throw exceptions
      upon signals or thread cancel. */
  inline void
  checkpoint()
  {
      if (bits::pending_signal)
          bits::dispatch_signal();
      for(int i = 0; i < bits::n_pointcheckers; ++i)
          bits::pointcheckers[i]();
  }

  /** Register a function to be run by checkpoint.  It is important to
      the efficiency to keep the number of registered pointcheckers at
      an absolute minimum, as checkpoint must call them all.
      Therefore, the intention is that each library using libmore
      registers only one pointchecker if reeded, and does all checks
      there.  There is an arbitrary limit of to the number of
      pointcheckers that can be registered, and an exception is thrown
      if this limit is exceeded.  */
  void register_pointchecker(void (*)());

  /** Unregister a function registered by register_pointchecker. */
  void unregister_pointchecker(void (*)());

  /** Install a pointchecker to throw an exception upon the signal \a sig. */
  void handle_signal(int sig);

  /** Handle \c SIGINT so that it does not quit the program at once
      but allows the application to clean up.  After the first \c
      SIGINT, a message is printed to the screen saying that CTRL-C
      must be pressed once more for immediate termination, and that is
      what happens if the program receives another \c SIGINT.  If
      checkpoint() is called before that, an exception is thrown,
      giving the application a chance to make a breathtaking exit. */
  void enable_delayed_interrupt();

  /** Handle the signal that will cause \a xc to be thrown. */
  template<typename SignalException>
    void handle_signal(SignalException const& xc)
    {
        handle_signal(xc.which());
    }

}} // more::cf

#endif

---