Return to ex_put.c CVS log

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

Annotation of 42BSD/ucb/ex/ex_put.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1981 Regents of the University of California */
        !             2: static char *sccsid = "@(#)ex_put.c    7.7     10/16/81";
        !             3: #include "ex.h"
        !             4: #include "ex_tty.h"
        !             5: #include "ex_vis.h"
        !             6: 
        !             7: /*
        !             8:  * Terminal driving and line formatting routines.
        !             9:  * Basic motion optimizations are done here as well
        !            10:  * as formatting of lines (printing of control characters,
        !            11:  * line numbering and the like).
        !            12:  */
        !            13: 
        !            14: /*
        !            15:  * The routines outchar, putchar and pline are actually
        !            16:  * variables, and these variables point at the current definitions
        !            17:  * of the routines.  See the routine setflav.
        !            18:  * We sometimes make outchar be routines which catch the characters
        !            19:  * to be printed, e.g. if we want to see how long a line is.
        !            20:  * During open/visual, outchar and putchar will be set to
        !            21:  * routines in the file ex_vput.c (vputchar, vinschar, etc.).
        !            22:  */
        !            23: int    (*Outchar)() = termchar;
        !            24: int    (*Putchar)() = normchar;
        !            25: int    (*Pline)() = normline;
        !            26: 
        !            27: int (*
        !            28: setlist(t))()
        !            29:        bool t;
        !            30: {
        !            31:        register int (*P)();
        !            32: 
        !            33:        listf = t;
        !            34:        P = Putchar;
        !            35:        Putchar = t ? listchar : normchar;
        !            36:        return (P);
        !            37: }
        !            38: 
        !            39: int (*
        !            40: setnumb(t))()
        !            41:        bool t;
        !            42: {
        !            43:        register int (*P)();
        !            44: 
        !            45:        numberf = t;
        !            46:        P = Pline;
        !            47:        Pline = t ? numbline : normline;
        !            48:        return (P);
        !            49: }
        !            50: 
        !            51: /*
        !            52:  * Format c for list mode; leave things in common
        !            53:  * with normal print mode to be done by normchar.
        !            54:  */
        !            55: listchar(c)
        !            56:        register short c;
        !            57: {
        !            58: 
        !            59:        c &= (TRIM|QUOTE);
        !            60:        switch (c) {
        !            61: 
        !            62:        case '\t':
        !            63:        case '\b':
        !            64:                outchar('^');
        !            65:                c = ctlof(c);
        !            66:                break;
        !            67: 
        !            68:        case '\n':
        !            69:                break;
        !            70: 
        !            71:        case '\n' | QUOTE:
        !            72:                outchar('$');
        !            73:                break;
        !            74: 
        !            75:        default:
        !            76:                if (c & QUOTE)
        !            77:                        break;
        !            78:                if (c < ' ' && c != '\n' || c == DELETE)
        !            79:                        outchar('^'), c = ctlof(c);
        !            80:                break;
        !            81:        }
        !            82:        normchar(c);
        !            83: }
        !            84: 
        !            85: /*
        !            86:  * Format c for printing.  Handle funnies of upper case terminals
        !            87:  * and crocky hazeltines which don't have ~.
        !            88:  */
        !            89: normchar(c)
        !            90:        register short c;
        !            91: {
        !            92:        register char *colp;
        !            93: 
        !            94:        c &= (TRIM|QUOTE);
        !            95:        if (c == '~' && HZ) {
        !            96:                normchar('\\');
        !            97:                c = '^';
        !            98:        }
        !            99:        if (c & QUOTE)
        !           100:                switch (c) {
        !           101: 
        !           102:                case ' ' | QUOTE:
        !           103:                case '\b' | QUOTE:
        !           104:                        break;
        !           105: 
        !           106:                case QUOTE:
        !           107:                        return;
        !           108: 
        !           109:                default:
        !           110:                        c &= TRIM;
        !           111:                }
        !           112:        else if (c < ' ' && (c != '\b' || !OS) && c != '\n' && c != '\t' || c == DELETE)
        !           113:                putchar('^'), c = ctlof(c);
        !           114:        else if (UPPERCASE)
        !           115:                if (isupper(c)) {
        !           116:                        outchar('\\');
        !           117:                        c = tolower(c);
        !           118:                } else {
        !           119:                        colp = "({)}!|^~'`";
        !           120:                        while (*colp++)
        !           121:                                if (c == *colp++) {
        !           122:                                        outchar('\\');
        !           123:                                        c = colp[-2];
        !           124:                                        break;
        !           125:                                }
        !           126:                }
        !           127:        outchar(c);
        !           128: }
        !           129: 
        !           130: /*
        !           131:  * Print a line with a number.
        !           132:  */
        !           133: numbline(i)
        !           134:        int i;
        !           135: {
        !           136: 
        !           137:        if (shudclob)
        !           138:                slobber(' ');
        !           139:        printf("%6d  ", i);
        !           140:        normline();
        !           141: }
        !           142: 
        !           143: /*
        !           144:  * Normal line output, no numbering.
        !           145:  */
        !           146: normline()
        !           147: {
        !           148:        register char *cp;
        !           149: 
        !           150:        if (shudclob)
        !           151:                slobber(linebuf[0]);
        !           152:        /* pdp-11 doprnt is not reentrant so can't use "printf" here
        !           153:           in case we are tracing */
        !           154:        for (cp = linebuf; *cp;)
        !           155:                putchar(*cp++);
        !           156:        if (!inopen)
        !           157:                putchar('\n' | QUOTE);
        !           158: }
        !           159: 
        !           160: /*
        !           161:  * Given c at the beginning of a line, determine whether
        !           162:  * the printing of the line will erase or otherwise obliterate
        !           163:  * the prompt which was printed before.  If it won't, do it now.
        !           164:  */
        !           165: slobber(c)
        !           166:        int c;
        !           167: {
        !           168: 
        !           169:        shudclob = 0;
        !           170:        switch (c) {
        !           171: 
        !           172:        case '\t':
        !           173:                if (Putchar == listchar)
        !           174:                        return;
        !           175:                break;
        !           176: 
        !           177:        default:
        !           178:                return;
        !           179: 
        !           180:        case ' ':
        !           181:        case 0:
        !           182:                break;
        !           183:        }
        !           184:        if (OS)
        !           185:                return;
        !           186:        flush();
        !           187:        putch(' ');
        !           188:        if (BC)
        !           189:                tputs(BC, 0, putch);
        !           190:        else
        !           191:                putch('\b');
        !           192: }
        !           193: 
        !           194: /*
        !           195:  * The output buffer is initialized with a useful error
        !           196:  * message so we don't have to keep it in data space.
        !           197:  */
        !           198: static char linb[66];
        !           199: char *linp = linb;
        !           200: 
        !           201: /*
        !           202:  * Phadnl records when we have already had a complete line ending with \n.
        !           203:  * If another line starts without a flush, and the terminal suggests it,
        !           204:  * we switch into -nl mode so that we can send lineffeeds to avoid
        !           205:  * a lot of spacing.
        !           206:  */
        !           207: static bool phadnl;
        !           208: 
        !           209: /*
        !           210:  * Indirect to current definition of putchar.
        !           211:  */
        !           212: putchar(c)
        !           213:        int c;
        !           214: {
        !           215: 
        !           216:        (*Putchar)(c);
        !           217: }
        !           218: 
        !           219: /*
        !           220:  * Termchar routine for command mode.
        !           221:  * Watch for possible switching to -nl mode.
        !           222:  * Otherwise flush into next level of buffering when
        !           223:  * small buffer fills or at a newline.
        !           224:  */
        !           225: termchar(c)
        !           226:        int c;
        !           227: {
        !           228: 
        !           229:        if (pfast == 0 && phadnl)
        !           230:                pstart();
        !           231:        if (c == '\n')
        !           232:                phadnl = 1;
        !           233:        else if (linp >= &linb[63])
        !           234:                flush1();
        !           235:        *linp++ = c;
        !           236:        if (linp >= &linb[63]) {
        !           237:                fgoto();
        !           238:                flush1();
        !           239:        }
        !           240: }
        !           241: 
        !           242: flush()
        !           243: {
        !           244: 
        !           245:        flush1();
        !           246:        flush2();
        !           247: }
        !           248: 
        !           249: /*
        !           250:  * Flush from small line buffer into output buffer.
        !           251:  * Work here is destroying motion into positions, and then
        !           252:  * letting fgoto do the optimized motion.
        !           253:  */
        !           254: flush1()
        !           255: {
        !           256:        register char *lp;
        !           257:        register short c;
        !           258: 
        !           259:        *linp = 0;
        !           260:        lp = linb;
        !           261:        while (*lp)
        !           262:                switch (c = *lp++) {
        !           263: 
        !           264:                case '\r':
        !           265:                        destline += destcol / COLUMNS;
        !           266:                        destcol = 0;
        !           267:                        continue;
        !           268: 
        !           269:                case '\b':
        !           270:                        if (destcol)
        !           271:                                destcol--;
        !           272:                        continue;
        !           273: 
        !           274:                case ' ':
        !           275:                        destcol++;
        !           276:                        continue;
        !           277: 
        !           278:                case '\t':
        !           279:                        destcol += value(TABSTOP) - destcol % value(TABSTOP);
        !           280:                        continue;
        !           281: 
        !           282:                case '\n':
        !           283:                        destline += destcol / COLUMNS + 1;
        !           284:                        if (destcol != 0 && destcol % COLUMNS == 0)
        !           285:                                destline--;
        !           286:                        destcol = 0;
        !           287:                        continue;
        !           288: 
        !           289:                default:
        !           290:                        fgoto();
        !           291:                        for (;;) {
        !           292:                                if (AM == 0 && outcol == COLUMNS)
        !           293:                                        fgoto();
        !           294:                                c &= TRIM;
        !           295:                                putch(c);
        !           296:                                if (c == '\b') {
        !           297:                                        outcol--;
        !           298:                                        destcol--;
        !           299:                                } else if (c >= ' ' && c != DELETE) {
        !           300:                                        outcol++;
        !           301:                                        destcol++;
        !           302:                                        if (XN && outcol % COLUMNS == 0)
        !           303:                                                putch('\r'), putch('\n');
        !           304:                                }
        !           305:                                c = *lp++;
        !           306:                                if (c <= ' ')
        !           307:                                        break;
        !           308:                        }
        !           309:                        --lp;
        !           310:                        continue;
        !           311:                }
        !           312:        linp = linb;
        !           313: }
        !           314: 
        !           315: flush2()
        !           316: {
        !           317: 
        !           318:        fgoto();
        !           319:        flusho();
        !           320:        pstop();
        !           321: }
        !           322: 
        !           323: /*
        !           324:  * Sync the position of the output cursor.
        !           325:  * Most work here is rounding for terminal boundaries getting the
        !           326:  * column position implied by wraparound or the lack thereof and
        !           327:  * rolling up the screen to get destline on the screen.
        !           328:  */
        !           329: fgoto()
        !           330: {
        !           331:        register int l, c;
        !           332: 
        !           333:        if (destcol > COLUMNS - 1) {
        !           334:                destline += destcol / COLUMNS;
        !           335:                destcol %= COLUMNS;
        !           336:        }
        !           337:        if (outcol > COLUMNS - 1) {
        !           338:                l = (outcol + 1) / COLUMNS;
        !           339:                outline += l;
        !           340:                outcol %= COLUMNS;
        !           341:                if (AM == 0) {
        !           342:                        while (l > 0) {
        !           343:                                if (pfast)
        !           344:                                        if (xCR)
        !           345:                                                tputs(xCR, 0, putch);
        !           346:                                        else
        !           347:                                                putch('\r');
        !           348:                                if (xNL)
        !           349:                                        tputs(xNL, 0, putch);
        !           350:                                else
        !           351:                                        putch('\n');
        !           352:                                l--;
        !           353:                        }
        !           354:                        outcol = 0;
        !           355:                }
        !           356:                if (outline > LINES - 1) {
        !           357:                        destline -= outline - (LINES - 1);
        !           358:                        outline = LINES - 1;
        !           359:                }
        !           360:        }
        !           361:        if (destline > LINES - 1) {
        !           362:                l = destline;
        !           363:                destline = LINES - 1;
        !           364:                if (outline < LINES - 1) {
        !           365:                        c = destcol;
        !           366:                        if (pfast == 0 && (!CA || holdcm))
        !           367:                                destcol = 0;
        !           368:                        fgoto();
        !           369:                        destcol = c;
        !           370:                }
        !           371:                while (l > LINES - 1) {
        !           372:                        /*
        !           373:                         * The following linefeed (or simulation thereof)
        !           374:                         * is supposed to scroll up the screen, since we
        !           375:                         * are on the bottom line.  We make the assumption
        !           376:                         * that linefeed will scroll.  If ns is in the
        !           377:                         * capability list this won't work.  We should
        !           378:                         * probably have an sc capability but sf will
        !           379:                         * generally take the place if it works.
        !           380:                         *
        !           381:                         * Superbee glitch:  in the middle of the screen we
        !           382:                         * have to use esc B (down) because linefeed screws up
        !           383:                         * in "Efficient Paging" (what a joke) mode (which is
        !           384:                         * essential in some SB's because CRLF mode puts garbage
        !           385:                         * in at end of memory), but you must use linefeed to
        !           386:                         * scroll since down arrow won't go past memory end.
        !           387:                         * I turned this off after recieving Paul Eggert's
        !           388:                         * Superbee description which wins better.
        !           389:                         */
        !           390:                        if (xNL /* && !XB */ && pfast)
        !           391:                                tputs(xNL, 0, putch);
        !           392:                        else
        !           393:                                putch('\n');
        !           394:                        l--;
        !           395:                        if (pfast == 0)
        !           396:                                outcol = 0;
        !           397:                }
        !           398:        }
        !           399:        if (destline < outline && !(CA && !holdcm || UP != NOSTR))
        !           400:                destline = outline;
        !           401:        if (CA && !holdcm)
        !           402:                if (plod(costCM) > 0)
        !           403:                        plod(0);
        !           404:                else
        !           405:                        tputs(tgoto(CM, destcol, destline), 0, putch);
        !           406:        else
        !           407:                plod(0);
        !           408:        outline = destline;
        !           409:        outcol = destcol;
        !           410: }
        !           411: 
        !           412: /*
        !           413:  * Tab to column col by flushing and then setting destcol.
        !           414:  * Used by "set all".
        !           415:  */
        !           416: tab(col)
        !           417:        int col;
        !           418: {
        !           419: 
        !           420:        flush1();
        !           421:        destcol = col;
        !           422: }
        !           423: 
        !           424: /*
        !           425:  * Move (slowly) to destination.
        !           426:  * Hard thing here is using home cursor on really deficient terminals.
        !           427:  * Otherwise just use cursor motions, hacking use of tabs and overtabbing
        !           428:  * and backspace.
        !           429:  */
        !           430: 
        !           431: static int plodcnt, plodflg;
        !           432: 
        !           433: plodput(c)
        !           434: {
        !           435: 
        !           436:        if (plodflg)
        !           437:                plodcnt--;
        !           438:        else
        !           439:                putch(c);
        !           440: }
        !           441: 
        !           442: plod(cnt)
        !           443: {
        !           444:        register int i, j, k;
        !           445:        register int soutcol, soutline;
        !           446: 
        !           447:        plodcnt = plodflg = cnt;
        !           448:        soutcol = outcol;
        !           449:        soutline = outline;
        !           450:        /*
        !           451:         * Consider homing and moving down/right from there, vs moving
        !           452:         * directly with local motions to the right spot.
        !           453:         */
        !           454:        if (HO) {
        !           455:                /*
        !           456:                 * i is the cost to home and tab/space to the right to
        !           457:                 * get to the proper column.  This assumes ND space costs
        !           458:                 * 1 char.  So i+destcol is cost of motion with home.
        !           459:                 */
        !           460:                if (GT)
        !           461:                        i = (destcol / value(HARDTABS)) + (destcol % value(HARDTABS));
        !           462:                else
        !           463:                        i = destcol;
        !           464:                /*
        !           465:                 * j is cost to move locally without homing
        !           466:                 */
        !           467:                if (destcol >= outcol) {        /* if motion is to the right */
        !           468:                        j = destcol / value(HARDTABS) - outcol / value(HARDTABS);
        !           469:                        if (GT && j)
        !           470:                                j += destcol % value(HARDTABS);
        !           471:                        else
        !           472:                                j = destcol - outcol;
        !           473:                } else
        !           474:                        /* leftward motion only works if we can backspace. */
        !           475:                        if (outcol - destcol <= i && (BS || BC))
        !           476:                                i = j = outcol - destcol; /* cheaper to backspace */
        !           477:                        else
        !           478:                                j = i + 1; /* impossibly expensive */
        !           479: 
        !           480:                /* k is the absolute value of vertical distance */
        !           481:                k = outline - destline;
        !           482:                if (k < 0)
        !           483:                        k = -k;
        !           484:                j += k;
        !           485: 
        !           486:                /*
        !           487:                 * Decision.  We may not have a choice if no UP.
        !           488:                 */
        !           489:                if (i + destline < j || (!UP && destline < outline)) {
        !           490:                        /*
        !           491:                         * Cheaper to home.  Do it now and pretend it's a
        !           492:                         * regular local motion.
        !           493:                         */
        !           494:                        tputs(HO, 0, plodput);
        !           495:                        outcol = outline = 0;
        !           496:                } else if (LL) {
        !           497:                        /*
        !           498:                         * Quickly consider homing down and moving from there.
        !           499:                         * Assume cost of LL is 2.
        !           500:                         */
        !           501:                        k = (LINES - 1) - destline;
        !           502:                        if (i + k + 2 < j && (k<=0 || UP)) {
        !           503:                                tputs(LL, 0, plodput);
        !           504:                                outcol = 0;
        !           505:                                outline = LINES - 1;
        !           506:                        }
        !           507:                }
        !           508:        } else
        !           509:        /*
        !           510:         * No home and no up means it's impossible, so we return an
        !           511:         * incredibly big number to make cursor motion win out.
        !           512:         */
        !           513:                if (!UP && destline < outline)
        !           514:                        return (500);
        !           515:        if (GT)
        !           516:                i = destcol % value(HARDTABS)
        !           517:                    + destcol / value(HARDTABS);
        !           518:        else
        !           519:                i = destcol;
        !           520: /*
        !           521:        if (BT && outcol > destcol && (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) {
        !           522:                j *= (k = strlen(BT));
        !           523:                if ((k += (destcol&7)) > 4)
        !           524:                        j += 8 - (destcol&7);
        !           525:                else
        !           526:                        j += k;
        !           527:        } else
        !           528: */
        !           529:                j = outcol - destcol;
        !           530:        /*
        !           531:         * If we will later need a \n which will turn into a \r\n by
        !           532:         * the system or the terminal, then don't bother to try to \r.
        !           533:         */
        !           534:        if ((NONL || !pfast) && outline < destline)
        !           535:                goto dontcr;
        !           536:        /*
        !           537:         * If the terminal will do a \r\n and there isn't room for it,
        !           538:         * then we can't afford a \r.
        !           539:         */
        !           540:        if (NC && outline >= destline)
        !           541:                goto dontcr;
        !           542:        /*
        !           543:         * If it will be cheaper, or if we can't back up, then send
        !           544:         * a return preliminarily.
        !           545:         */
        !           546:        if (j > i + 1 || outcol > destcol && !BS && !BC) {
        !           547:                /*
        !           548:                 * BUG: this doesn't take the (possibly long) length
        !           549:                 * of xCR into account.
        !           550:                 */
        !           551:                if (xCR)
        !           552:                        tputs(xCR, 0, plodput);
        !           553:                else
        !           554:                        plodput('\r');
        !           555:                if (NC) {
        !           556:                        if (xNL)
        !           557:                                tputs(xNL, 0, plodput);
        !           558:                        else
        !           559:                                plodput('\n');
        !           560:                        outline++;
        !           561:                }
        !           562:                outcol = 0;
        !           563:        }
        !           564: dontcr:
        !           565:        /* Move down, if necessary, until we are at the desired line */
        !           566:        while (outline < destline) {
        !           567:                j = destline - outline;
        !           568:                if (j > costDP && DOWN_PARM) {
        !           569:                        /* Win big on Tek 4025 */
        !           570:                        tputs(tgoto(DOWN_PARM, 0, j), j, plodput);
        !           571:                        outline += j;
        !           572:                }
        !           573:                else {
        !           574:                        outline++;
        !           575:                        if (xNL && pfast)
        !           576:                                tputs(xNL, 0, plodput);
        !           577:                        else
        !           578:                                plodput('\n');
        !           579:                }
        !           580:                if (plodcnt < 0)
        !           581:                        goto out;
        !           582:                if (NONL || pfast == 0)
        !           583:                        outcol = 0;
        !           584:        }
        !           585:        if (BT)
        !           586:                k = strlen(BT); /* should probably be cost(BT) and moved out */
        !           587:        /* Move left, if necessary, to desired column */
        !           588:        while (outcol > destcol) {
        !           589:                if (plodcnt < 0)
        !           590:                        goto out;
        !           591:                if (BT && !insmode && outcol - destcol > 4+k) {
        !           592:                        tputs(BT, 0, plodput);
        !           593:                        outcol--;
        !           594:                        outcol -= outcol % value(HARDTABS); /* outcol &= ~7; */
        !           595:                        continue;
        !           596:                }
        !           597:                j = outcol - destcol;
        !           598:                if (j > costLP && LEFT_PARM) {
        !           599:                        tputs(tgoto(LEFT_PARM, 0, j), j, plodput);
        !           600:                        outcol -= j;
        !           601:                }
        !           602:                else {
        !           603:                        outcol--;
        !           604:                        if (BC)
        !           605:                                tputs(BC, 0, plodput);
        !           606:                        else
        !           607:                                plodput('\b');
        !           608:                }
        !           609:        }
        !           610:        /* Move up, if necessary, to desired row */
        !           611:        while (outline > destline) {
        !           612:                j = outline - destline;
        !           613:                if (UP_PARM && j > 1) {
        !           614:                        /* Win big on Tek 4025 */
        !           615:                        tputs(tgoto(UP_PARM, 0, j), j, plodput);
        !           616:                        outline -= j;
        !           617:                }
        !           618:                else {
        !           619:                        outline--;
        !           620:                        tputs(UP, 0, plodput);
        !           621:                }
        !           622:                if (plodcnt < 0)
        !           623:                        goto out;
        !           624:        }
        !           625:        /*
        !           626:         * Now move to the right, if necessary.  We first tab to
        !           627:         * as close as we can get.
        !           628:         */
        !           629:        if (GT && !insmode && destcol - outcol > 1) {
        !           630:                /* tab to right as far as possible without passing col */
        !           631:                for (;;) {
        !           632:                        i = tabcol(outcol, value(HARDTABS));
        !           633:                        if (i > destcol)
        !           634:                                break;
        !           635:                        if (TA)
        !           636:                                tputs(TA, 0, plodput);
        !           637:                        else
        !           638:                                plodput('\t');
        !           639:                        outcol = i;
        !           640:                }
        !           641:                /* consider another tab and then some backspaces */
        !           642:                if (destcol - outcol > 4 && i < COLUMNS && (BC || BS)) {
        !           643:                        if (TA)
        !           644:                                tputs(TA, 0, plodput);
        !           645:                        else
        !           646:                                plodput('\t');
        !           647:                        outcol = i;
        !           648:                        /*
        !           649:                         * Back up.  Don't worry about LEFT_PARM because
        !           650:                         * it's never more than 4 spaces anyway.
        !           651:                         */
        !           652:                        while (outcol > destcol) {
        !           653:                                outcol--;
        !           654:                                if (BC)
        !           655:                                        tputs(BC, 0, plodput);
        !           656:                                else
        !           657:                                        plodput('\b');
        !           658:                        }
        !           659:                }
        !           660:        }
        !           661:        /*
        !           662:         * We've tabbed as much as possible.  If we still need to go
        !           663:         * further (not exact or can't tab) space over.  This is a
        !           664:         * very common case when moving to the right with space.
        !           665:         */
        !           666:        while (outcol < destcol) {
        !           667:                j = destcol - outcol;
        !           668:                if (j > costRP && RIGHT_PARM) {
        !           669:                        /*
        !           670:                         * This probably happens rarely, if at all.
        !           671:                         * It seems mainly useful for ANSI terminals
        !           672:                         * with no hardware tabs, and I don't know
        !           673:                         * of any such terminal at the moment.
        !           674:                         */
        !           675:                        tputs(tgoto(RIGHT_PARM, 0, j), j, plodput);
        !           676:                        outcol += j;
        !           677:                }
        !           678:                else {
        !           679:                        /*
        !           680:                         * move one char to the right.  We don't use ND space
        !           681:                         * because it's better to just print the char we are
        !           682:                         * moving over.  There are various exceptions, however.
        !           683:                         * If !inopen, vtube contains garbage.  If the char is
        !           684:                         * a null or a tab we want to print a space.  Other
        !           685:                         * random chars we use space for instead, too.
        !           686:                         */
        !           687:                        if (!inopen || vtube[outline]==NULL ||
        !           688:                                (i=vtube[outline][outcol]) < ' ')
        !           689:                                i = ' ';
        !           690:                        if(i & QUOTE)   /* mjm: no sign extension on 3B */
        !           691:                                i = ' ';
        !           692:                        if (insmode && ND)
        !           693:                                tputs(ND, 0, plodput);
        !           694:                        else
        !           695:                                plodput(i);
        !           696:                        outcol++;
        !           697:                }
        !           698:                if (plodcnt < 0)
        !           699:                        goto out;
        !           700:        }
        !           701: out:
        !           702:        if (plodflg) {
        !           703:                outcol = soutcol;
        !           704:                outline = soutline;
        !           705:        }
        !           706:        return(plodcnt);
        !           707: }
        !           708: 
        !           709: /*
        !           710:  * An input line arrived.
        !           711:  * Calculate new (approximate) screen line position.
        !           712:  * Approximate because kill character echoes newline with
        !           713:  * no feedback and also because of long input lines.
        !           714:  */
        !           715: noteinp()
        !           716: {
        !           717: 
        !           718:        outline++;
        !           719:        if (outline > LINES - 1)
        !           720:                outline = LINES - 1;
        !           721:        destline = outline;
        !           722:        destcol = outcol = 0;
        !           723: }
        !           724: 
        !           725: /*
        !           726:  * Something weird just happened and we
        !           727:  * lost track of whats happening out there.
        !           728:  * Since we cant, in general, read where we are
        !           729:  * we just reset to some known state.
        !           730:  * On cursor addressible terminals setting to unknown
        !           731:  * will force a cursor address soon.
        !           732:  */
        !           733: termreset()
        !           734: {
        !           735: 
        !           736:        endim();
        !           737:        if (TI) /* otherwise it flushes anyway, and 'set tty=dumb' vomits */
        !           738:                putpad(TI);      /*adb change -- emit terminal initial sequence */
        !           739:        destcol = 0;
        !           740:        destline = LINES - 1;
        !           741:        if (CA) {
        !           742:                outcol = UKCOL;
        !           743:                outline = UKCOL;
        !           744:        } else {
        !           745:                outcol = destcol;
        !           746:                outline = destline;
        !           747:        }
        !           748: }
        !           749: 
        !           750: /*
        !           751:  * Low level buffering, with the ability to drain
        !           752:  * buffered output without printing it.
        !           753:  */
        !           754: char   *obp = obuf;
        !           755: 
        !           756: draino()
        !           757: {
        !           758: 
        !           759:        obp = obuf;
        !           760: }
        !           761: 
        !           762: flusho()
        !           763: {
        !           764: 
        !           765:        if (obp != obuf) {
        !           766:                write(1, obuf, obp - obuf);
        !           767:                obp = obuf;
        !           768:        }
        !           769: }
        !           770: 
        !           771: putnl()
        !           772: {
        !           773: 
        !           774:        putchar('\n');
        !           775: }
        !           776: 
        !           777: putS(cp)
        !           778:        char *cp;
        !           779: {
        !           780: 
        !           781:        if (cp == NULL)
        !           782:                return;
        !           783:        while (*cp)
        !           784:                putch(*cp++);
        !           785: }
        !           786: 
        !           787: 
        !           788: putch(c)
        !           789:        int c;
        !           790: {
        !           791: 
        !           792: #ifdef OLD3BTTY                /* mjm */
        !           793:        if(c == '\n')   /* mjm: Fake "\n\r" for '\n' til fix in 3B firmware */
        !           794:                putch('\r');    /* mjm: vi does "stty -icanon" => -onlcr !! */
        !           795: #endif
        !           796:        *obp++ = c & 0177;
        !           797:        if (obp >= &obuf[sizeof obuf])
        !           798:                flusho();
        !           799: }
        !           800: 
        !           801: /*
        !           802:  * Miscellaneous routines related to output.
        !           803:  */
        !           804: 
        !           805: /*
        !           806:  * Put with padding
        !           807:  */
        !           808: putpad(cp)
        !           809:        char *cp;
        !           810: {
        !           811: 
        !           812:        flush();
        !           813:        tputs(cp, 0, putch);
        !           814: }
        !           815: 
        !           816: /*
        !           817:  * Set output through normal command mode routine.
        !           818:  */
        !           819: setoutt()
        !           820: {
        !           821: 
        !           822:        Outchar = termchar;
        !           823: }
        !           824: 
        !           825: /*
        !           826:  * Printf (temporarily) in list mode.
        !           827:  */
        !           828: /*VARARGS2*/
        !           829: lprintf(cp, dp)
        !           830:        char *cp, *dp;
        !           831: {
        !           832:        register int (*P)();
        !           833: 
        !           834:        P = setlist(1);
        !           835:        printf(cp, dp);
        !           836:        Putchar = P;
        !           837: }
        !           838: 
        !           839: /*
        !           840:  * Newline + flush.
        !           841:  */
        !           842: putNFL()
        !           843: {
        !           844: 
        !           845:        putnl();
        !           846:        flush();
        !           847: }
        !           848: 
        !           849: /*
        !           850:  * Try to start -nl mode.
        !           851:  */
        !           852: pstart()
        !           853: {
        !           854: 
        !           855:        if (NONL)
        !           856:                return;
        !           857:        if (!value(OPTIMIZE))
        !           858:                return;
        !           859:        if (ruptible == 0 || pfast)
        !           860:                return;
        !           861:        fgoto();
        !           862:        flusho();
        !           863:        pfast = 1;
        !           864:        normtty++;
        !           865: #ifndef USG3TTY
        !           866:        tty.sg_flags = normf & ~(ECHO|XTABS|CRMOD);
        !           867: #else
        !           868:        tty = normf;
        !           869:        tty.c_oflag &= ~(ONLCR|TAB3);
        !           870:        tty.c_lflag &= ~ECHO;
        !           871: #endif
        !           872:        sTTY(1);
        !           873: }
        !           874: 
        !           875: /*
        !           876:  * Stop -nl mode.
        !           877:  */
        !           878: pstop()
        !           879: {
        !           880: 
        !           881:        if (inopen)
        !           882:                return;
        !           883:        phadnl = 0;
        !           884:        linp = linb;
        !           885:        draino();
        !           886:        normal(normf);
        !           887:        pfast &= ~1;
        !           888: }
        !           889: 
        !           890: /*
        !           891:  * Prep tty for open mode.
        !           892:  */
        !           893: ttymode
        !           894: ostart()
        !           895: {
        !           896:        ttymode f;
        !           897: 
        !           898:        if (!intty)
        !           899:                error("Open and visual must be used interactively");
        !           900:        gTTY(1);
        !           901:        normtty++;
        !           902: #ifndef USG3TTY
        !           903:        f = tty.sg_flags;
        !           904:        tty.sg_flags = (normf &~ (ECHO|XTABS|CRMOD)) |
        !           905: # ifdef CBREAK
        !           906:                                                        CBREAK;
        !           907: # else
        !           908:                                                        RAW;
        !           909: # endif
        !           910: # ifdef TIOCGETC
        !           911:        ttcharoff();
        !           912: # endif
        !           913: #else
        !           914:        f = tty;
        !           915:        tty = normf;
        !           916:        tty.c_iflag &= ~ICRNL;
        !           917:        tty.c_lflag &= ~(ECHO|ICANON);
        !           918:        tty.c_oflag &= ~(TAB3|ONLCR);
        !           919:        tty.c_cc[VMIN] = 1;
        !           920:        tty.c_cc[VTIME] = 1;
        !           921:        ttcharoff();
        !           922: #endif
        !           923:        sTTY(1);
        !           924:        tostart();
        !           925:        pfast |= 2;
        !           926:        return (f);
        !           927: }
        !           928: 
        !           929: /* actions associated with putting the terminal in open mode */
        !           930: tostart()
        !           931: {
        !           932:        putpad(VS);
        !           933:        putpad(KS);
        !           934:        if (!value(MESG)) {
        !           935:                if (ttynbuf[0] == 0) {
        !           936:                        register char *tn;
        !           937:                        if ((tn=ttyname(2)) == NULL &&
        !           938:                            (tn=ttyname(1)) == NULL &&
        !           939:                            (tn=ttyname(0)) == NULL)
        !           940:                                ttynbuf[0] = 1;
        !           941:                        else
        !           942:                                strcpy(ttynbuf, tn);
        !           943:                }
        !           944:                if (ttynbuf[0] != 1) {
        !           945:                        struct stat sbuf;
        !           946:                        stat(ttynbuf, &sbuf);
        !           947:                        ttymesg = sbuf.st_mode & 0777;
        !           948:                        chmod(ttynbuf,
        !           949: #ifdef UCBV7
        !           950:        /*
        !           951:         * This applies to the UCB V7 Pdp-11 system with the
        !           952:         * -u write option only.
        !           953:         */
        !           954:                                        0611    /* 11 = urgent only allowed */
        !           955: #else
        !           956:                                        0600
        !           957: #endif
        !           958:                                                );
        !           959:                }
        !           960:        }
        !           961: }
        !           962: 
        !           963: /*
        !           964:  * Turn off start/stop chars if they aren't the default ^S/^Q.
        !           965:  * This is so idiots who make esc their start/stop don't lose.
        !           966:  * We always turn off quit since datamedias send ^\ for their
        !           967:  * right arrow key.
        !           968:  */
        !           969: #ifdef TIOCGETC
        !           970: ttcharoff()
        !           971: {
        !           972:        nttyc.t_quitc = '\377';
        !           973:        if (nttyc.t_startc != CTRL(q))
        !           974:                nttyc.t_startc = '\377';
        !           975:        if (nttyc.t_stopc != CTRL(s))
        !           976:                nttyc.t_stopc = '\377';
        !           977: # ifdef TIOCLGET
        !           978:        nlttyc.t_suspc = '\377';        /* ^Z */
        !           979:        nlttyc.t_dsuspc = '\377';       /* ^Y */
        !           980:        nlttyc.t_flushc = '\377';       /* ^O */
        !           981:        nlttyc.t_lnextc = '\377';       /* ^V */
        !           982: # endif
        !           983: }
        !           984: #endif
        !           985: 
        !           986: #ifdef USG3TTY
        !           987: ttcharoff()
        !           988: {
        !           989:        tty.c_cc[VQUIT] = '\377';
        !           990: # ifdef VSTART
        !           991:        /*
        !           992:         * The following is sample code if USG ever lets people change
        !           993:         * their start/stop chars.  As long as they can't we can't get
        !           994:         * into trouble so we just leave them alone.
        !           995:         */
        !           996:        if (tty.c_cc[VSTART] != CTRL(q))
        !           997:                tty.c_cc[VSTART] = '\377';
        !           998:        if (tty.c_cc[VSTOP] != CTRL(s))
        !           999:                tty.c_cc[VSTOP] = '\377';
        !          1000: # endif
        !          1001: }
        !          1002: #endif
        !          1003: 
        !          1004: /*
        !          1005:  * Stop open, restoring tty modes.
        !          1006:  */
        !          1007: ostop(f)
        !          1008:        ttymode f;
        !          1009: {
        !          1010: 
        !          1011: #ifndef USG3TTY
        !          1012:        pfast = (f & CRMOD) == 0;
        !          1013: #else
        !          1014:        pfast = (f.c_oflag & ONLCR) == 0;
        !          1015: #endif
        !          1016:        termreset(), fgoto(), flusho();
        !          1017:        normal(f);
        !          1018:        tostop();
        !          1019: }
        !          1020: 
        !          1021: /* Actions associated with putting the terminal in the right mode. */
        !          1022: tostop()
        !          1023: {
        !          1024:        putpad(VE);
        !          1025:        putpad(KE);
        !          1026:        if (!value(MESG) && ttynbuf[0]>1)
        !          1027:                chmod(ttynbuf, ttymesg);
        !          1028: }
        !          1029: 
        !          1030: #ifndef CBREAK
        !          1031: /*
        !          1032:  * Into cooked mode for interruptibility.
        !          1033:  */
        !          1034: vcook()
        !          1035: {
        !          1036: 
        !          1037:        tty.sg_flags &= ~RAW;
        !          1038:        sTTY(1);
        !          1039: }
        !          1040: 
        !          1041: /*
        !          1042:  * Back into raw mode.
        !          1043:  */
        !          1044: vraw()
        !          1045: {
        !          1046: 
        !          1047:        tty.sg_flags |= RAW;
        !          1048:        sTTY(1);
        !          1049: }
        !          1050: #endif
        !          1051: 
        !          1052: /*
        !          1053:  * Restore flags to normal state f.
        !          1054:  */
        !          1055: normal(f)
        !          1056:        ttymode f;
        !          1057: {
        !          1058: 
        !          1059:        if (normtty > 0) {
        !          1060:                setty(f);
        !          1061:                normtty--;
        !          1062:        }
        !          1063: }
        !          1064: 
        !          1065: /*
        !          1066:  * Straight set of flags to state f.
        !          1067:  */
        !          1068: ttymode
        !          1069: setty(f)
        !          1070:        ttymode f;
        !          1071: {
        !          1072: #ifndef USG3TTY
        !          1073:        register int ot = tty.sg_flags;
        !          1074: #else
        !          1075:        ttymode ot;
        !          1076:        ot = tty;
        !          1077: #endif
        !          1078: 
        !          1079: #ifndef USG3TTY
        !          1080:        if (f == normf) {
        !          1081:                nttyc = ottyc;
        !          1082: # ifdef TIOCLGET
        !          1083:                nlttyc = olttyc;
        !          1084: # endif
        !          1085:        } else
        !          1086:                ttcharoff();
        !          1087:        tty.sg_flags = f;
        !          1088: #else
        !          1089:        if (tty.c_lflag & ICANON)
        !          1090:                ttcharoff();
        !          1091:        tty = f;
        !          1092: #endif
        !          1093:        sTTY(1);
        !          1094:        return (ot);
        !          1095: }
        !          1096: 
        !          1097: gTTY(i)
        !          1098:        int i;
        !          1099: {
        !          1100: 
        !          1101: #ifndef USG3TTY
        !          1102:        ignore(gtty(i, &tty));
        !          1103: # ifdef TIOCGETC
        !          1104:        ioctl(i, TIOCGETC, &ottyc);
        !          1105:        nttyc = ottyc;
        !          1106: # endif
        !          1107: # ifdef TIOCGLTC
        !          1108:        ioctl(i, TIOCGLTC, &olttyc);
        !          1109:        nlttyc = olttyc;
        !          1110: # endif
        !          1111: #else
        !          1112:        ioctl(i, TCGETA, &tty);
        !          1113: #endif
        !          1114: }
        !          1115: 
        !          1116: /*
        !          1117:  * sTTY: set the tty modes on file descriptor i to be what's
        !          1118:  * currently in global "tty".  (Also use nttyc if needed.)
        !          1119:  */
        !          1120: sTTY(i)
        !          1121:        int i;
        !          1122: {
        !          1123: 
        !          1124: #ifndef USG3TTY
        !          1125: # ifdef USG
        !          1126:        /* Bug in USG tty driver, put out a DEL as a patch. */
        !          1127:        if (tty.sg_ospeed >= B1200)
        !          1128:                write(1, "\377", 1);
        !          1129: # endif
        !          1130: 
        !          1131: # ifdef TIOCSETN
        !          1132:        /* Don't flush typeahead if we don't have to */
        !          1133:        ioctl(i, TIOCSETN, &tty);
        !          1134: # else
        !          1135:        /* We have to.  Too bad. */
        !          1136:        stty(i, &tty);
        !          1137: # endif
        !          1138: 
        !          1139: # ifdef TIOCGETC
        !          1140:        /* Update the other random chars while we're at it. */
        !          1141:        ioctl(i, TIOCSETC, &nttyc);
        !          1142: # endif
        !          1143: # ifdef TIOCSLTC
        !          1144:        ioctl(i, TIOCSLTC, &nlttyc);
        !          1145: # endif
        !          1146: 
        !          1147: #else
        !          1148:        /* USG 3 very simple: just set everything */
        !          1149:        ioctl(i, TCSETAW, &tty);
        !          1150: #endif
        !          1151: }
        !          1152: 
        !          1153: /*
        !          1154:  * Print newline, or blank if in open/visual
        !          1155:  */
        !          1156: noonl()
        !          1157: {
        !          1158: 
        !          1159:        putchar(Outchar != termchar ? ' ' : '\n');
        !          1160: }

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