1375 lines
14 KiB
C
1375 lines
14 KiB
C
#include <signal.h>
|
||
|
||
/* Signal handlers, we set breakpoints in them to make sure that the
|
||
signals really get delivered. */
|
||
|
||
void
|
||
handle_ABRT (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_HUP (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_QUIT (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_ILL (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_EMT (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_FPE (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_BUS (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_SEGV (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_SYS (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_PIPE (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_ALRM (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_URG (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_TSTP (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_CONT (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_CHLD (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_TTIN (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_TTOU (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_IO (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_XCPU (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_XFSZ (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_VTALRM (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_PROF (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_WINCH (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_LOST (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_USR1 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_USR2 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_PWR (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_POLL (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_WIND (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_PHONE (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_WAITING (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_LWP (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_DANGER (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_GRANT (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_RETRACT (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_MSG (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_SOUND (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_SAK (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_PRIO (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_33 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_34 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_35 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_36 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_37 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_38 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_39 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_40 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_41 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_42 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_43 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_44 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_45 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_46 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_47 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_48 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_49 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_50 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_51 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_52 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_53 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_54 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_55 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_56 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_57 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_58 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_59 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_60 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_61 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_62 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_63 (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
void
|
||
handle_TERM (sig)
|
||
int sig;
|
||
{
|
||
}
|
||
|
||
/* Functions to send signals. These also serve as markers. */
|
||
int
|
||
gen_ABRT ()
|
||
{
|
||
kill (getpid (), SIGABRT);
|
||
}
|
||
|
||
int
|
||
gen_HUP ()
|
||
{
|
||
#ifdef SIGHUP
|
||
kill (getpid (), SIGHUP);
|
||
#else
|
||
handle_HUP ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_QUIT ()
|
||
{
|
||
#ifdef SIGQUIT
|
||
kill (getpid (), SIGQUIT);
|
||
#else
|
||
handle_QUIT ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_ILL ()
|
||
{
|
||
#ifdef SIGILL
|
||
kill (getpid (), SIGILL);
|
||
#else
|
||
handle_ILL ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_EMT ()
|
||
{
|
||
#ifdef SIGEMT
|
||
kill (getpid (), SIGEMT);
|
||
#else
|
||
handle_EMT ();
|
||
#endif
|
||
}
|
||
|
||
int x;
|
||
|
||
int
|
||
gen_FPE ()
|
||
{
|
||
/* The intent behind generating SIGFPE this way is to check the mapping
|
||
from the CPU exception itself to the signals. It would be nice to
|
||
do the same for SIGBUS, SIGSEGV, etc., but I suspect that even this
|
||
test might turn out to be insufficiently portable. */
|
||
|
||
#if 0
|
||
/* Loses on the PA because after the signal handler executes we try to
|
||
re-execute the failing instruction again. Perhaps we could siglongjmp
|
||
out of the signal handler? */
|
||
/* The expect script looks for the word "kill"; don't delete it. */
|
||
return 5 / x; /* and we both started jumping up and down yelling kill */
|
||
#else
|
||
kill (getpid (), SIGFPE);
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_BUS ()
|
||
{
|
||
#ifdef SIGBUS
|
||
kill (getpid (), SIGBUS);
|
||
#else
|
||
handle_BUS ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_SEGV ()
|
||
{
|
||
#ifdef SIGSEGV
|
||
kill (getpid (), SIGSEGV);
|
||
#else
|
||
handle_SEGV ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_SYS ()
|
||
{
|
||
#ifdef SIGSYS
|
||
kill (getpid (), SIGSYS);
|
||
#else
|
||
handle_SYS ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_PIPE ()
|
||
{
|
||
#ifdef SIGPIPE
|
||
kill (getpid (), SIGPIPE);
|
||
#else
|
||
handle_PIPE ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_ALRM ()
|
||
{
|
||
#ifdef SIGALRM
|
||
kill (getpid (), SIGALRM);
|
||
#else
|
||
handle_ALRM ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_URG ()
|
||
{
|
||
#ifdef SIGURG
|
||
kill (getpid (), SIGURG);
|
||
#else
|
||
handle_URG ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_TSTP ()
|
||
{
|
||
#ifdef SIGTSTP
|
||
kill (getpid (), SIGTSTP);
|
||
#else
|
||
handle_TSTP ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_CONT ()
|
||
{
|
||
#ifdef SIGCONT
|
||
kill (getpid (), SIGCONT);
|
||
#else
|
||
handle_CONT ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_CHLD ()
|
||
{
|
||
#ifdef SIGCHLD
|
||
kill (getpid (), SIGCHLD);
|
||
#else
|
||
handle_CHLD ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_TTIN ()
|
||
{
|
||
#ifdef SIGTTIN
|
||
kill (getpid (), SIGTTIN);
|
||
#else
|
||
handle_TTIN ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_TTOU ()
|
||
{
|
||
#ifdef SIGTTOU
|
||
kill (getpid (), SIGTTOU);
|
||
#else
|
||
handle_TTOU ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_IO ()
|
||
{
|
||
#ifdef SIGIO
|
||
kill (getpid (), SIGIO);
|
||
#else
|
||
handle_IO ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_XCPU ()
|
||
{
|
||
#ifdef SIGXCPU
|
||
kill (getpid (), SIGXCPU);
|
||
#else
|
||
handle_XCPU ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_XFSZ ()
|
||
{
|
||
#ifdef SIGXFSZ
|
||
kill (getpid (), SIGXFSZ);
|
||
#else
|
||
handle_XFSZ ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_VTALRM ()
|
||
{
|
||
#ifdef SIGVTALRM
|
||
kill (getpid (), SIGVTALRM);
|
||
#else
|
||
handle_VTALRM ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_PROF ()
|
||
{
|
||
#ifdef SIGPROF
|
||
kill (getpid (), SIGPROF);
|
||
#else
|
||
handle_PROF ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_WINCH ()
|
||
{
|
||
#ifdef SIGWINCH
|
||
kill (getpid (), SIGWINCH);
|
||
#else
|
||
handle_WINCH ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_LOST ()
|
||
{
|
||
#ifdef SIGLOST
|
||
kill (getpid (), SIGLOST);
|
||
#else
|
||
handle_LOST ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_USR1 ()
|
||
{
|
||
#ifdef SIGUSR1
|
||
kill (getpid (), SIGUSR1);
|
||
#else
|
||
handle_USR1 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_USR2 ()
|
||
{
|
||
#ifdef SIGUSR2
|
||
kill (getpid (), SIGUSR2);
|
||
#else
|
||
handle_USR2 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_PWR ()
|
||
{
|
||
#ifdef SIGPWR
|
||
kill (getpid (), SIGPWR);
|
||
#else
|
||
handle_PWR ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_POLL ()
|
||
{
|
||
#ifdef SIGPOLL
|
||
kill (getpid (), SIGPOLL);
|
||
#else
|
||
handle_POLL ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_WIND ()
|
||
{
|
||
#ifdef SIGWIND
|
||
kill (getpid (), SIGWIND);
|
||
#else
|
||
handle_WIND ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_PHONE ()
|
||
{
|
||
#ifdef SIGPHONE
|
||
kill (getpid (), SIGPHONE);
|
||
#else
|
||
handle_PHONE ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_WAITING ()
|
||
{
|
||
#ifdef SIGWAITING
|
||
kill (getpid (), SIGWAITING);
|
||
#else
|
||
handle_WAITING ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_LWP ()
|
||
{
|
||
#ifdef SIGLWP
|
||
kill (getpid (), SIGLWP);
|
||
#else
|
||
handle_LWP ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_DANGER ()
|
||
{
|
||
#ifdef SIGDANGER
|
||
kill (getpid (), SIGDANGER);
|
||
#else
|
||
handle_DANGER ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_GRANT ()
|
||
{
|
||
#ifdef SIGGRANT
|
||
kill (getpid (), SIGGRANT);
|
||
#else
|
||
handle_GRANT ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_RETRACT ()
|
||
{
|
||
#ifdef SIGRETRACT
|
||
kill (getpid (), SIGRETRACT);
|
||
#else
|
||
handle_RETRACT ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_MSG ()
|
||
{
|
||
#ifdef SIGMSG
|
||
kill (getpid (), SIGMSG);
|
||
#else
|
||
handle_MSG ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_SOUND ()
|
||
{
|
||
#ifdef SIGSOUND
|
||
kill (getpid (), SIGSOUND);
|
||
#else
|
||
handle_SOUND ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_SAK ()
|
||
{
|
||
#ifdef SIGSAK
|
||
kill (getpid (), SIGSAK);
|
||
#else
|
||
handle_SAK ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_PRIO ()
|
||
{
|
||
#ifdef SIGPRIO
|
||
kill (getpid (), SIGPRIO);
|
||
#else
|
||
handle_PRIO ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_33 ()
|
||
{
|
||
#ifdef SIG33
|
||
kill (getpid (), 33);
|
||
#else
|
||
handle_33 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_34 ()
|
||
{
|
||
#ifdef SIG34
|
||
kill (getpid (), 34);
|
||
#else
|
||
handle_34 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_35 ()
|
||
{
|
||
#ifdef SIG35
|
||
kill (getpid (), 35);
|
||
#else
|
||
handle_35 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_36 ()
|
||
{
|
||
#ifdef SIG36
|
||
kill (getpid (), 36);
|
||
#else
|
||
handle_36 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_37 ()
|
||
{
|
||
#ifdef SIG37
|
||
kill (getpid (), 37);
|
||
#else
|
||
handle_37 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_38 ()
|
||
{
|
||
#ifdef SIG38
|
||
kill (getpid (), 38);
|
||
#else
|
||
handle_38 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_39 ()
|
||
{
|
||
#ifdef SIG39
|
||
kill (getpid (), 39);
|
||
#else
|
||
handle_39 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_40 ()
|
||
{
|
||
#ifdef SIG40
|
||
kill (getpid (), 40);
|
||
#else
|
||
handle_40 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_41 ()
|
||
{
|
||
#ifdef SIG41
|
||
kill (getpid (), 41);
|
||
#else
|
||
handle_41 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_42 ()
|
||
{
|
||
#ifdef SIG42
|
||
kill (getpid (), 42);
|
||
#else
|
||
handle_42 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_43 ()
|
||
{
|
||
#ifdef SIG43
|
||
kill (getpid (), 43);
|
||
#else
|
||
handle_43 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_44 ()
|
||
{
|
||
#ifdef SIG44
|
||
kill (getpid (), 44);
|
||
#else
|
||
handle_44 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_45 ()
|
||
{
|
||
#ifdef SIG45
|
||
kill (getpid (), 45);
|
||
#else
|
||
handle_45 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_46 ()
|
||
{
|
||
#ifdef SIG46
|
||
kill (getpid (), 46);
|
||
#else
|
||
handle_46 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_47 ()
|
||
{
|
||
#ifdef SIG47
|
||
kill (getpid (), 47);
|
||
#else
|
||
handle_47 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_48 ()
|
||
{
|
||
#ifdef SIG48
|
||
kill (getpid (), 48);
|
||
#else
|
||
handle_48 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_49 ()
|
||
{
|
||
#ifdef SIG49
|
||
kill (getpid (), 49);
|
||
#else
|
||
handle_49 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_50 ()
|
||
{
|
||
#ifdef SIG50
|
||
kill (getpid (), 50);
|
||
#else
|
||
handle_50 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_51 ()
|
||
{
|
||
#ifdef SIG51
|
||
kill (getpid (), 51);
|
||
#else
|
||
handle_51 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_52 ()
|
||
{
|
||
#ifdef SIG52
|
||
kill (getpid (), 52);
|
||
#else
|
||
handle_52 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_53 ()
|
||
{
|
||
#ifdef SIG53
|
||
kill (getpid (), 53);
|
||
#else
|
||
handle_53 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_54 ()
|
||
{
|
||
#ifdef SIG54
|
||
kill (getpid (), 54);
|
||
#else
|
||
handle_54 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_55 ()
|
||
{
|
||
#ifdef SIG55
|
||
kill (getpid (), 55);
|
||
#else
|
||
handle_55 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_56 ()
|
||
{
|
||
#ifdef SIG56
|
||
kill (getpid (), 56);
|
||
#else
|
||
handle_56 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_57 ()
|
||
{
|
||
#ifdef SIG57
|
||
kill (getpid (), 57);
|
||
#else
|
||
handle_57 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_58 ()
|
||
{
|
||
#ifdef SIG58
|
||
kill (getpid (), 58);
|
||
#else
|
||
handle_58 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_59 ()
|
||
{
|
||
#ifdef SIG59
|
||
kill (getpid (), 59);
|
||
#else
|
||
handle_59 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_60 ()
|
||
{
|
||
#ifdef SIG60
|
||
kill (getpid (), 60);
|
||
#else
|
||
handle_60 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_61 ()
|
||
{
|
||
#ifdef SIG61
|
||
kill (getpid (), 61);
|
||
#else
|
||
handle_61 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_62 ()
|
||
{
|
||
#ifdef SIG62
|
||
kill (getpid (), 62);
|
||
#else
|
||
handle_62 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_63 ()
|
||
{
|
||
#ifdef SIG63
|
||
kill (getpid (), 63);
|
||
#else
|
||
handle_63 ();
|
||
#endif
|
||
}
|
||
|
||
int
|
||
gen_TERM ()
|
||
{
|
||
kill (getpid (), SIGTERM);
|
||
}
|
||
|
||
int
|
||
main ()
|
||
{
|
||
signal (SIGABRT, handle_ABRT);
|
||
#ifdef SIGHUP
|
||
signal (SIGHUP, handle_HUP);
|
||
#endif
|
||
#ifdef SIGQUIT
|
||
signal (SIGQUIT, handle_QUIT);
|
||
#endif
|
||
#ifdef SIGILL
|
||
signal (SIGILL, handle_ILL);
|
||
#endif
|
||
#ifdef SIGEMT
|
||
signal (SIGEMT, handle_EMT);
|
||
#endif
|
||
#ifdef SIGFPE
|
||
signal (SIGFPE, handle_FPE);
|
||
#endif
|
||
#ifdef SIGBUS
|
||
signal (SIGBUS, handle_BUS);
|
||
#endif
|
||
#ifdef SIGSEGV
|
||
signal (SIGSEGV, handle_SEGV);
|
||
#endif
|
||
#ifdef SIGSYS
|
||
signal (SIGSYS, handle_SYS);
|
||
#endif
|
||
#ifdef SIGPIPE
|
||
signal (SIGPIPE, handle_PIPE);
|
||
#endif
|
||
#ifdef SIGALRM
|
||
signal (SIGALRM, handle_ALRM);
|
||
#endif
|
||
#ifdef SIGURG
|
||
signal (SIGURG, handle_URG);
|
||
#endif
|
||
#ifdef SIGTSTP
|
||
signal (SIGTSTP, handle_TSTP);
|
||
#endif
|
||
#ifdef SIGCONT
|
||
signal (SIGCONT, handle_CONT);
|
||
#endif
|
||
#ifdef SIGCHLD
|
||
signal (SIGCHLD, handle_CHLD);
|
||
#endif
|
||
#ifdef SIGTTIN
|
||
signal (SIGTTIN, handle_TTIN);
|
||
#endif
|
||
#ifdef SIGTTOU
|
||
signal (SIGTTOU, handle_TTOU);
|
||
#endif
|
||
#ifdef SIGIO
|
||
signal (SIGIO, handle_IO);
|
||
#endif
|
||
#ifdef SIGXCPU
|
||
signal (SIGXCPU, handle_XCPU);
|
||
#endif
|
||
#ifdef SIGXFSZ
|
||
signal (SIGXFSZ, handle_XFSZ);
|
||
#endif
|
||
#ifdef SIGVTALRM
|
||
signal (SIGVTALRM, handle_VTALRM);
|
||
#endif
|
||
#ifdef SIGPROF
|
||
signal (SIGPROF, handle_PROF);
|
||
#endif
|
||
#ifdef SIGWINCH
|
||
signal (SIGWINCH, handle_WINCH);
|
||
#endif
|
||
#ifdef SIGLOST
|
||
signal (SIGLOST, handle_LOST);
|
||
#endif
|
||
#ifdef SIGUSR1
|
||
signal (SIGUSR1, handle_USR1);
|
||
#endif
|
||
#ifdef SIGUSR2
|
||
signal (SIGUSR2, handle_USR2);
|
||
#endif
|
||
#ifdef SIGPWR
|
||
signal (SIGPWR, handle_PWR);
|
||
#endif
|
||
#ifdef SIGPOLL
|
||
signal (SIGPOLL, handle_POLL);
|
||
#endif
|
||
#ifdef SIGWIND
|
||
signal (SIGWIND, handle_WIND);
|
||
#endif
|
||
#ifdef SIGPHONE
|
||
signal (SIGPHONE, handle_PHONE);
|
||
#endif
|
||
#ifdef SIGWAITING
|
||
signal (SIGWAITING, handle_WAITING);
|
||
#endif
|
||
#ifdef SIGLWP
|
||
signal (SIGLWP, handle_LWP);
|
||
#endif
|
||
#ifdef SIGDANGER
|
||
signal (SIGDANGER, handle_DANGER);
|
||
#endif
|
||
#ifdef SIGGRANT
|
||
signal (SIGGRANT, handle_GRANT);
|
||
#endif
|
||
#ifdef SIGRETRACT
|
||
signal (SIGRETRACT, handle_RETRACT);
|
||
#endif
|
||
#ifdef SIGMSG
|
||
signal (SIGMSG, handle_MSG);
|
||
#endif
|
||
#ifdef SIGSOUND
|
||
signal (SIGSOUND, handle_SOUND);
|
||
#endif
|
||
#ifdef SIGSAK
|
||
signal (SIGSAK, handle_SAK);
|
||
#endif
|
||
#ifdef SIGPRIO
|
||
signal (SIGPRIO, handle_PRIO);
|
||
#endif
|
||
#ifdef __Lynx__
|
||
/* Lynx doesn't seem to have anything in signal.h for this. */
|
||
signal (33, handle_33);
|
||
signal (34, handle_34);
|
||
signal (35, handle_35);
|
||
signal (36, handle_36);
|
||
signal (37, handle_37);
|
||
signal (38, handle_38);
|
||
signal (39, handle_39);
|
||
signal (40, handle_40);
|
||
signal (41, handle_41);
|
||
signal (42, handle_42);
|
||
signal (43, handle_43);
|
||
signal (44, handle_44);
|
||
signal (45, handle_45);
|
||
signal (46, handle_46);
|
||
signal (47, handle_47);
|
||
signal (48, handle_48);
|
||
signal (49, handle_49);
|
||
signal (50, handle_50);
|
||
signal (51, handle_51);
|
||
signal (52, handle_52);
|
||
signal (53, handle_53);
|
||
signal (54, handle_54);
|
||
signal (55, handle_55);
|
||
signal (56, handle_56);
|
||
signal (57, handle_57);
|
||
signal (58, handle_58);
|
||
signal (59, handle_59);
|
||
signal (60, handle_60);
|
||
signal (61, handle_61);
|
||
signal (62, handle_62);
|
||
signal (63, handle_63);
|
||
#endif /* lynx */
|
||
signal (SIGTERM, handle_TERM);
|
||
|
||
x = 0;
|
||
|
||
gen_ABRT ();
|
||
gen_HUP ();
|
||
gen_QUIT ();
|
||
gen_ILL ();
|
||
gen_EMT ();
|
||
gen_FPE ();
|
||
gen_BUS ();
|
||
gen_SEGV ();
|
||
gen_SYS ();
|
||
gen_PIPE ();
|
||
gen_ALRM ();
|
||
gen_URG ();
|
||
gen_TSTP ();
|
||
gen_CONT ();
|
||
gen_CHLD ();
|
||
gen_TTIN ();
|
||
gen_TTOU ();
|
||
gen_IO ();
|
||
gen_XCPU ();
|
||
gen_XFSZ ();
|
||
gen_VTALRM ();
|
||
gen_PROF ();
|
||
gen_WINCH ();
|
||
gen_LOST ();
|
||
gen_USR1 ();
|
||
gen_USR2 ();
|
||
gen_PWR ();
|
||
gen_POLL ();
|
||
gen_WIND ();
|
||
gen_PHONE ();
|
||
gen_WAITING ();
|
||
gen_LWP ();
|
||
gen_DANGER ();
|
||
gen_GRANT ();
|
||
gen_RETRACT ();
|
||
gen_MSG ();
|
||
gen_SOUND ();
|
||
gen_SAK ();
|
||
gen_PRIO ();
|
||
gen_33 ();
|
||
gen_34 ();
|
||
gen_35 ();
|
||
gen_36 ();
|
||
gen_37 ();
|
||
gen_38 ();
|
||
gen_39 ();
|
||
gen_40 ();
|
||
gen_41 ();
|
||
gen_42 ();
|
||
gen_43 ();
|
||
gen_44 ();
|
||
gen_45 ();
|
||
gen_46 ();
|
||
gen_47 ();
|
||
gen_48 ();
|
||
gen_49 ();
|
||
gen_50 ();
|
||
gen_51 ();
|
||
gen_52 ();
|
||
gen_53 ();
|
||
gen_54 ();
|
||
gen_55 ();
|
||
gen_56 ();
|
||
gen_57 ();
|
||
gen_58 ();
|
||
gen_59 ();
|
||
gen_60 ();
|
||
gen_61 ();
|
||
gen_62 ();
|
||
gen_63 ();
|
||
gen_TERM ();
|
||
|
||
return 0;
|
||
}
|