Tue Jun 4 00:16:03 1996 Roland McGrath <roland@delasyd.gnu.ai.mit.edu>
[kopensolaris-gnu/glibc.git] / signal / signal.h
index 23fe21e..402d15e 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 1992 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
 This file is part of the GNU C Library.
 
 The GNU C Library is free software; you can redistribute it and/or
@@ -27,81 +27,80 @@ Cambridge, MA 02139, USA.  */
 #include <features.h>
 #endif
 
-#include <gnu/types.h>
-#include <gnu/signal.h>
+__BEGIN_DECLS
 
 #define         __need_size_t
 #include <stddef.h>
 
+#include <gnu/types.h>
+#include <sigset.h>            /* __sigset_t, __sig_atomic_t.  */
+
 #if    !defined(__sig_atomic_t_defined) &&     \
   (defined(_SIGNAL_H) || defined(__need_sig_atomic_t))
 /* An integral type that can be modified atomically, without the
    possibility of a signal arriving in the middle of the operation.  */
 typedef __sig_atomic_t sig_atomic_t;
-#endif /* `sig_atomic_t' undefined and <signal.h> or need `sig_atomic_t'.  */
+#endif /* `sig_atomic_t' undefined and <signal.h> or need `sig_atomic_t'.  */
 #undef __need_sig_atomic_t
 
 #ifdef _SIGNAL_H
 
+#include <signum.h>
+
+/* Type of a signal handler.  */
+typedef void (*__sighandler_t) __P ((int));
+
 /* Set the handler for the signal SIG to HANDLER,
    returning the old handler, or SIG_ERR on error.  */
-extern __sighandler_t EXFUN(signal, (int __sig, __sighandler_t __handler));
+extern __sighandler_t signal __P ((int __sig, __sighandler_t __handler));
 
 /* Send signal SIG to process number PID.  If PID is zero,
    send SIG to all processes in the current process's process group.
    If PID is < -1, send SIG to all processes in process group - PID.  */
-extern int EXFUN(__kill, (__pid_t __pid, int __sig));
+extern int __kill __P ((__pid_t __pid, int __sig));
 #ifdef __USE_POSIX
-extern int EXFUN(kill, (int __pid, int __sig));
-#ifdef __OPTIMIZE__
-#define        kill(pid, sig)  __kill((pid), (sig))
-#endif /* Optimizing.  */
-#endif /* Use POSIX.  */
+extern int kill __P ((__pid_t __pid, int __sig));
+#endif /* Use POSIX.  */
 
 #ifdef __USE_BSD
 /* Send SIG to all processes in process group PGRP.
    If PGRP is zero, send SIG to all processes in
    the current process's process group.  */
-extern int EXFUN(killpg, (int __pgrp, int __sig));
-#endif /* Use BSD.  */
+extern int killpg __P ((__pid_t __pgrp, int __sig));
+#endif /* Use BSD.  */
 
 /* Raise signal SIG, i.e., send SIG to yourself.  */
-extern int EXFUN(raise, (int __sig));
+extern int raise __P ((int __sig));
 
 #ifdef __USE_SVID
 /* SVID names for the same things.  */
-extern __sighandler_t EXFUN(ssignal, (int __sig, __sighandler_t __handler));
-extern int EXFUN(gsignal, (int __sig));
+extern __sighandler_t ssignal __P ((int __sig, __sighandler_t __handler));
+extern int gsignal __P ((int __sig));
+#endif /* Use SVID.  */
 
-#ifdef __OPTIMIZE__
-#define        gsignal(sig)            raise(sig)
-#define        ssignal(sig, handler)   signal((sig), (handler))
-#endif /* Optimizing.  */
-
-#endif /* Use SVID.  */
+#ifdef __USE_MISC
+/* Print a message describing the meaning of the given signal number.  */
+extern void psignal __P ((int __sig, __const char *__s));
+#endif /* Use misc.  */
 
 
 /* Block signals in MASK, returning the old mask.  */
-extern int EXFUN(__sigblock, (int __mask));
+extern int __sigblock __P ((int __mask));
 
 /* Set the mask of blocked signals to MASK, returning the old mask.  */
-extern int EXFUN(__sigsetmask, (int __mask));
+extern int __sigsetmask __P ((int __mask));
 
 /* Set the mask of blocked signals to MASK,
    wait for a signal to arrive, and then restore the mask.  */
-extern int EXFUN(__sigpause, (int __mask));
+extern int __sigpause __P ((int __mask));
 
 #ifdef __USE_BSD
 #define        sigmask(sig)    __sigmask(sig)
 
-extern int EXFUN(sigblock, (int __mask));
-extern int EXFUN(sigsetmask, (int __mask));
-extern int EXFUN(sigpause, (int __mask));
-
-#define        sigblock        __sigblock
-#define        sigsetmask      __sigsetmask
-#define        sigpause        __sigpause
-#endif /* Use BSD.  */
+extern int sigblock __P ((int __mask));
+extern int sigsetmask __P ((int __mask));
+extern int sigpause __P ((int __mask));
+#endif /* Use BSD.  */
 
 
 #ifdef __USE_MISC
