mtree: no more /lib and /lib/i386.

[minix.git] / commands / elle / eeterm.c

/* ELLE - Copyright 1982, 1984, 1987 by Ken Harrenstien, SRI International
 *      This software is quasi-public; it may be used freely with
 *      like software, but may NOT be sold or made part of licensed
 *      products without permission of the author.
 */
/*
 *  EETERM      ELLE Terminal Driver.
 *      Directly supports DM2500, H-19, Omron 8025AG, Coherent/IBM-PC, TVI925.
 *      Others also supported if using TX_TERMCAP.
 */

#include "elle.h"

/* Define terminal indices (there may be holes but C preprocessor is too
 * stupid to let us close them).  Should be one TN_ definition for every
 * hardwired terminal type, even though whether or not it is actually
 * compiled depends on which TX_ switches are defined.
 */
#define TN_TERMCAP 0
#define TN_DM2500 1
#define TN_H19    2
#define TN_OM8025 3
#define TN_COHIBM 4     /* Coherent IBM-PC console */
#define TN_TVI925 5

#if TX_COHIBM && !(TX_H19)      /* Ensure H19 defined if COHIBM is. */
#define TX_H19 1
#endif

#ifndef TXS_DEFAULT             /* If no default is explicitly specified */
#define TXS_DEFAULT "H19"       /* Then settle for H-19 */
#endif /*TXS_DEFAULT*/
\f


extern char *tv_stype;  /* If set, specifies terminal type */
extern int tibfmsk;     /* Crock to mask off parity (meta) bit */
static int tv_padc;     /* Pad character to use */
static int tv_cspeed;   /* # msec per char (set from trm_ospeed) */
static int tv_type;     /* Index of selected terminal type */

/* Internal functions */
static void tpadn(), tpad();

/* Character speed table, indexed by system output speed value (0-017).
 * Value in table is 100 * <# msec used per character>.
 */
static int cspdtab[] =
{       /* Val    Idx Baud CPS  Time/char in msec */
        0,      /*  0 Hangup -  ----            */
        13333,  /*  1   50 7.5 133.33  (Baudot) */
        10000,  /*  2   75  10 100.0   (Baudot) */
        10000,  /*  3  110  10 100.0            */
         8200,  /*  4 134.5 12.2 82.0 (IBM2741) */
         6666,  /*  5  150  15  66.6666         */
         5000,  /*  6  200  20  50.0            */
         3333,  /*  7  300  30  33.3333         */
         1666,  /*  8  600  60  16.6666         */
          833,  /*  9 1200 120   8.3333         */
          555,  /* 10 1800 180   5.5555         */
          416,  /* 11 2400 240   4.1666         */
          208,  /* 12 4800 480   2.0833         */
          104,  /* 13 9600 960   1.04166        */
        0,      /* 14 Ext A  ?   ?              */
        0       /* 15 Ext B  ?   ?              */
};

#if TX_TERMCAP
/* Declarations for TERMCAP stuff.  Only EETERM knows about them. */

/* Termcap routines */
extern int tgetent(), tgetnum(), tgetflag(), tputs();
extern char *tgetstr(), *tgoto();
static int getcap();            /* Internal routines */
static void putpad(), putnpad(), putpar();

/* Gross disgusting externals that must be defined for TERMCAP rtns */
char    PC;             /* Pad char */
char    *BC;            /* Backspace to use, if not ^H */
char    *UP;            /* Cursor up */
short   ospeed;         /* Terminal output speed */

/* Termcap numerical values/flags */
static int
        tc_am,          /* TRUE if has auto-wrap */
        tc_km;          /* TRUE if meta key exists */

/* Termcap capability strings we want to know about */

struct tcap { char tcicod1, tcicod2, *tccap; };
static struct tcap tcap[] = {
#define TC_al   tcap[0].tccap   /* Add (insert) line */
        {'a','l', 0},
#define TC_AL   tcap[1].tccap   /* Add N lines */
        {'A','L', 0},
#define TC_bc   tcap[2].tccap   /* Backspace Char (for BC) */
        {'b','c', 0},
#define TC_ce   tcap[3].tccap   /* Erase to end of line (CLEOL) */
        {'c','e', 0},
#define TC_cl   tcap[4].tccap   /* Clear screen */
        {'c','l', 0},
#define TC_cm   tcap[5].tccap   /* Cursor motion */
        {'c','m', 0},
#define TC_dc   tcap[6].tccap   /* Delete char */
        {'d','c', 0},
#define TC_DC   tcap[7].tccap   /* Delete N chars */
        {'D','C', 0},
#define TC_dl   tcap[8].tccap   /* Delete line */
        {'d','l', 0},
#define TC_DL   tcap[9].tccap   /* Delete N lines */
        {'D','L', 0},
#define TC_dm   tcap[10].tccap  /* Delete mode on */
        {'d','m', 0},
#define TC_ed   tcap[11].tccap  /* Delete mode off */
        {'e','d', 0},
#define TC_ei   tcap[12].tccap  /* Insert mode off */
        {'e','i', 0},
#define TC_ia   tcap[13].tccap  /* Add line while in insert mode (see note) */
        {'i','a', 0},
#define TC_ic   tcap[14].tccap  /* Insert blank char */
        {'i','c', 0},
#define TC_IC   tcap[15].tccap  /* Insert N blank chars */
        {'I','C', 0},
#define TC_id   tcap[16].tccap  /* Delete line while in del mode (see note) */
        {'i','d', 0},
#define TC_im   tcap[17].tccap  /* Insert mode on */
        {'i','m', 0},
#define TC_ip   tcap[18].tccap  /* Padding to send after char insertion */
        {'i','p', 0},
#define TC_mm   tcap[19].tccap  /* String to set (turn on) meta-key mode */
        {'m','m', 0},
#define TC_mo   tcap[20].tccap  /* String to reset (turn off) meta-key mode */
        {'m','o', 0},
#define TC_pc   tcap[21].tccap  /* Pad Char (for PC) */
        {'p','c', 0},
#define TC_se   tcap[22].tccap  /* End standout mode */
        {'s','e', 0},
#define TC_so   tcap[23].tccap  /* Enter standout mode */
        {'s','o', 0},
#define TC_te   tcap[24].tccap  /* String to end programs that use termcap */
        {'t','e', 0},
#define TC_ti   tcap[25].tccap  /* String to beg programs that use termcap */
        {'t','i', 0},
#define TC_up   tcap[26].tccap  /* Move cursor up (for UP) */
        {'u','p', 0},
#define TC_vb   tcap[27].tccap  /* Visible bell */
        {'v','b', 0},
};
#define NTCAPS ((sizeof(tcap))/(sizeof(struct tcap)))   /* # entries */

