I once wrote a C++ class that convert OS signals to exceptions. The
problem is what to do when you catch the signal, as Alf said, when you
encounter a bug you should fix it. But if you have a program that does
large iterations and kind of clean itself between iterations it might
be helpfull:
#ifndef SIG_EXCEPT_H
#define SIG_EXCEPT_H
/*************** *************** *************** *************** *************** ****
File name : sigexception.h
Programmer : Yuval Lifshitz
Date : 03-sep-2003
Description : Try/Catch mechanism for OS signals.
Usage example:
TRY {
// write code here
}
CATCH {
// write code here
ex.WriteMsg();
cout << "signal number = " << ex.getSignal() << endl;
}
Notes: (1) This mechanism is NOT thread safe.
(2) The CATCH macro must follow immediatly after the
closing brackets of the TRY macro
(3) inside the CATCH block there exists a local variable
named ex holding the thrown signal data.
Change log : 23-sep-2004 make gcc compatible
add thread index hashing
*************** *************** *************** *************** *************** ****/
// include files
#include <stack>
#include <iostream>
#include <pthread.h>
#include <signal.h>
#include <setjmp.h>
// signal description list - used at the psignal function
extern const char *const sys_siglist[];
// jump function type
extern "C" {
typedef void (*jump_func_t)( int);
}
// main class definition
class TryCatchAsync
{
public:
// const and enum
enum {MAX_THREAD_NUM = 100};
//---------------------------
// internal class/type definitions
//---------------------------
//---------------------------------------------------------------
// Class Name : sigjmp_containe r
// Description : Container to encapsulate the sigjmp_buf type.
// This is done for the conviniece of allocation,
// since the original type is an array of integers.
//----------------------------------------------------------------
class sigjmp_containe r {
private:
sigjmp_buf m_sigbuf;
public:
sigjmp_containe r() {}
~sigjmp_contain er() {}
operator sigjmp_buf * ()
{
return &m_sigbuf;
}
sigjmp_buf * get_buf()
{
return &m_sigbuf;
}
};
//-----------------------------------------------
// Class Name : Exception
// Description : The exception thrown by the try
//-----------------------------------------------
class Exception {
public:
Exception(int sig) : m_sig(sig) {}
int getSignal() const
{
return m_sig;
}
void WriteMsg() const
{
psignal(m_sig, "signal thrown");
}
private:
int m_sig;
};
// jump adresses stack type
typedef std::stack<sigj mp_container> jump_stack_t;
// the constructor is used to generate the array of jump functions
// the object should be instanciated only once - but has no effect
// if instanciated more then once, since the relevant execution
// is done in compile time
// constructor
TryCatchAsync() ;
// destructor
~TryCatchAsync( ) {}
// static member functions
static void SigMaskAdd(int sig);
static void Push(sigjmp_con tainer &curr_addr);
static void Throw();
static int GetThreadIndex( );
// member functions
template <int func_id>
static void Jump(int sig)
{
pthread_t pt = GetThreadIndex( );
m_sig[pt] = sig;
siglongjmp(*(si gjmp_buf *)m_addr[pt].top().get_buf( ), 1);
}
private:
// data members
static int m_sig[MAX_THREAD_NUM];
static jump_stack_t m_addr[MAX_THREAD_NUM];
static jump_func_t m_jump_func[MAX_THREAD_NUM];
};
//-----------------------------------------------
// Class Name : JUMP_FUNC_GENER ATOR
// Description : a template struct that instanciate
// an array of different "Jump" functions.
// Note: this is done in a "generative programming"
// method in compile time.
//-----------------------------------------------
template <int N>
struct JUMP_FUNC_GENER ATOR
{
JUMP_FUNC_GENER ATOR(jump_func_ t *jump_func_arr)
{
jump_func_arr[N-1] = TryCatchAsync:: Jump<N-1>;
JUMP_FUNC_GENER ATOR<N-1> tmp_creator(jum p_func_arr);
tmp_creator = tmp_creator; // to avoid "unusead variable" warning
}
};
// termination condition for the generative process
template <>
struct JUMP_FUNC_GENER ATOR<0>
{
JUMP_FUNC_GENER ATOR(jump_func_ t *jump_func_arr)
{
jump_func_arr[0] = TryCatchAsync:: Jump<0>;
}
};
//------------------
// macro definitions
//------------------
#define SIG_INIT \
TryCatchAsync:: SigMaskAdd(SIGF PE); \
TryCatchAsync:: SigMaskAdd(SIGS EGV); \
TryCatchAsync:: SigMaskAdd(SIGI LL); \
TryCatchAsync:: SigMaskAdd(SIGB US);
// note: new signals should be added in the SIG_INIT macro
#define TRY SIG_INIT try { TryCatchAsync:: sigjmp_containe r curr_addr;\
if (sigsetjmp(*(si gjmp_buf *)curr_addr, 1) == 0) { \
TryCatchAsync:: Push(curr_addr) ; \
} \
else { \
TryCatchAsync:: Throw(); \
}
#define CATCH } catch(TryCatchA sync::Exception &ex)
#endif // RSEXCEPT_H
