source: trunk/minix/commands/elvis/unix.c@ 11

/* unix.c */

/* Author:
 *      Steve Kirkendall
 *      14407 SW Teal Blvd. #C
 *      Beaverton, OR 97005
 *      kirkenda@cs.pdx.edu
 */


/* This file contains the unix-specific versions the ttyread() functions.
 * There are actually three versions of ttyread() defined here, because
 * BSD, SysV, and V7 all need quite different implementations.
 */

#include "config.h"
#if ANY_UNIX
# include "vi.h"

# if BSD
/* For BSD, we use select() to wait for characters to become available,
 * and then do a read() to actually get the characters.  We also try to
 * handle SIGWINCH -- if the signal arrives during the select() call, then
 * we adjust the o_columns and o_lines variables, and fake a control-L.
 */
#  include <sys/types.h>
#  include <sys/time.h>
int ttyread(buf, len, time)
        char    *buf;   /* where to store the gotten characters */
        int     len;    /* maximum number of characters to read */
        int     time;   /* maximum time to allow for reading */
{
        fd_set  rd;     /* the file descriptors that we want to read from */
        static  tty;    /* 'y' if reading from tty, or 'n' if not a tty */
        int     i;
        struct timeval t;
        struct timeval *tp;


        /* do we know whether this is a tty or not? */
        if (!tty)
        {
                tty = (isatty(0) ? 'y' : 'n');
        }

        /* compute the timeout value */
        if (time)
        {
                t.tv_sec = time / 10;
                t.tv_usec = (time % 10) * 100000L;
                tp = &t;
        }
        else
        {
                tp = (struct timeval *)0;
        }

        /* loop until we get characters or a definite EOF */
        for (;;)
        {
                if (tty == 'y')
                {
                        /* wait until timeout or characters are available */
                        FD_ZERO(&rd);
                        FD_SET(0, &rd);
                        i = select(1, &rd, (fd_set *)0, (fd_set *)0, tp);
                }
                else
                {
                        /* if reading from a file or pipe, never timeout!
                         * (This also affects the way that EOF is detected)
                         */
                        i = 1;
                }
        
                /* react accordingly... */
                switch (i)
                {
                  case -1:      /* assume we got an EINTR because of SIGWINCH */
                        if (*o_lines != LINES || *o_columns != COLS)
                        {
                                *o_lines = LINES;
                                *o_columns = COLS;
#ifndef CRUNCH
                                if (!wset)
                                {
                                        *o_window = LINES - 1;
                                }
#endif
                                if (mode != MODE_EX)
                                {
                                        /* pretend the user hit ^L */
                                        *buf = ctrl('L');
                                        return 1;
                                }
                        }
                        break;
        
                  case 0:       /* timeout */
                        return 0;
        
                  default:      /* characters available */
                        return read(0, buf, len);
                }
        }
}
# else

# if M_SYSV
/* For System-V or Coherent, we use VMIN/VTIME to implement the timeout.
 * For no timeout, VMIN should be 1 and VTIME should be 0; for timeout,
 * VMIN should be 0 and VTIME should be the timeout value.
 */
#  include <termio.h>
int ttyread(buf, len, time)
        char    *buf;   /* where to store the gotten characters */
        int     len;    /* maximum number of characters to read */
        int     time;   /* maximum time to allow for reading */
{
        struct termio tio;
        int     bytes;  /* number of bytes actually read */

        /* arrange for timeout */
        ioctl(0, TCGETA, &tio);
        if (time)
        {
                tio.c_cc[VMIN] = 0;
                tio.c_cc[VTIME] = time;
        }
        else
        {
                tio.c_cc[VMIN] = 1;
                tio.c_cc[VTIME] = 0;
        }
        ioctl(0, TCSETA, &tio);

        /* Perform the read.  Loop if EINTR error happens */
        while ((bytes = read(0, buf, len)) < 0)
        {
                /* probably EINTR error because a SIGWINCH was received */
                if (*o_lines != LINES || *o_columns != COLS)
                {
                        *o_lines = LINES;
                        *o_columns = COLS;
#ifndef CRUNCH
                        if (!wset)
                        {
                                *o_window = LINES - 1;
                        }
#endif
                        if (mode != MODE_EX)
                        {
                                /* pretend the user hit ^L */
                                *buf = ctrl('L');
                                return 1;
                        }
                }
        }

        /* return the number of bytes read */
        return bytes;

        /* NOTE: The terminal may be left in a timeout-mode after this function
         * returns.  This shouldn't be a problem since Elvis *NEVER* tries to
         * read from the keyboard except through this function.
         */
}

# else /* any other version of UNIX, assume it is V7 compatible */

/* For V7 UNIX (including Minix) we set an alarm() before doing a blocking
 * read(), and assume that the SIGALRM signal will cause the read() function
 * to give up.
 */

#include <setjmp.h>

static jmp_buf env;

/*ARGSUSED*/
int dummy(signo)
        int     signo;
{
        longjmp(env, 1);
}
int ttyread(buf, len, time)
        char    *buf;   /* where to store the gotten characters */
        int     len;    /* maximum number of characters to read */
        int     time;   /* maximum time to allow for reading */
{
        /* arrange for timeout */
#if __GNUC__ || _ANSI
        signal(SIGALRM, (void (*)()) dummy);
#else
        signal(SIGALRM, dummy);
#endif
        alarm(time);

        /* perform the blocking read */
        if (setjmp(env) == 0)
        {
                len = read(0, buf, len);
        }
        else /* I guess we timed out */
        {
                len = 0;
        }

        /* cancel the alarm */
#if _ANSI
        signal(SIGALRM, (void (*)())dummy); /* work around a bug in Minix */
#else
        signal(SIGALRM, dummy);             /* work around a bug in Minix */
#endif
        alarm(0);

        /* return the number of bytes read */
        if (len < 0)
                len = 0;
        return len;
}

# endif /* !(M_SYSV || COHERENT) */
# endif /* !BSD */

#endif /* ANY_UNIX */