/*
 * There are many other things that must be taken into account.
 * The termcap code here will probably not work for many termcap entries,
 * but the only sure way to find out which ones they are is to try them.
 */
/* Note that the "ia" and "id" strings are not defined by the TERMCAP doc;
 * their usage here is derived from examining other TERMCAP-using programs.
 * Sigh!!!!
 */
#endif /*TX_TERMCAP*/
\f
/* T_INIT is called once only at program startup, to identify the
 *      terminal type and set up any one-time things.
 * T_FATAL is only called if some routine detects an error related to the
 *      terminal specification, before any initialization is done.
 *      It prints a short error message and exits the program.
 * T_ENTER is called after TS_ENTER to set the terminal parameters for
 *      editing (as opposed to normal typeout).  It may be called
 *      several times.
 * T_EXIT is called before TS_EXIT to restore normal typeout modes.
 *      It is called on exit from the program, and perhaps other times.
 */
t_init()
{
        char *getenv();

        /* Set some default parameters */
        scr_ht = 24;
        scr_wid = 79;
        trm_flags = 0;
        tvc_cin = 1;            /* Assume 1 char per char I/D pos */
        tvc_cdn = 1;
        tvc_pos = 4;            /* Default abs-move cost is 4 chars */
        tvc_bs = 1;             /* Default backspace cost is 1 char */
        tv_cspeed = cspdtab[trm_ospeed];        /* Find # msec per char */

        /* First must determine terminal type, and check for terminals
         * that are hardwired into ELLE. */
        if(!tv_stype            /* String set in command line args? */
#if !(V6)
         && !(tv_stype = getenv("TERM"))        /* or given by TERM var? */
#endif /*-V6*/
                ) tv_stype = TXS_DEFAULT;       /* No, try using default */
        if(0) ;                 /* Sigh, stupid construct */
#if TX_H19
        else if(ustrcmp(tv_stype,"H19")) tv_type = TN_H19;
#endif /*TX_H19*/
#if TX_OM8025
        else if(ustrcmp(tv_stype,"OM8025")) tv_type = TN_OM8025;
#endif /*TX_OM8025*/
#if TX_DM2500
        else if(ustrcmp(tv_stype,"DM2500")) tv_type = TN_DM2500;
        else if(ustrcmp(tv_stype,"DM3025")) tv_type = TN_DM2500;
#endif /*TX_DM2500*/
#if TX_COHIBM
        else if(ustrcmp(tv_stype,"COHIBM")) tv_type = TN_COHIBM;
#endif /*TX_COHIBM*/
#if TX_TVI925
        else if(ustrcmp(tv_stype,"TVI925")) tv_type = TN_TVI925;
#endif /*TX_TVI925*/
#if TX_TERMCAP  /* This should be last thing */
        else if(getcap(tv_stype)) tv_type = TN_TERMCAP;
#endif /*TX_TERMCAP*/
        else t_fatal("type unknown");   /* Ugh, barf and exit */

        /* Terminal selected, now initialize parameters for it. */
        switch(tv_type)
          {
#if TX_DM2500
                case TN_DM2500:
                        tv_padc = 0177;         /* Use rubout for pad */
                        tvc_pos = 3;            /* Only 3 chars for abs mov */
                        tvc_ci = 2;
                /*      tvc_cin = 1; */         /* Default is OK */
                        tvc_cd = 2;
                /*      tvc_cdn = 1; */         /* Default is OK */
                        tvc_ld = 2;
                        tvc_ldn = 1;
                        tvc_li = 2;
                        tvc_lin = 1;
                        if(trm_ospeed == 13)    /* If 9600, */
                          {     tvc_cin = 5;            /* Sigh, high cost */
                                tvc_cdn = 2;
                                tvc_lin = 18;
                                tvc_ldn = 2;
                          }
                        trm_flags |= TF_IDLIN|TF_IDCHR|TF_CLEOL|TF_METAKEY;
                        break;
#endif /*TX_DM2500*/
#if TX_H19
                case TN_H19:                    
                        trm_flags |= TF_IDLIN|TF_IDCHR|TF_CLEOL;
                        tvc_ci = 8;
                /*      tvc_cin = 1; */ /* default is ok */
                        tvc_cd = 0;
                        tvc_cdn = 2;
                /*      tvc_ld = 0; */  /* Default is OK */
                        tvc_ldn = 1 << (trm_ospeed - 7);
                /*      tvc_li = 0; */  /* Default is OK */
                        tvc_lin = tvc_ldn;
                        break;
#endif /*TX_H19*/
#if TX_COHIBM
                case TN_COHIBM:
                        trm_flags |= TF_IDLIN|TF_IDCHR|TF_CLEOL|TF_METAKEY|TF_DIRVID;
                        /* Always use lowest possible costs */
                /*      tvc_ci = 0; */  /* Default */
                        tvc_cin = 2;
                /*      tvc_cd = 0; */  /* Default */
                        tvc_cdn = 2;
                /*      tvc_ld = 0; */  /* Default */
                        tvc_ldn = 2;
                /*      tvc_li = 0; */  /* Default */
                        tvc_lin = 2;
                        break;
#endif /*TX_COHIBM*/
#if TX_OM8025
                case TN_OM8025:
                        trm_flags |= TF_IDLIN|TF_IDCHR|TF_CLEOL;
                        tvc_pos = 6;
                /*      tvc_ci = tvc_cd = 0; */ /* Default */
                        tvc_cin = 4;
                        tvc_cdn = 2;
                /*      tvc_ld = tvc_li = 0; */ /* Default */
                        tvc_ldn = 10;           /* Crude approx */
                        tvc_lin = 10;
                        if(trm_ospeed > 7)      /* If faster than 300 baud */
                                trm_flags &= ~TF_IDLIN; /* Turn off LID */
                        break;
#endif /*TX_OM8025*/
#if TX_TVI925
                case TN_TVI925:
                        trm_flags |= TF_IDLIN|TF_IDCHR|TF_CLEOL;
                        tvc_ci = tvc_cd = tvc_cin = tvc_cdn
                                = tvc_ldn = tvc_lin = 2;
                        break;
#endif /*TX_TVI925*/
          }
        if(tibfmsk < 0)         /* If mask is still default -1, set it. */
                tibfmsk = ((trm_flags&TF_METAKEY) ? 0377 : 0177);
}

