X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fsyssignal.h;fp=src%2Fsyssignal.h;h=8b2747c38825ad8cbc0eec00064e24a17dc4a193;hb=9a9fedfd2473568f4827f6295de7b03259b160e5;hp=0000000000000000000000000000000000000000;hpb=97badae7fa41c4bd3e92511ff7b16389e646e022;p=chise%2Fxemacs-chise.git- diff --git a/src/syssignal.h b/src/syssignal.h new file mode 100644 index 0000000..8b2747c --- /dev/null +++ b/src/syssignal.h @@ -0,0 +1,247 @@ +/* syssignal.h - System-dependent definitions for signals. + Copyright (C) 1992, 1993 Free Software Foundation, Inc. + +This file is part of XEmacs. + +XEmacs 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, or (at your option) any +later version. + +XEmacs 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 XEmacs; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +/* Synched up with: FSF 19.30. */ + +#ifndef INCLUDED_syssignal_h_ +#define INCLUDED_syssignal_h_ + +/* In the old world, one could not #include here. The party line + was that that header should always be #included before , because + some configuration files (like s/hpux.h) indicate that SIGIO doesn't work + by #undef-ing SIGIO, and if this file #includes , then that will + re-#define SIGIO and confuse things. + + This was, however, a completely fucked up state of affairs, because on some + systems it's necessary for the s/m files to #define things in order to get + to provide the right typedefs, etc. And it's generally a broken + concept for to not be the very very first file included. + + So instead of #undef'ing SIGIO in the various s/m files, I've changed them + to define BROKEN_SIGIO instead, then we (syssignal.h) do an #undef SIGIO + at the end, after including signal.h. Therefore, it's important that + not be included after "syssignal.h", but that's the normal state: + nothing should be directly including these days. + -- jwz, 29-nov-93 + */ + +#include +#include + +/* SIGPOLL is the SVR4 signal. Those systems generally define + SIGIO as an alias for SIGPOLL, but just in case ... */ + +#if defined (BROKEN_SIGIO) +# if defined (SIGIO) && defined (SIGPOLL) +# if SIGIO == SIGPOLL +# undef SIGIO +# undef SIGPOLL +# else +# undef SIGIO +# endif +# endif +#else /* Not BROKEN_SIGIO */ +# if !defined (SIGIO) && defined (SIGPOLL) +# define SIGIO SIGPOLL +# endif +#endif + +/* Define SIGCHLD as an alias for SIGCLD. There are many conditionals + testing SIGCHLD. */ +#if defined (SIGCLD) && !defined (SIGCHLD) +# define SIGCHLD SIGCLD +#endif /* SIGCHLD */ + +#ifdef BROKEN_SIGCHLD +#undef SIGCHLD +#endif + +#ifdef SIGCHLD +#define EMACS_BLOCK_SIGCHLD EMACS_BLOCK_SIGNAL (SIGCHLD) +#define EMACS_UNBLOCK_SIGCHLD EMACS_UNBLOCK_SIGNAL (SIGCHLD) +#else +#define EMACS_BLOCK_SIGCHLD +#define EMACS_UNBLOCK_SIGCHLD +#endif + +/* According to W.R. Stevens __Advanced Programming in the Unix + Environment__, there are four different paradigms for handling + signals. We use autoconf to tell us which one applies. + + Note that on some systems, more than one paradigm is implemented + (typically, the POSIX sigaction/sigprocmask and either the older + SYSV or BSD way). In such a case, we prefer the POSIX way. + + NOTE: We use EMACS_* macros for most signal operations, but + just signal() for the standard signal-setting operation. + Perhaps we should change this to EMACS_SIGNAL(), but that runs + the risk of someone forgetting this convention and calling + signal() directly. */ + +#ifndef NeXT +typedef SIGTYPE (*signal_handler_t) (int); +#endif + +#if defined (HAVE_SIGPROCMASK) + +/* The POSIX way (sigaction, sigprocmask, sigpending, sigsuspend) */ + +signal_handler_t sys_do_signal (int signal_number, signal_handler_t action); +/* Provide our own version of signal(), that calls sigaction(). The + name is not sys_signal() because a function of that name exists in + libenergize.a */ +#undef signal +#define signal sys_do_signal + +#define EMACS_BLOCK_SIGNAL(sig) do \ +{ \ + sigset_t ES_mask; \ + sigemptyset (&ES_mask); \ + sigaddset (&ES_mask, sig); \ + sigprocmask (SIG_BLOCK, &ES_mask, NULL); \ +} while (0) +#define EMACS_UNBLOCK_SIGNAL(sig) do \ +{ \ + sigset_t ES_mask; \ + sigemptyset (&ES_mask); \ + sigaddset (&ES_mask, sig); \ + sigprocmask (SIG_UNBLOCK, &ES_mask, NULL); \ +} while (0) +#define EMACS_UNBLOCK_ALL_SIGNALS() do \ +{ \ + sigset_t ES_mask; \ + sigemptyset (&ES_mask); \ + sigprocmask (SIG_SETMASK, &ES_mask, NULL); \ +} while (0) +#define EMACS_WAIT_FOR_SIGNAL(sig) do \ +{ \ + sigset_t ES_mask; \ + sigprocmask (0, NULL, &ES_mask); \ + sigdelset (&ES_mask, sig); \ + sigsuspend (&ES_mask); \ +} while (0) +#define EMACS_REESTABLISH_SIGNAL(sig, handler) + +#elif defined (HAVE_SIGBLOCK) + +/* The older BSD way (signal/sigvec, sigblock, sigsetmask, sigpause) */ + +/* It's OK to use signal() here directly. No unreliable signal + problems. However, we use sigvec() because it allows us to + request interruptible I/O. */ + +#define signal sys_do_signal + +/* Is it necessary to define sigmask like this? */ +#ifndef sigmask +# define sigmask(no) (1L << ((no) - 1)) +#endif + +#define EMACS_BLOCK_SIGNAL(sig) sigblock (sigmask (sig)) +#define EMACS_UNBLOCK_SIGNAL(sig) sigsetmask (sigblock (0) & ~sigmask (sig)) +#define EMACS_UNBLOCK_ALL_SIGNALS() sigsetmask (0) +#define EMACS_WAIT_FOR_SIGNAL(sig) do \ +{ \ + int ES_mask = sigblock (0); \ + sigpause (ES_mask & ~sigmask (sig)); \ +} while (0) +#define EMACS_REESTABLISH_SIGNAL(sig, handler) + +#elif defined (HAVE_SIGHOLD) + +/* The older SYSV way (signal/sigset, sighold, sigrelse, sigignore, + sigpause) */ + +#define signal sigset +#define EMACS_BLOCK_SIGNAL(sig) sighold (sig) +#define EMACS_UNBLOCK_SIGNAL(sig) sigrelse (sig) +/* #### There's not really any simple way to implement this. + Since EMACS_UNBLOCK_ALL_SIGNALS() is only called once (at startup), + it's probably OK to just ignore it. */ +#define EMACS_UNBLOCK_ALL_SIGNALS() 0 +#define EMACS_WAIT_FOR_SIGNAL(sig) sigpause (sig) +#define EMACS_REESTABLISH_SIGNAL(sig, handler) + +#else + +/* The oldest SYSV way (signal only; unreliable signals) */ + +/* Old USG systems don't really have signal blocking. + We indicate this by not defining EMACS_BLOCK_SIGNAL or + EMACS_WAIT_FOR_SIGNAL. */ +#define EMACS_UNBLOCK_SIGNAL(sig) 0 +#define EMACS_UNBLOCK_ALL_SIGNALS() 0 +#define EMACS_REESTABLISH_SIGNAL(sig, handler) do \ +{ \ + int old_errno = errno; \ + signal (sig, handler); \ + errno = old_errno; \ +} while (0) + +/* Under SYSV, setting a signal handler for SIGCLD causes + SIGCLD to immediately be sent if there any unwaited processes + out there. This means that the SIGCLD handler *must* call + wait() to reap the status of all processes -- it cannot + simply set a flag and then reestablish the handler, because + it will get called again, infinitely. We only need to + worry about this on systems where signals need to be + reestablished (SYSV Release 2 and earlier). */ +#define OBNOXIOUS_SYSV_SIGCLD_BEHAVIOR + +#endif + +/* On bsd, [man says] kill does not accept a negative number to kill a pgrp. + Must do that using the killpg call. */ +#ifdef HAVE_KILLPG +#define EMACS_KILLPG(pid, signo) killpg (pid, signo) +#else +#ifdef WIN32_NATIVE +#define EMACS_KILLPG(pid, signo) kill (pid, signo) +#else +#define EMACS_KILLPG(pid, signo) kill (-(pid), signo) +#endif +#endif + +#ifndef NSIG +# define NSIG (SIGUSR2+1) /* guess how many elements are in sys_siglist... */ +#endif + +/* SYS_SIGLIST_DECLARED is determined by configure. On Linux, it seems, + configure incorrectly fails to find it, so s/linux.h defines + HAVE_SYS_SIGLIST. */ +#if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_SYS_SIGLIST) +extern const char *sys_siglist[]; +#endif + +#ifdef SIGDANGER +SIGTYPE memory_warning_signal (int sig); +#endif + +#ifdef WIN32_NATIVE +/* Prototypes for signal functions, see nt.c */ +typedef void (__cdecl *mswindows_sighandler) (int); +mswindows_sighandler mswindows_sigset (int sig, mswindows_sighandler handler); +int mswindows_sighold (int nsig); +int mswindows_sigrelse (int nsig); +int mswindows_sigpause (int nsig); +int mswindows_raise (int nsig); +#endif /* WIN32_NATIVE */ + +#endif /* INCLUDED_syssignal_h_ */