@@ -109,94 +108,94 @@ extern int EXFUN(sigpause, (int __mask));
 #endif
 
 #ifdef __USE_GNU
-#define        sighandler_t    __sighandler_t
+typedef __sighandler_t sighandler_t;
 #endif
 
-#endif /* <signal.h> included.  */
+/* 4.4 BSD uses the name `sig_t' for this.  */
+#ifdef __USE_BSD
+typedef __sighandler_t sig_t;
+#endif
+
+#endif /* <signal.h> included.  */
 
 
 #ifdef __USE_POSIX
 
 #if    !defined(__sigset_t_defined) && \
    (defined(_SIGNAL_H) || defined(__need_sigset_t))
-#define        sigset_t        __sigset_t
+typedef __sigset_t sigset_t;
 #define        __sigset_t_defined      1
-#endif /* `sigset_t' not defined and <signal.h> or need `sigset_t'.  */
+#endif /* `sigset_t' not defined and <signal.h> or need `sigset_t'.  */
 #undef __need_sigset_t
 
 #ifdef _SIGNAL_H
 
 /* Clear all signals from SET.  */
-extern int EXFUN(sigemptyset, (sigset_t *__set));
+extern int sigemptyset __P ((sigset_t *__set));
 
 /* Set all signals in SET.  */
-extern int EXFUN(sigfillset, (sigset_t *__set));
+extern int sigfillset __P ((sigset_t *__set));
 
 /* Add SIGNO to SET.  */
-extern int EXFUN(sigaddset, (sigset_t *__set, int __signo));
+extern int sigaddset __P ((sigset_t *__set, int __signo));
 
 /* Remove SIGNO from SET.  */
-extern int EXFUN(sigdelset, (sigset_t *__set, int __signo));
+extern int sigdelset __P ((sigset_t *__set, int __signo));
 
 /* Return 1 if SIGNO is in SET, 0 if not.  */
-extern int EXFUN(sigismember, (CONST sigset_t *__set, int signo));
+extern int sigismember __P ((__const sigset_t *__set, int signo));
 
-/* Get and/or change the set of blocked signals.  */
-extern int EXFUN(__sigprocmask, (int __how, CONST sigset_t *__set,
-                                sigset_t *__oset));
-extern int EXFUN(sigprocmask, (int __how, sigset_t *__set, sigset_t *__oset));
+#ifdef __OPTIMIZE__
+/* <sigset.h> defines the __ versions as macros that do the work.  */
+#define        sigemptyset(set)        __sigemptyset(set)
+#define        sigfillset(set)         __sigfillset(set)
+#define        sigaddset(set, signo)   __sigaddset(set, signo)
+#define        sigdelset(set, signo)   __sigdelset(set, signo)
+#define        sigismember(set, signo) __sigismember(set, signo)
+#endif
 
-/* Values for the HOW argument to `sigprocmask'.  */
-#define        SIG_BLOCK       1       /* Block signals.  */
-#define        SIG_UNBLOCK     2       /* Unblock signals.  */
-#define        SIG_SETMASK     3       /* Set the set of blocked signals.  */
+/* Get the system-specific definitions of `struct sigaction'
+   and the `SA_*' and `SIG_*'. constants.  */
+#include <sigaction.h>
 
+/* Get and/or change the set of blocked signals.  */
+extern int __sigprocmask __P ((int __how,
+                              __const sigset_t *__set, sigset_t *__oset));
+extern int sigprocmask __P ((int __how,
+                            __const sigset_t *__set, sigset_t *__oset));
 
 /* Change the set of blocked signals to SET,
    wait until a signal arrives, and restore the set of blocked signals.  */
-extern int EXFUN(sigsuspend, (CONST sigset_t *__set));
-
-/* Bits the in `sa_flags' field of a `struct sigaction'.  */
-#ifdef __USE_BSD
-#define        SA_ONSTACK      __SA_ONSTACK    /* Take signal on signal stack.  */
-#define        SA_RESTART      __SA_RESTART    /* No syscall restart on sig ret.  */
-#define        SA_DISABLE      __SA_DISABLE    /* Disable alternate signal stack.  */
-#endif
-#define        SA_NOCLDSTOP    __SA_NOCLDSTOP  /* No SIGCHLD when children stop.  */
+extern int sigsuspend __P ((__const sigset_t *__set));
 
 /* Get and/or set the action for signal SIG.  */