/* T_FATAL(str) - prints error message and exits.
*/
t_fatal(str)
char *str;
{       writerr("ELLE: \"");
        writerr(tv_stype);
        writerr("\" terminal ");
        writerr(str);
        writerr("\n");
        exit(1);                /* Terminate with prejudice */
}
\f
/* T_ENTER is called after TS_ENTER to set the terminal parameters for
 *      editing (as opposed to normal typeout).
 *      Standout mode must initially be off.
 */

t_enter()
{       switch(tv_type)
          {
#if TX_TERMCAP
                case TN_TERMCAP:
                        putpad(TC_ti);
                        if(tc_km) putpad(TC_mm);        /* Use meta if poss */
#if FX_SOWIND
                        t_standout(0);          /* Ensure standout mode off */
#endif
                        break;
#endif /*TX_TERMCAP*/
#if TX_DM2500
                case TN_DM2500:
                        tput(030);      /* Just in case, flush stray modes */
                        break;
#endif /*TX_DM2500*/
#if TX_COHIBM
                case TN_COHIBM:         /* Note TN_H19 will exist too */
#endif /*TX_COHIBM*/
#if TX_H19
                case TN_H19:
                        /* Enter ZDS (Heath) mode, then
                         * Exit graphics mode (G) Exit ins-char mode (O)
                         * exit rev video mode (q) exit hold-screen mode (\)
                         * set cursor on (y5)
                         */
                        tputz("\033[?2h\033G\033O\033q\033\\\033y5");
                        /* Set Discard-at-EOL (w)
                         * Set no auto-CR (y9)
                         * Enable 25th line (x1)
                         */
                        tputz("\033w\033y9\033x1");
                        break;
#endif /*TX_H19*/
          }
}
\f
/* T_EXIT - Leave editing modes.  This function should restore
**      the terminal's modes to what they were before ELLE was started.
**      Standout mode is turned off.
*/

t_exit()
{
        switch(tv_type)
          {
#if TX_TERMCAP
                case TN_TERMCAP:
                        if(tc_km) putpad(TC_mo);        /* Turn off meta */
                        putpad(TC_te);
                        break;
#endif /*TX_TERMCAP*/
#if TX_DM2500
                case TN_DM2500:
                        tput(035);      /* Turn on roll mode */
                        break;
#endif /*TX_DM2500*/
#if TX_COHIBM
                case TN_COHIBM:         /* If this exists, TN_H19 will too */
#endif /*TX_COHIBM*/
#if TX_H19
                case TN_H19:
                        tputz("\033v");         /* Turn EOL-wrap back on */
#if DNTTY
                        tputz("\033<");         /* Return to ANSI mode */
#endif /*DNTTY*/
                        break;
#endif /*TX_H19*/
          }
}
\f
/* T_CLEAR() - Clears the screen and homes the cursor.
 *      Always valid - ELLE refuses to support terminals without this.
 */

