Return to ex_tty.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / ex

Annotation of 3BSD/cmd/ex/ex_tty.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) 1979 Regents of the University of California */
                      2: #include "ex.h"
                      3: #include "ex_tty.h"
                      4: 
                      5: /*
                      6:  * Terminal type initialization routines,
                      7:  * and calculation of flags at entry or after
                      8:  * a shell escape which may change them.
                      9:  */
                     10: short  ospeed = -1;
                     11: 
                     12: gettmode()
                     13: {
                     14: 
                     15:        if (gtty(1, &tty) < 0)
                     16:                return;
                     17:        if (ospeed != tty.sg_ospeed)
                     18:                value(SLOWOPEN) = tty.sg_ospeed < B1200;
                     19:        ospeed = tty.sg_ospeed;
                     20:        normf = tty.sg_flags;
                     21:        UPPERCASE = (tty.sg_flags & LCASE) != 0;
                     22:        GT = (tty.sg_flags & XTABS) != XTABS && !XT;
                     23:        NONL = (tty.sg_flags & CRMOD) == 0;
                     24: }
                     25: 
                     26: char *xPC;
                     27: char **sstrs[] = {
                     28:        &AL, &BC, &BT, &CD, &CE, &CL, &CM, &DC, &DL, &DM, &DO, &ED, &EI,
                     29:        &F0, &F1, &F2, &F3, &F4, &F5, &F6, &F7, &F8, &F9,
                     30:        &HO, &IC, &IM, &IP, &KD, &KE, &KH, &KL, &KR, &KS, &KU, &LL,
                     31:        &ND, &xPC, &SE, &SF, &SO, &SR, &TA, &TE, &TI, &UP, &VB, &VS, &VE
                     32: };
                     33: bool *sflags[] = {
                     34:        &AM, &BS, &DA, &DB, &EO, &HC, &HZ, &IN, &MI, &NC, &OS, &UL, &XN, &XT
                     35: };
                     36: char **fkeys[10] = {
                     37:        &F0, &F1, &F2, &F3, &F4, &F5, &F6, &F7, &F8, &F9
                     38: };
                     39: setterm(type)
                     40:        char *type;
                     41: {
                     42:        char *cgoto();
                     43:        register int unknown, i;
                     44:        register int l;
                     45:        char ltcbuf[TCBUFSIZE];
                     46: 
                     47:        if (type[0] == 0)
                     48:                type = "xx";
                     49:        unknown = 0;
                     50:        putpad(TE);
                     51:        if (tgetent(ltcbuf, type) != 1) {
                     52:                unknown++;
                     53:                CP(genbuf, "xx|dumb:");
                     54:        }
                     55:        i = LINES = tgetnum("li");
                     56:        if (LINES <= 5)
                     57:                LINES = 24;
                     58:        if (LINES > 48)
                     59:                LINES = 48;
                     60:        l = LINES;
                     61:        if (ospeed < B1200)
                     62:                l /= 2;
                     63:        else if (ospeed < B2400)
                     64:                l = (l * 2) / 3;
                     65:        aoftspace = tspace;
                     66:        zap();
                     67:        /*
                     68:         * Initialize keypad arrow keys.
                     69:         */
                     70:        arrows[0].cap = KU; arrows[0].mapto = "k"; arrows[0].descr = "up";
                     71:        arrows[1].cap = KD; arrows[1].mapto = "j"; arrows[1].descr = "down";
                     72:        arrows[2].cap = KL; arrows[2].mapto = "h"; arrows[2].descr = "left";
                     73:        arrows[3].cap = KR; arrows[3].mapto = "l"; arrows[3].descr = "right";
                     74:        arrows[4].cap = KH; arrows[4].mapto = "H"; arrows[4].descr = "home";
                     75: 
                     76:        options[WINDOW].ovalue = options[WINDOW].odefault = l - 1;
                     77:        if (defwind) options[WINDOW].ovalue = defwind;
                     78:        options[SCROLL].ovalue = options[SCROLL].odefault = HC ? 11 : ((l-1) / 2);
                     79:        COLUMNS = tgetnum("co");
                     80:        if (COLUMNS <= 20)
                     81:                COLUMNS = 1000;
                     82:        if (cgoto()[0] == 'O')  /* OOPS */
                     83:                CA = 0, CM = 0;
                     84:        else
                     85:                CA = 1, costCM = strlen(tgoto(CM, 8, 10));
                     86:        PC = xPC ? xPC[0] : 0;
                     87:        aoftspace = tspace;
                     88:        CP(ttytype, longname(genbuf, type));
                     89:        if (i <= 0)
                     90:                LINES = 2;
                     91:        /* proper strings to change tty type */
                     92: #ifdef notdef
                     93:        /* Taken out because we don't allow it. See ex_set.c for reasons. */
                     94:        if (inopen)
                     95:                putpad(VE);
                     96: #endif
                     97:        termreset();
                     98:        gettmode();
                     99:        value(REDRAW) = AL && DL;
                    100:        value(OPTIMIZE) = !CA && !GT;
                    101:        if (unknown)
                    102:                serror("%s: Unknown terminal type", type);
                    103: }
                    104: 
                    105: zap()
                    106: {
                    107:        register char *namp;
                    108:        register bool **fp;
                    109:        register char ***sp;
                    110: 
                    111:        namp = "ambsdadbeohchzinmincosulxnxt";
                    112:        fp = sflags;
                    113:        do {
                    114:                *(*fp++) = tgetflag(namp);
                    115:                namp += 2;
                    116:        } while (*namp);
                    117:        namp = "albcbtcdceclcmdcdldmdoedeik0k1k2k3k4k5k6k7k8k9hoicimipkdkekhklkrkskullndpcsesfsosrtatetiupvbvsve";
                    118:        sp = sstrs;
                    119:        do {
                    120:                *(*sp++) = tgetstr(namp, &aoftspace);
                    121:                namp += 2;
                    122:        } while (*namp);
                    123: }
                    124: 
                    125: char *
                    126: longname(bp, def)
                    127:        register char *bp;
                    128:        char *def;
                    129: {
                    130:        register char *cp;
                    131: 
                    132:        while (*bp && *bp != ':' && *bp != '|')
                    133:                bp++;
                    134:        if (*bp == '|') {
                    135:                bp++;
                    136:                cp = bp;
                    137:                while (*cp && *cp != ':' && *cp != '|')
                    138:                        cp++;
                    139:                *cp = 0;
                    140:                return (bp);
                    141:        }
                    142:        return (def);
                    143: }
                    144: 
                    145: char *
                    146: fkey(i)
                    147:        int i;
                    148: {
                    149:        if (0 <= i && i <= 9)
                    150:                return(*fkeys[i]);
                    151:        else
                    152:                return(NOSTR);
                    153: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.