Frozen Fish 1: Amiga/FrozenFish-Apr94.iso/bbs/alib/d0xx/d023/microemacs.lha/Ver30/Sys/Ultrix/ttyio.c

C/C++ Source or Header | 1986-05-10 | 4.7 KB | 197 lines

/*
 * Name:    MicroEMACS
 *        Ultrix-32 and Unix terminal I/O.
 * Version:    29 -- osu 2
 * Last edit:    22-Apr-86
 * By:        paul@ohio-state
 *        cbosgd!osu-eddie!paul
 *
 * The functions in this file
 * negotiate with the operating system for
 * keyboard characters, and write characters to
 * the display in a barely buffered fashion.
 */
#include    "def.h"

#include    <sgtty.h>

#define    NOBUF    512            /* Output buffer size.        */

char    obuf[NOBUF];            /* Output buffer.        */
int    nobuf;
struct    sgttyb    oldtty;            /* V6/V7 stty data.        */
struct    sgttyb    newtty;
struct    tchars    oldtchars;        /* V7 editing.            */
struct    tchars    newtchars;
struct    ltchars oldltchars;        /* 4.2 BSD editing.        */
struct    ltchars    newltchars;
int    nrow;                /* Terminal size, rows.        */
int    ncol;                /* Terminal size, columns.    */

/*
 * This function gets called once, to set up
 * the terminal channel. On Ultrix is's tricky, since
 * we want flow control, but we don't want any characters
 * stolen to send signals. Use CBREAK mode, and set all
 * characters but start and stop to 0xFF.
 */
ttopen()
{
    register char    *cp;
    extern char    *getenv();
#ifdef TERMCAP
        char *t, *p, *tgetstr();
        char tcbuf[1024];
        char *tv_stype;
        char err_str[72];
#endif

    if (ioctl(0, TIOCGETP, &oldtty) < 0)
        abort();
    newtty.sg_ospeed = oldtty.sg_ospeed;
    newtty.sg_ispeed = oldtty.sg_ispeed;
    newtty.sg_erase  = oldtty.sg_erase;
    newtty.sg_kill   = oldtty.sg_kill;
    newtty.sg_flags  = oldtty.sg_flags;
    newtty.sg_flags &= ~(ECHO|CRMOD);    /* Kill echo, CR=>NL.    */
#if FLOWCONTROL
    newtty.sg_flags |= CBREAK;        /* Half-cooked mode.    */
#else
    newtty.sg_flags |= RAW|ANYP;        /* raw mode for 8 bit path.*/
#endif
    if (ioctl(0, TIOCSETP, &newtty) < 0)
        abort();
    if (ioctl(0, TIOCGETC, &oldtchars) < 0)
        abort();
    newtchars.t_intrc  = 0xFF;        /* Interrupt.        */
    newtchars.t_quitc  = 0xFF;        /* Quit.        */
#if FLOWCONTROL
    newtchars.t_startc = 0x11;        /* ^Q, for terminal.    */
    newtchars.t_stopc  = 0x13;        /* ^S, for terminal.    */
#else
    newtchars.t_startc = 0xFF;        /* ^Q, for terminal.    */
    newtchars.t_stopc  = 0xFF;        /* ^S, for terminal.    */
#endif
    newtchars.t_eofc   = 0xFF;
    newtchars.t_brkc   = 0xFF;
    if (ioctl(0, TIOCSETC, &newtchars) < 0)
        abort();
    if (ioctl(0, TIOCGLTC, &oldltchars) < 0)
        abort();
    newltchars.t_suspc  = 0xFF;        /* Suspend #1.        */
    newltchars.t_dsuspc = 0xFF;        /* Suspend #2.        */
    newltchars.t_rprntc = 0xFF;
    newltchars.t_flushc = 0xFF;        /* Output flush.    */
    newltchars.t_werasc = 0xFF;
    newltchars.t_lnextc = 0xFF;        /* Literal next.    */
    if (ioctl(0, TIOCSLTC, &newltchars) < 0)
        abort();
#ifndef TERMCAP
    if ((cp=getenv("TERMCAP")) == NULL
    || (nrow=getvalue(cp, "li")) <= 0
    || (ncol=getvalue(cp, "co")) <= 0) {
#else

/* do this the REAL way */
        if ((tv_stype = getenv("TERM")) == NULL)
        {
                puts("Environment variable TERM not defined!");
                exit(1);
        }

        if((tgetent(tcbuf, tv_stype)) != 1)
        {
                sprintf(err_str, "Unknown terminal type %s!", tv_stype);
                puts(err_str);
                exit(1);
        }

    if ((nrow=tgetnum ("li")) <= 0
    || (ncol=tgetnum ("co")) <= 0) {
#endif TERMCAP
        nrow = 24;
        ncol = 80;
    }
    if (nrow > NROW)            /* Don't crash if the    */
        nrow = NROW;            /* termcap entry is    */
    if (ncol > NCOL)            /* too big.        */
        ncol = NCOL;
}

#ifndef TERMCAP
/*
 * This routine scans a string, which is
 * actually the return value of a getenv call for the TERMCAP
 * variable, looking for numeric parameter "name". Return the value
 * if found. Return -1 if not there. Assume that "name" is 2
 * characters long. This limited use of the TERMCAP lets us find
 * out the size of a window on the X display.
 */
getvalue(cp, name)
register char    *cp;
register char    *name;
{
    for (;;) {
        while (*cp!=0 && *cp!=':')
            ++cp;
        if (*cp++ == 0)            /* Not found.        */
            return (-1);
        if (cp[0]==name[0] && cp[1]==name[1] && cp[2]=='#')
            return (atoi(cp+3));    /* Stops on ":".    */
    }
}
#endif    /* TERMCAP */

/*
 * This function gets called just
 * before we go back home to the shell. Put all of
 * the terminal parameters back.
 */
ttclose()
{
    ttflush();
    if (ioctl(0, TIOCSLTC, &oldltchars) < 0)
        abort();
    if (ioctl(0, TIOCSETC, &oldtchars) < 0)
        abort();
    if (ioctl(0, TIOCSETP, &oldtty) < 0)
        abort();
}

/*
 * Write character to the display.
 * Characters are buffered up, to make things
 * a little bit more efficient.
 */
ttputc(c)
{
    if (nobuf >= NOBUF)
        ttflush();
    obuf[nobuf++] = c;
}

/*
 * Flush output.
 */
ttflush()
{
    if (nobuf != 0) {
        write(1, obuf, nobuf);
        nobuf = 0;
    }
}

/*
 * Read character from terminal.
 * All 8 bits are returned, so that you can use
 * a multi-national terminal.
 */
ttgetc()
{
    char    buf[1];

    while (read(0, &buf[0], 1) != 1)
        ;
    return (buf[0] & 0xFF);
}