t_clear ()
{       switch(tv_type)
          {
#if TX_TERMCAP
                case TN_TERMCAP:
                        putnpad(TC_cl,scr_ht);
                        break;
#endif /*TX_TERMCAP*/
#if TX_DM2500
                case TN_DM2500:
                        tputz("\036\036");      /* Double Master Clear */
                        break;
#endif /*TX_DM2500*/
#if TX_COHIBM
                case TN_COHIBM:         /* Note TN_H19 will exist too */
#endif /*TX_COHIBM*/
#if TX_H19
                case TN_H19:
                        tputz("\033E");
                /*      tputn(zpadstr,9);       */
                        break;
#endif /*TX_H19*/
#if TX_OM8025
                case TN_OM8025:
                        tputz("\033H\033J");    /* Home then CLEOS */
                        tpad(1000);             /* One second!!!! */
                        break;
#endif /*TX_OM8025*/
#if TX_TVI925
                case TN_TVI925:
                        tput(032);      /* ^Z */
                        break;
#endif /*TX_TVI925*/
          }
        curs_lin = curs_col = 0;
}
\f
/* T_CURPOS(y, x) - Absolute move.  Place cursor in given position
 *      regardless of where it currently is.
 *      Updates curs_lin, curs_col.
 *      Always valid -- ELLE refuses to support terminals without this.
 */

t_curpos (lin, col)
register int lin, col;
{
        if(col > scr_wid)               /* Easiest to catch here */
                col = scr_wid;

        /* Do absolute positioning */
        switch(tv_type)
          {
#if TX_TERMCAP
                case TN_TERMCAP:
                        putpad(tgoto(TC_cm, col, lin));
                        break;
#endif /*TX_TERMCAP*/
#if TX_DM2500
                case TN_DM2500:
                        tput(014);
                        tput(col^0140);
                        tput(lin^0140);
                        break;
#endif /*TX_DM2500*/
#if TX_COHIBM
                case TN_COHIBM:         /* If this exists, TN_H19 will too */
#endif /*TX_COHIBM*/
#if TX_H19
                case TN_H19:
                        tputz("\033Y");
                        tput(lin+040);
                        tput(col+040);
                        break;
#endif /*TX_H19*/
#if TX_OM8025
                case TN_OM8025:
                        tputz("\033\175");
                        tput(0100+((lin+1)>>4));
                        tput(0100+((lin+1)&017));
                        tput(0100+((col+1)>>4));
                        tput(0100+((col+1)&017));
                        break;
#endif /*TX_OM8025*/
#if TX_TVI925
                case TN_TVI925:
                        tputz("\033=");
                        tput(lin+040);
                        tput(col+040);
                        break;
#endif /*TX_TVI925*/
          }
        curs_lin = lin;
        curs_col = col;
}

/* T_BACKSPACE() - Back up 1 character position.
 *      Updates curs_col.
 *      Only valid if tvc_bs has a "reasonable" value ( < 1000)
 */

t_backspace()
{
#if TX_TERMCAP
        if(BC) tputz(BC);       /* Use alternate BS */
        else
#endif
        tput('\010');           /* Send BS */
        --curs_col;
}

/* T_BELL() - Ring terminal's bell (or flash something, or whatever).
 *      Forces out all output thus far, to ensure immediate attention.
 *      This used to be an unbuffered feep, but was changed to use normal
 *      output path in order to avoid messing up terminal escape sequences.
 */
t_bell()
{
#if TXC_VISBEL && TX_TERMCAP
        if(TC_vb)
                tputz(TC_vb);           /* Do visible bell if possible */
        else
#endif
        tput(BELL);
        tbufls();       /* Force it out */
}
\f
/* T_CLEOL() - Clear to End Of Line.
 *      Only valid if trm_flags has TF_CLEOL set.
 */

t_cleol ()
{
        switch(tv_type)
          {
#if TX_TERMCAP
                case TN_TERMCAP:
                        putpad(TC_ce);
                        break;
#endif /*TX_TERMCAP*/
#if TX_DM2500
                case TN_DM2500:
                        tput(027);
                        break;
#endif /*TX_DM2500*/
#if TX_COHIBM
                case TN_COHIBM:         /* If this exists, TN_H19 will too */
#endif /*TX_COHIBM*/
#if TX_H19
                case TN_H19:
                        tputz("\033K");
                        break;
#endif /*TX_H19*/
#if TX_OM8025
                case TN_OM8025:
                        tputz("\033K");
                        tpad(41);       /* 1/25 sec padding */
                        break;
#endif /*TX_OM8025*/
#if TX_TVI925
                case TN_TVI925:
                        tputz("\033T");
                        break;
#endif /*TX_TVI925*/
          }
}
\f
/* T_INSLIN(n, bot) - Insert lines in window.
 *      n   - # blank lines to insert.
 *      bot - # of last line of current window
 *
 *              The current line is moved down and N blank lines inserted.
 *      Lines which are moved past bot are lost.
 *      May leave cursor in random place.
 *      Only valid if trm_flags has TF_IDLIN set.
 */

