[BACK]Return to signal.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / less

Annotation of src/usr.bin/less/signal.c, Revision 1.1

1.1     ! etheisen    1: /*
        !             2:  * Copyright (c) 1984,1985,1989,1994,1995  Mark Nudelman
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms, with or without
        !             6:  * modification, are permitted provided that the following conditions
        !             7:  * are met:
        !             8:  * 1. Redistributions of source code must retain the above copyright
        !             9:  *    notice, this list of conditions and the following disclaimer.
        !            10:  * 2. Redistributions in binary form must reproduce the above copyright
        !            11:  *    notice in the documentation and/or other materials provided with
        !            12:  *    the distribution.
        !            13:  *
        !            14:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
        !            15:  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            16:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
        !            17:  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
        !            18:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
        !            19:  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
        !            20:  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
        !            21:  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
        !            22:  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
        !            23:  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
        !            24:  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
        !            25:  */
        !            26:
        !            27:
        !            28: /*
        !            29:  * Routines dealing with signals.
        !            30:  *
        !            31:  * A signal usually merely causes a bit to be set in the "signals" word.
        !            32:  * At some convenient time, the mainline code checks to see if any
        !            33:  * signals need processing by calling psignal().
        !            34:  * If we happen to be reading from a file [in iread()] at the time
        !            35:  * the signal is received, we call intread to interrupt the iread.
        !            36:  */
        !            37:
        !            38: #include "less.h"
        !            39: #include <signal.h>
        !            40:
        !            41: /*
        !            42:  * "sigs" contains bits indicating signals which need to be processed.
        !            43:  */
        !            44: public int sigs;
        !            45:
        !            46: extern int sc_width, sc_height;
        !            47: extern int screen_trashed;
        !            48: extern int lnloop;
        !            49: extern int linenums;
        !            50: extern int wscroll;
        !            51: extern int reading;
        !            52:
        !            53: /*
        !            54:  * Interrupt signal handler.
        !            55:  */
        !            56:        /* ARGSUSED*/
        !            57:        static RETSIGTYPE
        !            58: u_interrupt(type)
        !            59:        int type;
        !            60: {
        !            61: #if OS2
        !            62:        SIGNAL(SIGINT, SIG_ACK);
        !            63: #endif
        !            64:        SIGNAL(SIGINT, u_interrupt);
        !            65:        sigs |= S_INTERRUPT;
        !            66:        if (reading)
        !            67:                intread();
        !            68: }
        !            69:
        !            70: #ifdef SIGTSTP
        !            71: /*
        !            72:  * "Stop" (^Z) signal handler.
        !            73:  */
        !            74:        /* ARGSUSED*/
        !            75:        static RETSIGTYPE
        !            76: stop(type)
        !            77:        int type;
        !            78: {
        !            79:        SIGNAL(SIGTSTP, stop);
        !            80:        sigs |= S_STOP;
        !            81:        if (reading)
        !            82:                intread();
        !            83: }
        !            84: #endif
        !            85:
        !            86: #ifdef SIGWINCH
        !            87: /*
        !            88:  * "Window" change handler
        !            89:  */
        !            90:        /* ARGSUSED*/
        !            91:        public RETSIGTYPE
        !            92: winch(type)
        !            93:        int type;
        !            94: {
        !            95:        SIGNAL(SIGWINCH, winch);
        !            96:        sigs |= S_WINCH;
        !            97:        if (reading)
        !            98:                intread();
        !            99: }
        !           100: #else
        !           101: #ifdef SIGWIND
        !           102: /*
        !           103:  * "Window" change handler
        !           104:  */
        !           105:        /* ARGSUSED*/
        !           106:        public RETSIGTYPE
        !           107: winch(type)
        !           108:        int type;
        !           109: {
        !           110:        SIGNAL(SIGWIND, winch);
        !           111:        sigs |= S_WINCH;
        !           112:        if (reading)
        !           113:                intread();
        !           114: }
        !           115: #endif
        !           116: #endif
        !           117:
        !           118: /*
        !           119:  * Set up the signal handlers.
        !           120:  */
        !           121:        public void
        !           122: init_signals(on)
        !           123:        int on;
        !           124: {
        !           125:        if (on)
        !           126:        {
        !           127:                /*
        !           128:                 * Set signal handlers.
        !           129:                 */
        !           130:                (void) SIGNAL(SIGINT, u_interrupt);
        !           131: #ifdef SIGTSTP
        !           132:                (void) SIGNAL(SIGTSTP, stop);
        !           133: #endif
        !           134: #ifdef SIGWINCH
        !           135:                (void) SIGNAL(SIGWINCH, winch);
        !           136: #else
        !           137: #ifdef SIGWIND
        !           138:                (void) SIGNAL(SIGWIND, winch);
        !           139: #endif
        !           140: #endif
        !           141:        } else
        !           142:        {
        !           143:                /*
        !           144:                 * Restore signals to defaults.
        !           145:                 */
        !           146:                (void) SIGNAL(SIGINT, SIG_DFL);
        !           147: #ifdef SIGTSTP
        !           148:                (void) SIGNAL(SIGTSTP, SIG_DFL);
        !           149: #endif
        !           150: #ifdef SIGWINCH
        !           151:                (void) SIGNAL(SIGWINCH, SIG_IGN);
        !           152: #endif
        !           153: #ifdef SIGWIND
        !           154:                (void) SIGNAL(SIGWIND, SIG_IGN);
        !           155: #endif
        !           156:        }
        !           157: }
        !           158:
        !           159: /*
        !           160:  * Process any signals we have received.
        !           161:  * A received signal cause a bit to be set in "sigs".
        !           162:  */
        !           163:        public void
        !           164: psignals()
        !           165: {
        !           166:        register int tsignals;
        !           167:
        !           168:        if ((tsignals = sigs) == 0)
        !           169:                return;
        !           170:        sigs = 0;
        !           171:
        !           172: #ifdef SIGTSTP
        !           173:        if (tsignals & S_STOP)
        !           174:        {
        !           175:                /*
        !           176:                 * Clean up the terminal.
        !           177:                 */
        !           178: #ifdef SIGTTOU
        !           179:                SIGNAL(SIGTTOU, SIG_IGN);
        !           180: #endif
        !           181:                clear_bot();
        !           182:                deinit();
        !           183:                flush();
        !           184:                raw_mode(0);
        !           185: #ifdef SIGTTOU
        !           186:                SIGNAL(SIGTTOU, SIG_DFL);
        !           187: #endif
        !           188:                SIGNAL(SIGTSTP, SIG_DFL);
        !           189:                kill(getpid(), SIGTSTP);
        !           190:                /*
        !           191:                 * ... Bye bye. ...
        !           192:                 * Hopefully we'll be back later and resume here...
        !           193:                 * Reset the terminal and arrange to repaint the
        !           194:                 * screen when we get back to the main command loop.
        !           195:                 */
        !           196:                SIGNAL(SIGTSTP, stop);
        !           197:                raw_mode(1);
        !           198:                init();
        !           199:                screen_trashed = 1;
        !           200:                tsignals |= S_WINCH;
        !           201:        }
        !           202: #endif
        !           203: #ifdef S_WINCH
        !           204:        if (tsignals & S_WINCH)
        !           205:        {
        !           206:                int old_width, old_height;
        !           207:                /*
        !           208:                 * Re-execute scrsize() to read the new window size.
        !           209:                 */
        !           210:                old_width = sc_width;
        !           211:                old_height = sc_height;
        !           212:                get_term();
        !           213:                if (sc_width != old_width || sc_height != old_height)
        !           214:                {
        !           215:                        wscroll = (sc_height + 1) / 2;
        !           216:                        screen_trashed = 1;
        !           217:                }
        !           218:        }
        !           219: #endif
        !           220:        if (tsignals & S_INTERRUPT)
        !           221:        {
        !           222:                bell();
        !           223:                /*
        !           224:                 * {{ You may wish to replace the bell() with
        !           225:                 *    error("Interrupt", NULL_PARG); }}
        !           226:                 */
        !           227:
        !           228:                /*
        !           229:                 * If we were interrupted while in the "calculating
        !           230:                 * line numbers" loop, turn off line numbers.
        !           231:                 */
        !           232:                if (lnloop)
        !           233:                {
        !           234:                        lnloop = 0;
        !           235:                        if (linenums == 2)
        !           236:                                screen_trashed = 1;
        !           237:                        linenums = 0;
        !           238:                        error("Line numbers turned off", NULL_PARG);
        !           239:                }
        !           240:
        !           241:        }
        !           242: }