signal.h

Go to the documentation of this file.

/*--------------------------------------------------------
 * /
 * / apeNEXT signal functions for nlcc
 * /
 * / $Id: signal.h,v 1.14 2005/10/28 12:28:57 morinl Exp $
 * /
 * / ISO/IEC 9899:1999 (E) Standard
 * / ctype  <signal.h>
 * /
 * / IMPLEMENTATION for APEnext: possible?         (signal.h)
 * /---------------------------------------------------------------------------------------------*/

#ifndef _SIGNAL_H
#define _SIGNAL_H

#include <nlibc.h>

/*
    Header <signal.h> specifies how the program handles signals while it executes.                     
    A signal can report some exceptional behavior within the program, such as division 
    by zero. Or a signal can report some asynchronous event outside the program, such                 

    as someone striking an interactive attention key on a keyboard 


    One can report any signal by calling raise(). Each implementation defines what 
    signals it generates (if any) and under what circumstances it generates them. 
    An implementation can define signals other than the ones listed here. 
    The standard header <signal.h> can define additional macros with names beginning 
    with SIG to specify the values of additional signals. All such values are 
    integer constant expressions >= 0.

    One can specify a signal handler for each signal. A signal handler is a function 
    that the target environment calls when the corresponding signal occurs. 
    The target environment suspends execution of the program until the signal handler 
    returns or calls longjmp. For maximum portability, an asynchronous signal handler 
    should only:
                -make calls (that succeed) to the function signal
                -assign values to objects of type volatile sig_atomic_t
                -return control to its caller

    If the signal reports an error within the program (and the signal is not asynchronous), 
    the signal handler can terminate by calling abort, exit, or longjmp.
 */

/*------------------------------------------------------------------------------------------------
 * / NAME   
 * /           sig_atomic_t - typedef i-type
 * / 
 * / SYNOPSIS
 * /           #include <signal.h>
 * /
 * /           typedef i-type sig_atomic_t 
 * / 
 * / DESCRIPTION
 * /           This type is the integer type i-type for objects whose stored value is 
 * /           altered by an assigning operator as an atomic operation (an operation 
 * /           that never has its execution suspended while partially completed). 
 * /           You declare such objects to communicate between signal handlers and 
 * /           the rest of the program.
 * /
 * / RETURN VALUE
 * /           None
 * / 
 * / Notes
 * /           
 * / 
 * / IMPLEMENTATION for APEnext:  possible         (i-type sig_atomic_t) 
 * / --------------------------------------------------------------------------------------------*/
typedef int sig_atomic_t;

// We need a better explanation of those signals                        (OK 09.08.02)
// How do such signals occur and do we have them on APEnext ?           (OK 09.08.02)
// Answer: No such signals internally, except after explicit checks
//         for e.g. exceptions.
//         Signals may, however, be sent to the 'OS' (i.e. nose) and
//         then passed on to the nodes by stopping the nodes and 
//         explicitly calling a handler.                                (NP 29.1.04)

                        // yields the func argument value to signal to specify default signal handling
#define SIG_DFL   0     // address constant expression              

                        // yields the signal return value to specify an erroneous call.
#define SIG_ERR  -1     // address constant expression

                        // yields the func argument value to signal to specify that the target 
                        // environment is to henceforth ignore the signal
#define SIG_IGN   1     // address constant expression

                        // yields the sig argument value for the abort signal.
#define SIGABRT   6     // integer constant expression >= 0

                        // acro yields the sig argument value for the arithmetic error signal, 
                        // such as for division by zero or result out of range.
#define SIGFPE    8     // integer constant expression >= 0

                        // yields the sig argument value for the invalid execution signal, 
                        // such as for a corrupted function image.
#define SIGILL    4     // integer constant expression >= 0

                        // yields the sig argument value for the asynchronous interactive 
                        // attention signal.
#define SIGINT    2     // integer constant expression >= 0

                        // yields the sig argument value for the invalid storage access signal, 
                        // such as for an erroneous lvalue expression.
#define SIGSEGV  11     // integer constant expression >= 0

                        // yields the sig argument value for the asynchronous termination request signal.
                        // Do we have such a signal on APEnext ? (OK 09.08.02)
#define SIGTERM  15     // integer constant expression >= 0


/*------------------------------------------------------------------------------------------------
 * / NAME   
 * /           signal - pecifies the new handling for signal sig
 * / 
 * / SYNOPSIS
 * /           #include <signal.h>
 * /
 * /           void (*signal(int sig, void (*func)(int)))(int) 
 * / 
 * / DESCRIPTION
 * /           This function specifies the new handling for signal sig and returns the 
 * /           previous handling, if successful; otherwise, it returns SIG_ERR.
 * /
 * / RETURN VALUE
 * /           None
 * / 
 * / Notes
 * /           -If func is SIG_DFL, the target environment commences default handling 
 * /            (as defined by the implementation). 
 * /           -If func is SIG_IGN, the target environment ignores subsequent reporting 
 * /            of the signal. 
 * /           -Otherwise, func must be the address of a function returning void that 
 * /            the target environment calls with a single int argument. The target 
 * /            environment calls this function to handle the signal when it is next 
 * /            reported, with the value of the signal as its argument. 
 * /           
 * /           When the target environment calls a signal handler: 
 * /            -The target environment can block further occurrences of the corresponding 
 * /             signal until the handler returns, calls longjmp, or calls signal for that signal. 
 * /            -The target environment can perform default handling of further occurrences 
 * /             of the corresponding signal. 
 * /            -For signal SIGILL, the target environment can leave handling unchanged for 
 * /             that signal. 
 * / 
 * / IMPLEMENTATION for APEnext:  possible         (signal) 
 * / --------------------------------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern void (*signal(int sig, void (*func)(int)))(int);
#else
#if defined(_uses_signal_signal_h) || !defined(__cflow_processed)
void (*signal(int sig, void (*func)(int)))(int)
{
#ifdef __cflow_processed
#  warning "Not fully implemented, always return SIG_ERR"
#endif
  return (void (*)(int)) SIG_ERR;
} 
#endif // signal()
#endif // Has Main

/*------------------------------------------------------------------------------------------------
 * / NAME   
 * /           raise - sends the signal sig
 * / 
 * / SYNOPSIS
 * /           #include <signal.h>
 * /
 * /           int raise(int sig)
 * / 
 * / DESCRIPTION
 * /           This function sends the signal sig.
 * /
 * / RETURN VALUE
 * /           Zero if the signal is successfully reported
 * /           Otherwise non-zero
 * / 
 * / Notes
 * /
 * / IMPLEMENTATION for APEnext:  possible         (raise) 
 * / --------------------------------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern int raise(int sig);
#else
#if defined(_uses_raise_signal_h) || !defined(__cflow_processed)
int raise(int sig)
{
#ifdef __cflow_processed
#  warning "Not fully implemented, always return -1"
#endif
  return -1;
} 
#endif // raise()
#endif // Has Main

#endif  /* ifndef _SIGNAL_H  */

---