t_inslin (n, bot)
int   n;                        /* number of lines */
int   bot;                      /* line number of last line in window */
{       register  i, j;
        int savc,savl;

        if((i = n) <= 0) return;
        if(bot < (scr_ht-1))
          {     savc = curs_col;
                savl = curs_lin;
                t_curpos(bot-i, 0);
                t_dellin(i, scr_ht);
                t_curpos(savl, savc);
          }
        switch(tv_type)
          {
#if TX_TERMCAP
                case TN_TERMCAP:
                        if(TC_AL)
                                putpar(TC_AL, i, i);
                        else if(TC_ia)
                          {     putpad(TC_im);
                                do { putpad(TC_ia);
                                  } while(--i);
                                putpad(TC_ei);
                          }
                        else
                                do { putnpad(TC_al, scr_ht - curs_lin);
                                  } while(--i);
                        break;
#endif /*TX_TERMCAP*/
#if TX_DM2500
                case TN_DM2500:
                        tput(020);              /* Enter I/D mode */
                        do {    tput(012);              /* Insert line */
                                switch(trm_ospeed)
                                  {     case 13: j = 17; break; /* 9600 */
                                        case 12: j = 8; break;  /* 4800 */
                                        case 11: j = 4; break;  /* 2400 */
                                        case 9:  j = 2; break;  /* 1200 */
                                        default: j = 0; break;
                                  }
                                tpadn(j);
                          } while(--i);
                        tput(030);                      /* Exit I/D mode */
                        break;
#endif /*TX_DM2500*/
#if TX_H19
        /* NOTE: H19 supposedly requires 19 ms for each line during line I/D
         * operations.
         * In actual practice, at 9600 baud 25 pads are necessary (24 wont work!)
         * for both I and D.  Plus esc-E needs 9 pads.
         */
                case TN_H19:
                        do {    tputz("\033L");
                                switch(trm_ospeed)
                                  {     case 13: j = 25; break;
                                        case 9: j = 4; break;
                                        case 7: j = 1; break;
                                        default: j = 0; break;
                                  }
                                tpadn(j);
                          } while(--i);
                        break;
#endif /*TX_H19*/
#if TX_COHIBM
                case TN_COHIBM:
                        do {    tputz("\033L");  /* no padding required */
                          } while(--i);
                        break;
#endif /*TX_COHIBM*/
#if TX_OM8025
                case TN_OM8025:
                        do {    tputz("\033L");
                                tpad(100*(scr_ht - curs_lin));  /* .1 per moved line*/
                          } while(--i);
                        break;
#endif /*TX_OM8025*/
#if TX_TVI925
                case TN_TVI925:
                        do tputz("\033E");
                        while(--i);
                        break;
#endif /*TX_TVI925*/
          }
}
\f
/* T_DELLIN(n, bot) - Delete lines from window.
 *      n   - # lines to delete.
 *      bot - # of last line of current window.
 *              The current line, and N-1 following lines, are deleted.
 *      Blank lines are inserted past bot.
 *      Cursor should be left at original position.
 *      Only valid if trm_flags has TF_IDLIN set.
 */
t_dellin (n, bot)
int   n;                        /* number of lines */
int   bot;                      /* line number of last line in window */
{       register  i, j;
        int savl, savc;

        if((i = n) <= 0) return;
        switch(tv_type)
          {
#if TX_TERMCAP
                case TN_TERMCAP:
                        if(TC_DL)
                                putpar(TC_DL, i, i);
                        else if(TC_id)
                          {     putpad(TC_dm);
                                do putpad(TC_id);
                                while(--i);
                                putpad(TC_ed);
                          }
                        else
                                do { putnpad(TC_dl,scr_ht - curs_lin);
                                  } while(--i);

                        break;
#endif /*TX_TERMCAP*/
#if TX_DM2500
                case TN_DM2500:
                        tput(020);
                        do {    tput(032);
                                if(trm_ospeed >= 13)    /* 9600 */
                                        tput(0177);
                          } while(--i);
                        tput(030);
                        break;
#endif /*TX_DM2500*/
#if TX_H19
                case TN_H19:
                        do {    tputz("\033M");
                                switch(trm_ospeed){
                                        case 13: j = 25; break;
                                        case 9: j = 4; break;
                                        case 7: j = 1; break;
                                        default: j = 0; break;
                                        }
                                tpadn(j);
                          } while(--i);
                        break;
#endif /*TX_H19*/
#if TX_COHIBM
                case TN_COHIBM:
                        do {    tputz("\033M");   /* no padding required */
                          } while(--i);
                        break;
#endif /*TX_COHIBM*/
#if TX_OM8025
                case TN_OM8025:
                        do {    tputz("\033M");
                                tpad(100*(scr_ht - curs_lin));
                          } while(--i);
                        break;
#endif /*TX_OM8025*/
#if TX_TVI925
                case TN_TVI925:
                        do {    tputz("\033R");
                          } while(--i);
                        break;
#endif /*TX_TVI925*/
          }
        if(bot < (scr_ht-1))
          {     savl = curs_lin;
                savc = curs_col;
                t_curpos(bot-n,0);
                t_inslin(n,scr_ht);
                t_curpos(savl,savc);
          }
}
\f
/* T_INSCHR(n, str) - Insert n chars in current line
 *      n   - # characters to insert
 *      str - Pointer to char string.  If 0, insert spaces.
 *
 *      Insert N characters from string str at current position.
 *      The cursor may move but curs_col must be updated.
 *      Only valid if trm_flags has TF_IDCHR set.
 */
