Ticket #178: signal.d

module include.signal;

/* The <signal.h> header defines all the ANSI and POSIX signals.
 * MINIX supports all the signals required by POSIX. They are defined below.
 * Some additional signals are also supported.
 */

import include.ansi;
static if ( _POSIX_SOURCE) {
    import include.sys.types;
}

/* Here are types that are closely associated with signal handling. */
typedef int sig_atomic_t;

static if ( _POSIX_SOURCE) {
    typedef ulong sigset_t;
}

/* Regular signals. */
const SIGHUP               = 1; /* hangup */
const SIGINT               = 2; /* interrupt (DEL) */
const SIGQUIT              = 3; /* quit (ASCII FS) */
const SIGILL               = 4; /* illegal instruction */
const SIGTRAP              = 5; /* trace trap (not reset when caught) */
const SIGABRT              = 6; /* IOT instruction */
const SIGBUS               = 7; /* bus error */
const SIGFPE               = 8; /* floating point exception */
const SIGKILL              = 9; /* kill (cannot be caught or ignored) */
const SIGUSR1             = 10; /* user defined signal # 1 */
const SIGSEGV             = 11; /* segmentation violation */
const SIGUSR2             = 12; /* user defined signal # 2 */
const SIGPIPE             = 13; /* write on a pipe with no one to read it */
const SIGALRM             = 14; /* alarm clock */
const SIGTERM             = 15; /* software termination signal from kill */
const SIGEMT           = 16;    /* EMT instruction */
const SIGCHLD             = 17; /* child process terminated or stopped */
const SIGWINCH         = 21;    /* window size has changed */

/* POSIX requires the following signals to be defined, even if they are
 * not supported.  Here are the definitions, but they are not supported.
 */
const SIGCONT             = 18; /* continue if stopped */
const SIGSTOP             = 19; /* stop signal */
const SIGTSTP             = 20; /* interactive stop signal */
const SIGTTIN             = 22; /* background process wants to read */
const SIGTTOU             = 23; /* background process wants to write */

const _NSIG               = 24; /* highest signal number plus one */

static if ( _MINIX) {
    const SIGIOT               = SIGABRT; /* for people who speak PDP-11 */
    
    /* MINIX specific signals. These signals are not used by user proceses, 
     * but meant to inform system processes, like the PM, about system events.
     */
    const SIGKMESS         = 29;    /* new kernel message */
    const SIGKSIG          = 30;    /* kernel signal pending */
    const SIGKSTOP         = 31;    /* kernel shutting down */

}

/* The sighandler_t type is not allowed unless _POSIX_SOURCE is defined. */
void function (int) __sighandler_t;

/* Macros used as function pointers. */
const SIG_ERR      = cast (__sighandler_t) -1; /* error return */
const SIG_DFL      = cast (__sighandler_t)  0; /* default signal handling */
const SIG_IGN      = cast (__sighandler_t)  1; /* ignore signal */
const SIG_HOLD     = cast (__sighandler_t)  2; /* block signal */
const SIG_CATCH    = cast (__sighandler_t)  3; /* catch signal */
const SIG_MESS     = cast (__sighandler_t)  4; /* pass as message (MINIX) */

static if (_POSIX_SOURCE) {
struct sigaction {
  __sighandler_t sa_handler;    /* SIG_DFL, SIG_IGN, or pointer to function */
  sigset_t sa_mask;     /* signals to be blocked during handler */
  int sa_flags;         /* special flags */
}

/* Fields for sa_flags. */
const SA_ONSTACK     = 0x0001; /*   /* deliver signal on alternate stack */
const SA_RESETHAND   = 0x0002; /*   /* reset signal handler when signal caught */
const SA_NODEFER     = 0x0004; /*   /* don't block signal while catching it */
const SA_RESTART     = 0x0008; /*   /* automatic system call restart */
const SA_SIGINFO     = 0x0010; /*   /* extended signal handling */
const SA_NOCLDWAIT   = 0x0020; /*   /* don't create zombies */
const SA_NOCLDSTOP   = 0x0040; /*   /* don't receive SIGCHLD when child stops */

/* POSIX requires these values for use with sigprocmask(2). */
const SIG_BLOCK            = 0; /*  /* for blocking signals */
const SIG_UNBLOCK          = 1; /*  /* for unblocking signals */
const SIG_SETMASK          = 2; /*  /* for setting the signal mask */
const SIG_INQUIRE          = 4; /*  /* for internal use only */
}   /* _POSIX_SOURCE */

/* POSIX and ANSI function prototypes. */
int function (int _sig)                  raise;
__sighandler_t function (int _sig, __sighandler_t _func)     signal;

static if ( _POSIX_SOURCE) {
int function (pid_t _pid, int _sig)              kill;
int function (pid_t _pgrp, int _sig)                 killpg;
int function (int _sig, const struct sigaction *_act, struct sigaction *_oact)   sigaction;
int function (sigset_t *_set, int _sig)          sigaddset;
int function (sigset_t *_set, int _sig)          sigdelset;
int function (sigset_t *_set)                sigemptyset;
int function (sigset_t *_set)                sigfillset;
int function (const sigset_t *_set, int _sig)        sigismember;
int function (sigset_t *_set)                sigpending;
int function (int _how, const sigset_t *_set, sigset_t *_oset)       sigprocmask;
int function (const sigset_t *_sigmask)          sigsuspend;
}