-extern int EXFUN(__sigaction, (int __sig, CONST struct __sigaction *__act,
-                              struct __sigaction *__oact));
-extern int EXFUN(sigaction, (int __sig, CONST struct __sigaction *__act,
-                            struct __sigaction *__oact));
-
-#define        sigaction       __sigaction
+extern int __sigaction __P ((int __sig, __const struct sigaction *__act,
+                            struct sigaction *__oact));
+extern int sigaction __P ((int __sig, __const struct sigaction *__act,
+                          struct sigaction *__oact));
 
 /* Put in SET all signals that are blocked and waiting to be delivered.  */
-extern int EXFUN(sigpending, (sigset_t *__set));
+extern int sigpending __P ((sigset_t *__set));
 
-#define        sigemptyset     __sigemptyset
-#define        sigfillset      __sigfillset
-#define        sigaddset       __sigaddset
-#define        sigdelset       __sigdelset
-#define        sigismember     __sigismember
-#define        sigprocmask     __sigprocmask
-#define        sigaction       __sigaction
+#endif /* <signal.h> included.  */
 
-#endif /* <signal.h> included.  */
-
-#endif /* Use POSIX.  */
+#endif /* Use POSIX.  */
 
 #if    defined(_SIGNAL_H) && defined(__USE_BSD)
 
+/* Names of the signals.  This variable exists only for compatiblity.
+   Use `strsignal' instead (see <string.h>).  */
+extern __const char *__const _sys_siglist[NSIG];
+extern __const char *__const sys_siglist[NSIG];
+
 /* Structure passed to `sigvec'.  */
-struct __sigvec
+struct sigvec
   {
     __sighandler_t sv_handler; /* Signal handler.  */
     int sv_mask;               /* Mask of signals to be blocked.  */
 
     int sv_flags;              /* Flags (see below).  */
-#define        sv_onstack      sv_flags/* 4.2 BSD compatibility.  */
+#define        sv_onstack      sv_flags /* 4.2 BSD compatibility.  */
   };
 
 /* Bits in `sv_flags'.  */
@@ -210,51 +209,50 @@ struct __sigvec
    If the SV_RESETHAND bit is set in `sv_flags', the handler for SIG will be
    reset to SIG_DFL before `sv_handler' is entered.  If OVEC is non-NULL,
    it is filled in with the old information for SIG.  */
-extern int EXFUN(__sigvec, (int __sig, CONST struct __sigvec *__vec,
-                           struct __sigvec *__ovec));
-extern int EXFUN(sigvec, (int __sig, CONST struct __sigvec *__vec,
-                         struct __sigvec *__ovec));
-#define        sigvec  __sigvec
+extern int __sigvec __P ((int __sig, __const struct sigvec *__vec,
+                         struct sigvec *__ovec));
+extern int sigvec __P ((int __sig, __const struct sigvec *__vec,
+                       struct sigvec *__ovec));
 
 
 /* If INTERRUPT is nonzero, make signal SIG interrupt system calls
    (causing them to fail with EINTR); if INTERRUPT is zero, make system
    calls be restarted after signal SIG.  */
-extern int EXFUN(siginterrupt, (int __sig, int __interrupt));
+extern int siginterrupt __P ((int __sig, int __interrupt));
 
 
 /* Structure describing a signal stack.  */
 struct sigstack
   {
-    PTR ss_sp;                 /* Signal stack pointer.  */
+    __ptr_t ss_sp;             /* Signal stack pointer.  */
     int ss_onstack;            /* Nonzero if executing on this stack.  */
   };
 
 /* Run signals handlers on the stack specified by SS (if not NULL).
    If OSS is not NULL, it is filled in with the old signal stack status.  */
-extern int EXFUN(sigstack, (CONST struct sigstack *__ss,
-                           struct sigstack *__oss));
+extern int sigstack __P ((__const struct sigstack *__ss,
+                         struct sigstack *__oss));
 
 /* Alternate interface.  */
 struct sigaltstack
   {
-    PTR ss_sp;
+    __ptr_t ss_sp;
     size_t ss_size;
     int ss_flags;
   };
 
-extern int EXFUN(sigaltstack, (CONST struct sigaltstack *__ss,
-                              struct sigaltstack *__oss));
+extern int sigaltstack __P ((__const struct sigaltstack *__ss,
+                            struct sigaltstack *__oss));
 
 /* Get machine-dependent `struct sigcontext' and signal subcodes.  */
 #include <sigcontext.h>
 
 /* Restore the state saved in SCP.  */
-extern int EXFUN(__sigreturn, (CONST struct sigcontext *__scp));
-extern int EXFUN(sigreturn, (CONST struct sigcontext *__scp));
-#define        sigreturn       __sigreturn
+extern int __sigreturn __P ((struct sigcontext *__scp));
+extern int sigreturn __P ((struct sigcontext *__scp));
 
+#endif /* signal.h included and use BSD.  */
 
-#endif /* signal.h included and use BSD.  */
+__END_DECLS
 
-#endif /* signal.h  */
+#endif /* signal.h  */