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     ! 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.