t_inschr(n, str)
int n;
char *str;
{       register int i;
        register char *cp;

        if((i = n) <= 0) return;
        cp = str;
        switch(tv_type)
          {
#if TX_TERMCAP
                case TN_TERMCAP:
                        putpad(TC_im);          /* Go into insert mode */
                        if(TC_IC)
                          {     putpar(TC_IC, i, 1);
                                if(cp) tputn(cp, i);
                                else do tput(SP); while(--i);
                          }
                        else do {
                                if(TC_ic) putpad(TC_ic);
                                if(cp) tput(*cp++);
                                else tput(SP);
                                if(TC_ip) putpad(TC_ip);
                          } while(--i);
                        putpad(TC_ei);          /* Exit insert mode */
                        curs_col += n;
                        break;
#endif /*TX_TERMCAP*/
#if TX_COHIBM
                case TN_COHIBM:         /* If this exists, TN_H19 will too */
#endif /*TX_COHIBM*/
#if TX_H19
                case TN_H19:
                        tputz("\033@");         /* Enter ins char mode */
                        do {    if(cp) tput(*cp++);
                                else tput(SP);
                          } while(--i);
                        tputz("\033O");         /* Exit ins char mode */
                        curs_col += n;
                        break;
#endif /*TX_H19*/
#if TX_DM2500
                case TN_DM2500:
                        tput(020);              /* Enter I/D mode */
                        if(trm_ospeed == 13)    /* 9600 baud lossage */
                          {     do {
                                        tputz(" \177"); /* SP and DEL */
                                  } while(--i);
                                tput(030);
                                i = n;
                                if(i < 3)       /* If close enough, */
                                        tputn("\010\010", i);   /* use BSes */
                                else t_curpos(curs_lin, curs_col);
                          }
                        else                    /* Not 9600, can win */
                          {     do { tput(034);
                                  } while(--i);
                                tput(030);
                                if(cp == 0) return;
                                i = n;
                          }

                        do {    if(cp) tput(*cp++);
                                else tput(SP);
                          } while(--i);
                        curs_col += n;
                        break;
#endif /*TX_DM2500*/
#if TX_OM8025
                case TN_OM8025:
                        do {
                                tputz("\033@");
                                if(cp) tput(*cp++);
                                else tput(SP);
                          } while(--i);
                        curs_col += n;
                        break;
#endif /*TX_OM8025*/
#if TX_TVI925
                case TN_TVI925:
                        do {    tputz("\033Q");
                          } while(--i);
                        if(cp)
                          {     tputn(cp, n);
                                curs_col += n;
                          }
                        break;
#endif /*TX_TVI925*/
          }
}
\f
/* T_DELCHR(n) - Delete N chars in current line.
 *      Deletes the N characters to the right of the cursor.  Remaining
 *      chars are shifted left.  The cursor should not move.
 *      Only valid if trm_flags has TF_IDCHR set.
 */
t_delchr(n)             /* Delete N chars at current loc */
int n;
{       register int i;

        if((i = n) <= 0) return;
        switch(tv_type)
          {
#if TX_TERMCAP
                case TN_TERMCAP:
                        putpad(TC_dm);  /* Enter delete mode */
                        if(TC_DC)
                                putpar(TC_DC, i, 1);
                        else do {       /* Delete char while in del mode */
                                putpad(TC_dc);
                        } while(--i);
                        putpad(TC_ed);  /* Exit delete mode */
                        break;
#endif /*TX_TERMCAP*/
#if TX_COHIBM
                case TN_COHIBM:         /* If this exists, TN_H19 will too */
#endif /*TX_COHIBM*/
#if TX_H19
                case TN_H19:
                        do tputz("\033N");
                        while(--i);
                        break;
#endif /*TX_H19*/
#if TX_DM2500
                case TN_DM2500:
                        tput(020);              /* Enter I/D mode */
                        do if(trm_ospeed == 13) /* 9600? */
                                tputz("\010\177");      /* BS and DEL */
                          else tput(010);
                        while(--i);
                        tput(030);              /* Exit I/D mode */
                        break;
#endif /*TX_DM2500*/
#if TX_OM8025
                case TN_OM8025:
                        do tputz("\033P");
                        while (--i);
                        break;
#endif /*TX_OM8025*/
#if TX_TVI925
                case TN_TVI925:
                        do {    tputz("\033W");
                          } while(--i);
#endif /*TX_TVI925*/
          }
}
\f
#if FX_SOWIND

/* T_STANDOUT(n) - Enter or leave standout mode.
 *      n   - 0 to return to normal display mode,
 *            1 to enter standout display mode.
 *              This is usually reverse video but may be something else.
 *
 *      Only valid if trm_flags has TF_SO set.
 */

t_standout(on)
int on;
{
        switch(tv_type)
          {
#if TX_TERMCAP
                case TN_TERMCAP:
                        putpad(on ? TC_so : TC_se);
                        break;
#endif /*TX_TERMCAP*/

#if TX_COHIBM
                case TN_COHIBM:         /* Note TN_H19 will exist too */
#endif /*TX_COHIBM*/
#if TX_H19
                case TN_H19:
                        tputz(on ? "\033p" : "\033q");
                        break;
#endif /*TX_H19*/
          }
}
#endif /*FX_SOWIND*/
\f

/* TPADN(n) - Output N pad chars.
 */
static void
tpadn(n)
int n;
{       register int i, pad;
        if((i = n) > 0)
          {     pad = tv_padc;
                do { tput(pad);
                  } while(--i);
          }
}

/* TPAD(msec) - Output padding for given # of milliseconds.
 */
static void
tpad(n)
int n;
{       register int i, i2;

        i = n;
        while(i > 0)
          {     if((i2 = 320) < i)      /* So can use integers */
                        i2 = i;
                i -= i2;
                i2 *= 100;
                while((i2 -= tv_cspeed) > 0)
                        tput(tv_padc);
          }
}
#if TX_TERMCAP
/*
 * Print the string str, interpreting padding.
 */
