Next Previous Contents

## 8. Signal Functions

Almost all non-trivial programs must worry about signals. This is especially true for programs that use the S-Lang terminal input/output and screen management routines. Unfortunately, there is no fixed way to handle signals; otherwise, the Unix kernel would take care of all issues regarding signals and the application programmer would never have to worry about them. For this reason, none of the routines in the S-Lang library catch signals; however, some of the routines block the delivery of signals during crucial moments. It is up to the application programmer to install handlers for the various signals of interest.

If the application makes use of the interpreter, then a signal handler for `SIGINT` should be installed to allow the user to break out of the interpreter via, e.g., `Ctrl-C`. In order for this to work, the signal handler should call `SLang_set_error` to generate a `SL_UserBreak_Error` exception, i.e.,

> `

>         void sigint_handler (int sig)
>         {
>            if (SLang_Ignore_User_Abort == 0)
>              SLang_set_error (SL_UserBreak_Error);
>         }

> `

Applications that use the `tty` `getkey` routines or the screen management routines must worry about signals such as:

> `

>          SIGINT                interrupt
>          SIGTSTP               stop
>          SIGQUIT               quit
>          SIGTTOU               background write
>          SIGTTIN               background read
>          SIGWINCH              window resize

> `

It is important that handlers be established for these signals while the either the `SLsmg` routines or the `getkey` routines are initialized. The `SLang_init_tty`, `SLang_reset_tty`, `SLsmg_init_smg`, and `SLsmg_reset_smg` functions block these signals from occuring while they are being called.

Since a signal can be delivered at any time, it is important for the signal handler to call only functions that can be called from a signal handler. This usually means that such function must be re-entrant. In particular, the `SLsmg` routines are not re-entrant; hence, they should not be called when a signal is being processed unless the application can ensure that the signal was not delivered while an `SLsmg` function was called. This statement applies to many other functions such as `malloc`, or, more generally, any function that calls `malloc`. The upshot is that the signal handler should not attempt to do too much except set a global variable for the application to look at while not in a signal handler.

The S-Lang library provides two functions for blocking and unblocking the above signals:

> `

>         int SLsig_block_signals (void);
>         int SLsig_unblock_signals (void);

> `

It should be noted that for every call to `SLsig_block_signals`, a corresponding call should be made to `SLsig_unblock_signals`, e.g.,

> `

>         void update_screen ()
>         {
>            SLsig_block_signals ();

>            /* Call SLsmg functions */
>                .
>                .
>            SLsig_unblock_signals ();
>         }

> `

See `demo/pager.c` for examples.

Next Previous Contents