Return to ex_set.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / ex

Annotation of 43BSD/ucb/ex/ex_set.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1980 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char *sccsid = "@(#)ex_set.c    7.4 (Berkeley) 6/7/85";
        !             9: #endif not lint
        !            10: 
        !            11: #include "ex.h"
        !            12: #include "ex_temp.h"
        !            13: #include "ex_tty.h"
        !            14: 
        !            15: /*
        !            16:  * Set command.
        !            17:  */
        !            18: char   optname[ONMSZ];
        !            19: 
        !            20: set()
        !            21: {
        !            22:        register char *cp;
        !            23:        register struct option *op;
        !            24:        register int c;
        !            25:        bool no;
        !            26:        extern short ospeed;
        !            27: 
        !            28:        setnoaddr();
        !            29:        if (skipend()) {
        !            30:                if (peekchar() != EOF)
        !            31:                        ignchar();
        !            32:                propts();
        !            33:                return;
        !            34:        }
        !            35:        do {
        !            36:                cp = optname;
        !            37:                do {
        !            38:                        if (cp < &optname[ONMSZ - 2])
        !            39:                                *cp++ = getchar();
        !            40:                } while (isalnum(peekchar()));
        !            41:                *cp = 0;
        !            42:                cp = optname;
        !            43:                if (eq("all", cp)) {
        !            44:                        if (inopen)
        !            45:                                pofix();
        !            46:                        prall();
        !            47:                        goto next;
        !            48:                }
        !            49:                no = 0;
        !            50:                if (cp[0] == 'n' && cp[1] == 'o') {
        !            51:                        cp += 2;
        !            52:                        no++;
        !            53:                }
        !            54:                /* Implement w300, w1200, and w9600 specially */
        !            55:                if (eq(cp, "w300")) {
        !            56:                        if (ospeed >= B1200) {
        !            57: dontset:
        !            58:                                ignore(getchar());      /* = */
        !            59:                                ignore(getnum());       /* value */
        !            60:                                continue;
        !            61:                        }
        !            62:                        cp = "window";
        !            63:                } else if (eq(cp, "w1200")) {
        !            64:                        if (ospeed < B1200 || ospeed >= B2400)
        !            65:                                goto dontset;
        !            66:                        cp = "window";
        !            67:                } else if (eq(cp, "w9600")) {
        !            68:                        if (ospeed < B2400)
        !            69:                                goto dontset;
        !            70:                        cp = "window";
        !            71:                }
        !            72:                for (op = options; op < &options[NOPTS]; op++)
        !            73:                        if (eq(op->oname, cp) || op->oabbrev && eq(op->oabbrev, cp))
        !            74:                                break;
        !            75:                if (op->oname == 0)
        !            76:                        serror("%s: No such option@- 'set all' gives all option values", cp);
        !            77:                c = skipwh();
        !            78:                if (peekchar() == '?') {
        !            79:                        ignchar();
        !            80: printone:
        !            81:                        propt(op);
        !            82:                        noonl();
        !            83:                        goto next;
        !            84:                }
        !            85:                if (op->otype == ONOFF) {
        !            86:                        op->ovalue = 1 - no;
        !            87:                        if (op == &options[PROMPT])
        !            88:                                oprompt = 1 - no;
        !            89:                        goto next;
        !            90:                }
        !            91:                if (no)
        !            92:                        serror("Option %s is not a toggle", op->oname);
        !            93:                if (c != 0 || setend())
        !            94:                        goto printone;
        !            95:                if (getchar() != '=')
        !            96:                        serror("Missing =@in assignment to option %s", op->oname);
        !            97:                switch (op->otype) {
        !            98: 
        !            99:                case NUMERIC:
        !           100:                        if (!isdigit(peekchar()))
        !           101:                                error("Digits required@after =");
        !           102:                        op->ovalue = getnum();
        !           103:                        if (value(TABSTOP) <= 0)
        !           104:                                value(TABSTOP) = TABS;
        !           105:                        if (value(HARDTABS) <= 0)
        !           106:                                value(HARDTABS) = TABS;
        !           107:                        if (op == &options[WINDOW]) {
        !           108:                                if (value(WINDOW) >= LINES)
        !           109:                                        value(WINDOW) = LINES-1;
        !           110:                                vsetsiz(value(WINDOW));
        !           111:                        }
        !           112:                        break;
        !           113: 
        !           114:                case STRING:
        !           115:                case OTERM:
        !           116:                        cp = optname;
        !           117:                        while (!setend()) {
        !           118:                                if (cp >= &optname[ONMSZ])
        !           119:                                        error("String too long@in option assignment");
        !           120:                                /* adb change:  allow whitepace in strings */
        !           121:                                if( (*cp = getchar()) == '\\')
        !           122:                                        if( peekchar() != EOF)
        !           123:                                                *cp = getchar();
        !           124:                                cp++;
        !           125:                        }
        !           126:                        *cp = 0;
        !           127:                        if (op->otype == OTERM) {
        !           128: /*
        !           129:  * At first glance it seems like we shouldn't care if the terminal type
        !           130:  * is changed inside visual mode, as long as we assume the screen is
        !           131:  * a mess and redraw it. However, it's a much harder problem than that.
        !           132:  * If you happen to change from 1 crt to another that both have the same
        !           133:  * size screen, it's OK. But if the screen size if different, the stuff
        !           134:  * that gets initialized in vop() will be wrong. This could be overcome
        !           135:  * by redoing the initialization, e.g. making the first 90% of vop into
        !           136:  * a subroutine. However, the most useful case is where you forgot to do
        !           137:  * a setenv before you went into the editor and it thinks you're on a dumb
        !           138:  * terminal. Ex treats this like hardcopy and goes into HARDOPEN mode.
        !           139:  * This loses because the first part of vop calls oop in this case.
        !           140:  * The problem is so hard I gave up. I'm not saying it can't be done,
        !           141:  * but I am saying it probably isn't worth the effort.
        !           142:  */
        !           143:                                if (inopen)
        !           144: error("Can't change type of terminal from within open/visual");
        !           145:                                setterm(optname);
        !           146:                        } else {
        !           147:                                CP(op->osvalue, optname);
        !           148:                                op->odefault = 1;
        !           149:                        }
        !           150:                        break;
        !           151:                }
        !           152: next:
        !           153:                flush();
        !           154:        } while (!skipend());
        !           155:        eol();
        !           156: }
        !           157: 
        !           158: setend()
        !           159: {
        !           160: 
        !           161:        return (iswhite(peekchar()) || endcmd(peekchar()));
        !           162: }
        !           163: 
        !           164: prall()
        !           165: {
        !           166:        register int incr = (NOPTS + 2) / 3;
        !           167:        register int rows = incr;
        !           168:        register struct option *op = options;
        !           169: 
        !           170:        for (; rows; rows--, op++) {
        !           171:                propt(op);
        !           172:                tab(24);
        !           173:                propt(&op[incr]);
        !           174:                if (&op[2*incr] < &options[NOPTS]) {
        !           175:                        tab(56);
        !           176:                        propt(&op[2 * incr]);
        !           177:                }
        !           178:                putNFL();
        !           179:        }
        !           180: }
        !           181: 
        !           182: propts()
        !           183: {
        !           184:        register struct option *op;
        !           185: 
        !           186:        for (op = options; op < &options[NOPTS]; op++) {
        !           187: #ifdef V6
        !           188:                if (op == &options[TERM])
        !           189: #else
        !           190:                if (op == &options[TTYTYPE])
        !           191: #endif
        !           192:                        continue;
        !           193:                switch (op->otype) {
        !           194: 
        !           195:                case ONOFF:
        !           196:                case NUMERIC:
        !           197:                        if (op->ovalue == op->odefault)
        !           198:                                continue;
        !           199:                        break;
        !           200: 
        !           201:                case STRING:
        !           202:                        if (op->odefault == 0)
        !           203:                                continue;
        !           204:                        break;
        !           205:                }
        !           206:                propt(op);
        !           207:                putchar(' ');
        !           208:        }
        !           209:        noonl();
        !           210:        flush();
        !           211: }
        !           212: 
        !           213: propt(op)
        !           214:        register struct option *op;
        !           215: {
        !           216:        register char *name;
        !           217:        
        !           218:        name = op->oname;
        !           219: 
        !           220:        switch (op->otype) {
        !           221: 
        !           222:        case ONOFF:
        !           223:                printf("%s%s", op->ovalue ? "" : "no", name);
        !           224:                break;
        !           225: 
        !           226:        case NUMERIC:
        !           227:                printf("%s=%d", name, op->ovalue);
        !           228:                break;
        !           229: 
        !           230:        case STRING:
        !           231:        case OTERM:
        !           232:                printf("%s=%s", name, op->osvalue);
        !           233:                break;
        !           234:        }
        !           235: }

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