int tput();     /* Our output function */
static void
putpad(str)
char *str;
{       if(str) tputs(str, 1, tput);    /* Invoke TERMCAP function */
}
static void
putnpad(str,n)
char *str;
int n;
{       if(str) tputs(str, n, tput);
}
static void
putpar(str, par, n)             /* Wish we had tparm() */
char *str;
int par,n;
{       putnpad(tgoto(str, 0, par), n);
}
#endif /*TX_TERMCAP*/
\f
/*
 * Read in the stuff from termcap upon startup.
 */

#if TX_TERMCAP
static int tstrlen(), tstrlp();

#ifndef TCAPSLEN
#define TCAPSLEN 1024   /* Default size of buffer for TERMCAP strings */
#endif /*-TCAPSLEN*/

static int
getcap(stype)
char *stype;
{       register int i;
        int buflen;
        char *tcbuf, *tcbptr;           /* Pointers into termcap buffer */
        char tmpstr[4];
        char tmpbuf[TCAPSLEN];          /* Allocate from stack */
        char *malloc();
        char *realloc();

        /* First see if can find the terminal type. */
        if((tgetent(tmpbuf, stype)) != 1)
                return(0);

        /* Found it!  Set up a string buffer to save the caps. */
        if(!(tcbuf = malloc(TCAPSLEN))) /* Get permanent buffer */
                t_fatal(" - cannot allocate termcap buffer");
        tcbptr = tcbuf;

        /* Now gobble all the string caps that ELLE wants to know about. */
        tmpstr[3] = '\0';
        i = NTCAPS;
        do {
                tmpstr[0] = tcap[i].tcicod1;    /* Make str of the code */
                tmpstr[1] = tcap[i].tcicod2;
                tcap[i].tccap = tgetstr(tmpstr, &tcbptr);       /* Get cap */
        } while(--i);
        buflen = tcbptr - tcbuf;        /* String buffer done, finalize */
        if(buflen >= TCAPSLEN)
                t_fatal("description too big!");
        realloc(tcbuf, buflen);         /* Free up unused part of buffer */
                                        /* (this better not move it!!!) */

        /* Now get the number/flag stuff that ELLE needs. */
        tc_am = tgetflag("am");         /* auto wrap */
        if (tgetflag("xn")) tc_am = 0;  /* auto wrap at 81st char, nice! */
        tc_km = (tgetflag("km")         /* TTY has meta key */
                || tgetflag("MT"));     /* Alternate version of "km"?? */
        scr_ht = tgetnum("li");         /* Set screen height (# lines) */
        scr_wid = tgetnum("co");        /* Set screen width (# cols) */
        ts_winsize();

        /* Now initialize the stupid external vars that TERMCAP rtns want. */
        if(TC_pc) PC = *TC_pc;  /* Pad char */
        BC = TC_bc;             /* Backspace str (if no BS) */
        UP = TC_up;             /* Cursor up */
        ospeed = trm_ospeed;    /* Put output speed here */


        /* Basic data extracted, now mull over it and set the remaining
         * ELLE variables
         */
#if FX_SOWIND
        if(tgetnum("sg") <= 0)          /* If no magic cookie problems */
          {     if (TC_so && TC_se)     /* And have standout caps, */
                        trm_flags |= TF_SO;     /* Say has standout cap */
          }
#endif

        if (!(TC_cm && TC_cl))
                t_fatal("lacks cursor addressing or clear screen.");
        tvc_pos = tstrlen(TC_cm);               /* Find cost of abs move */
        if(BC)                                  /* Find cost of backspace */
                tvc_bs = tstrlen(BC);

        /* Find costs for doing I/D char operations */
        if ((TC_im||TC_ic) && (TC_dm||TC_dc))
          {     trm_flags |= TF_IDCHR;
                tvc_ci  = tstrlen(TC_im)+tstrlen(TC_ei);
                tvc_cin = tstrlen(TC_ic)+1+tstrlen(TC_ip);
                if(TC_IC)                       /* If have multi-IC, use it */
                  {     tvc_ci += tstrlp(TC_IC, 1);
                        tvc_cin = 1;
                  }
                tvc_cd  = tstrlen(TC_dm)+tstrlen(TC_ed);
                tvc_cdn = tstrlen(TC_dc);
                if(TC_DC)                       /* If have multi-DC, use it */
                  {     tvc_cd += tstrlp(TC_DC, 1);
                        tvc_cdn = 0;
                  }
          }

        /* Find costs for doing I/D line operations */
        if ((TC_ia || TC_al) && (TC_id || TC_dl))
          {     trm_flags |= TF_IDLIN;
                tvc_li = 0;                     /* Usual case */
                tvc_lin = tstrlen(TC_al);
                if(TC_AL)                       /* If have multi-IL, use it */
                  {     tvc_li  = tstrlp(TC_AL, 1);
                        tvc_lin = tstrlp(TC_AL, 2) - tvc_lin;
                  }
                else if(TC_ia)
                  {     tvc_li  = tstrlen(TC_im)+tstrlen(TC_ei);
                        tvc_lin = tstrlen(TC_ia);
                  }

                tvc_ld = 0;                     /* Usual case */
                tvc_ldn = tstrlen(TC_dl);
                if(TC_DL)                       /* If have multi-DL, use it */
                  {     tvc_ld  = tstrlp(TC_DL, 1);
                        tvc_ldn = tstrlp(TC_DL, 2) - tvc_ld;
                  }
                else if(TC_id)
                  {     tvc_ld = tstrlen(TC_dm)+tstrlen(TC_ed);
                        tvc_ldn = tstrlen(TC_id);
                  }
          }

        if (tc_am)
          {     scr_wid--;              /* For now, avoid invoking wrap. */
#if 0
                trm_flags |= AUTOWRAP;  /* */
#endif
          }
        if (TC_ce) trm_flags |= TF_CLEOL;               /* Term has CLEOL? */
        if (tc_km) trm_flags |= TF_METAKEY;     /* Term has meta key? */

        return(1);
}

