


Synopsys:
     #include <signal.h>
     int raise(int SIG);

     int _raise_r(void *REENT, int SIG);
   
Description:
'raise' sends the signal SIG (one of the macros from sys/signal.h).  This
interrupts your program's normal flow of execution, and allows a signal
handler (if you've defined one, using signal) to take control.

   The alternate function '_raise_r' is a reentrant version.  The extra
argument REENT is a pointer to a reentrancy structure.

Returns:
The result is 0 if SIG was successfully raised, 1 otherwise.
However, the return value (since it depends on the normal flow of
execution) may not be visible, unless the signal handler for SIG
terminates with a return or unless 'SIG_IGN' is in effect for this
signal.

Portability:
ANSI C requires raise, but allows the full set of signal numbers to
vary from one implementation to another.

   Required OS subroutines: getpid, kill.

 





Synopsys:
     #include <signal.h>
     void ( * signal(int SIG, void(*FUNC)(int)) )(int);

     void ( * _signal_r(void *REENT,
         int SIG, void(*FUNC)(int)) )(int);

     int raise (int SIG);

     int _raise_r (void *REENT, int SIG);
   
Description:
'signal', raise provide a simple signal/raise implementation for
embedded targets.

   signal allows you to request changed treatment for a particular
signal SIG.  You can use one of the predefined macros 'SIG_DFL' (select
system default handling) or 'SIG_IGN' (ignore this signal) as the value
of FUNC; otherwise, FUNC is a function pointer that identifies a
subroutine in your program as the handler for this signal.

   Some of the execution environment for signal handlers is
unpredictable; notably, the only library function required to work
correctly from within a signal handler is signal itself, and only
when used to redefine the handler for the current signal value.

   Static storage is likewise unreliable for signal handlers, with one
exception: if you declare a static storage location as volatile
'sig_atomic_t', then you may use that location in a signal handler to
store signal values.

   If your signal handler terminates using return (or implicit
return), your program's execution continues at the point where it was
when the signal was raised (whether by your program itself, or by an
external event).  Signal handlers can also use functions such as exit
and abort to avoid returning.

   raise sends the signal sig to the executing program.  It returns
zero if successful, non-zero if unsuccessful.

   The alternate functions '_signal_r', _raise_r are the reentrant
versions.  The extra argument REENT is a pointer to a reentrancy
structure.

Returns:
If your request for a signal handler cannot be honored, the result is
'SIG_ERR'; a specific error number is also recorded in errno.

   Otherwise, the result is the previous handler (a function pointer or
one of the predefined macros).

Portability:
ANSI C requires raise, signal.

   No supporting OS subroutines are required to link with signal, but
it will not have any useful effects, except for software generated
signals, without an operating system that can actually raise exceptions.

