Click above to get retro games delivered to your door ever month!

Synopsis:
    #include <signal.h>
    void ( *signal(int sig, void (*func)(int)) )( int );

Description:
    The signal function is used to specify an action to take place when
    certain conditions are detected while a program executes.  These
    conditions are defined to be:

    Condition     Meaning

SIGABRT
    abnormal termination, such as caused by the  abort function

SIGBREAK
    an interactive attention (CTRL/BREAK on keyboard) is signalled

SIGFPE
    an erroneous floating-point operation occurs (such as division by zero,
    overflow and underflow)

SIGILL
    illegal instruction encountered

SIGINT
    an interactive attention (CTRL/C on keyboard) is signalled

SIGSEGV
    an illegal memory reference is detected

SIGTERM
    a termination request is sent to the program

SIGUSR1
    OS/2 process flag A via DosFlagProcess

SIGUSR2
    OS/2 process flag B via DosFlagProcess

SIGUSR3
    OS/2 process flag C via DosFlagProcess

    An action can be specified for each of the conditions, depending upon
    the value of the func argument:

    function
        When func is a function name, that function will be called
        equivalently to the following code sequence.


                 /* "sig_no" is condition being signalled */
                 signal( sig_no, SIG_DFL );
                 (*func)( sig_no );

        The func function may terminate the program by calling the  exit or
        abort functions or call the  longjmp function.  Because the next
        signal will be handled with default handling, the program must again
        call signal if it is desired to handle the next condition of the
        type that has been signalled.

        After returning from the signal-catching function, the receiving
        process will resume execution at the point at which it was
        interrupted.

        The signal catching function is described as follows:


                 void func( int sig_no )
                 {

                     /* body of function */

                 }

        Since signal-catching functions are invoked asynchronously with
        process execution, the type  sig_atomic_t may be used to define
        variables on which an atomic operation (e.g., incrementation,
        decrementation) may be performed.

    SIG_DFL
        This value causes the default action for the condition to occur.

    SIG_IGN
        This value causes the indicated condition to be ignored.

    When a condition is detected, it may be handled by a program, it may be
    ignored, or it may be handled by the usual default action (often causing
    an error message to be printed upon the stderr stream followed by
    program termination).

    When the program begins execution, the equivalent of


             signal( SIGABRT, SIG_DFL );
             signal( SIGFPE, SIG_IGN );
             signal( SIGILL, SIG_DFL );
             signal( SIGINT, SIG_DFL );
             signal( SIGSEGV, SIG_DFL );
             signal( SIGTERM, SIG_DFL );

    is executed.

    The  SIGINT signal is generated by pressing the CTRL/C or CTRL/BREAK key
    combination on the keyboard.  Under DOS, if "BREAK=ON", a signal will be
    delivered at the next DOS call; otherwise, if "BREAK=OFF", a signal will
    be delivered only at the next standard input/output DOS call.  The
     BREAK setting is configured in the CONFIG.SYS file.

    A condition can be generated by a program using the  raise function.

Returns:
    A return value of  SIG_ERR indicates that the request could not be
    handled, and  errno is set to the value  EINVAL.

    Otherwise, the previous value of func for the indicated condition is
    returned.

Example:
    #include <signal.h>

    sig_atomic_t signal_count;

    void MyHandler( int sig_number )
      {
         ++signal_count;
      }

    void main()
      {
        signal( SIGFPE, MyHandler );   /* set own handler */
        signal( SIGABRT, SIG_DFL );    /* Default action */
        signal( SIGFPE, SIG_IGN );     /* Ignore condition */
      }

Classification:
    ANSI

Systems:
    All, Netware

See Also:
    break Functions, raise