/* Pair of routines which conspire in order to find # chars actually output
 * by a particular termcap string.
 */
static int _tslen;              /* Stored count */
static void _tslinc(ch) { _tslen++; }
static int
tstrlen(str)
char *str;
{       _tslen = 0;
        if(str && str[0])
                tputs(str, 1, _tslinc); /* Mult padding by just 1 */
        return(_tslen);
}

static int
tstrlp(str, par)                /* Same but with parameter */
char *str;
int par;
{
#if 0
        if(str)
          {     char *cp = tgoto(str, 0, par);
                int i = strlen(cp);
                while(--i >= 0)
                        printf(" %o", *cp++);
                printf("\n");
          }
#endif
        return !str ? 0 : tstrlen(tgoto(str, 0, par));
}
#endif /*TX_TERMCAP*/
\f
/* Direct-Video terminal output routine
 *      Currently only COHERENT has this capability.
 */

#if COHERENT
#include <sgtty.h>

struct vidctl {
        int     v_position;             /* Position in video memory */
        int     v_count;                /* Number of characters to transfer */
        char    *v_buffer;              /* Character buffer to read/write */
};
/*
 * Attribute masks for TIOVPUTB - attributes occupy odd addresses
 * in video memory.
 */
#define VNORM   0x07                    /* Ordinary Video */
#define VINTE   0x08                    /* Intense video */
#define VBLIN   0x80                    /* Blinking video */
#define VREVE   0x70                    /* Reverse video */
#define VUNDE   0x01                    /* Underline video (mono board) */

/* T_DIRECT(line, col, string, len) - Do direct-video output of string.
 *      Puts the string ("len" chars in length) on the screen starting at
 *      the X,Y character position given by col, line.
 *      This routine is only called if terminal has the "TF_DIRVID" flag set.
 */
t_direct(lin, col, str, len)
int lin, col;
register char *str;
register int len;
{       register char *cp;
        char vbuf[MAXLINE*2];
        struct vidctl v;

        if(len <= 0) return;
        tbufls();               /* Ensure normal output is forced out */
        v.v_position = (lin*80 + col)*2;
        v.v_count = len*2;
        v.v_buffer = cp = vbuf;
        do {
                *cp++ = *str++;
                *cp++ = VNORM;
          } while(--len);
        ioctl(1, TIOVPUTB, &v);
}
#endif /*COHERENT*/
\f
/*
 * Terminal Output buffering routines
 */

static char tbuf[TOBFSIZ];      /* Output buffer */
static int tbufcnt = 0;         /* # chars of room left in buffer */
static char *tbufp = 0;         /* Pointer to deposit in buffer */

tput(ch)
int ch;
{       if(--tbufcnt < 0)
                tbufls();
        *tbufp++ = ch;
}

tputz(str)
char *str;
{       register int c;
        register char *cp, *tp;
        cp = str;
        tp = tbufp;
        while(c = *cp++)
          {     if(--tbufcnt < 0)
                  {     tbufp = tp;
                        tbufls();
                        tp = tbufp;
                  }
                *tp++ = c;
          }
        tbufp = tp;
}

tputn(str,cnt)
char *str;
int cnt;
{       register int c;
        register char *cp, *tp;
        cp = str;
        tp = tbufp;
        if((c = cnt) > 0)
        do {
                if(--tbufcnt < 0)
                  {
                        tbufp = tp;
                        tbufls();
                        tp = tbufp;
                  }
                *tp++ = *cp++;
          } while(--c);
        tbufp = tp;
}

tbufls()
{       register int cnt;

        if(tbufp
          && (cnt = tbufp - tbuf) > 0)          /* # chars written */
                write(1, tbuf, cnt);            /* Out they go */
        tbufp = tbuf;
        tbufcnt = TOBFSIZ-1;    /* Allow for usual expected decrement */
}
\f
/*
 * Terminal Input buffering routines
 */

int tibfmsk = -1;               /* Mask AND'ed with input chars (external) */
static char tibuf[TIBFSIZ];     /* TTY input buffer */
static char *tibfp;             /* Pointer to read from buffer */
static int tibfcnt = 0;         /* # chars left to be read from buffer */

tgetc()
{
#if SUN
        register int c;
        extern int sun_winfd, sun_rdevf;

        if(sun_winfd)
          {     if(!sun_rdevf)
                        return(sun_input(1)&tibfmsk);
                sun_rdevf = 0;          /* Check mouse too, but only once! */
                c = sun_input(0);
                if(c != -1) c &= tibfmsk;
                return(c);
          }
#endif /*SUN*/
        while(--tibfcnt < 0)
                tibfcnt = read(0,(tibfp = tibuf),TIBFSIZ);
        return((*tibfp++)&tibfmsk);
}

tinwait()
{       return(tibfcnt > 0 || ts_inp());
}