Return to vtrm.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed

Annotation of 43BSD/contrib/B/src/bed/vtrm.c, revision 1.1

1.1     ! root        1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
        !             2: static char rcsid[] = "$Header: vtrm.c,v 1.3 85/08/30 10:11:04 timo Exp $";
        !             3: 
        !             4: /* History:
        !             5:  *     21-aug-85 GvR   added support for AL and DL (parametrized al and dl).
        !             6:  *     The Epoch tk    created and modified.
        !             7:  */
        !             8: 
        !             9: /*
        !            10:  * Virtual TeRMinal package.
        !            11:  *
        !            12:  * This package uses termcap to determine the terminal capabilities.
        !            13:  *
        !            14:  * The lines and columns of our virtual terminal are numbered 
        !            15:  *     y = {0...lines-1} from top to bottom, and
        !            16:  *     x = {0...cols-1} from left to right,
        !            17:  * respectively.
        !            18:  *
        !            19:  * The Visible Procedures in this package are:
        !            20:  *
        !            21:  * trmstart(&lines, &cols, &flags)
        !            22:  *     Obligatory initialization call (sets tty modes etc.),
        !            23:  *     Returns the height and width of the screen to the integers
        !            24:  *     whose addresses are passed as parameters, and a flag that
        !            25:  *     describes some capabilities.
        !            26:  *     Function return value: Yes if all went well, No if the terminal
        !            27:  *     is not supported.  An error message has already been displayed.
        !            28:  *
        !            29:  * trmundefined()
        !            30:  *     Sets internal representation of screen and attributes to undefined.
        !            31:  *     This is necessary for a hard redraw, which would get optimised to
        !            32:  *     oblivion,
        !            33:  *
        !            34:  * trmsense(&y, &x)
        !            35:  *     Returns the cursor position through its parameters
        !            36:  *     after a possible manual change by the user.
        !            37:  *
        !            38:  * trmputdata(yfirst, ylast, indent, data)
        !            39:  *     Fill lines {yfirst..ylast} with data, after skipping the initial
        !            40:  *     'indent' positions. It is assumed that these positions do not contain
        !            41:  *     anything dangerous (like standout cookies or null characters).
        !            42:  *
        !            43:  * trmscrollup(yfirst, ylast, by)
        !            44:  *     Shift lines {yfirst..ylast} up by lines (down |by| if by < 0).
        !            45:  *
        !            46:  * trmsync(y, x)
        !            47:  *     Call to output data to the terminal and set cursor position.
        !            48:  *
        !            49:  * trmbell()
        !            50:  *     Send a (possibly visible) bell, immediately (flushing stdout).
        !            51:  *
        !            52:  * trmend()
        !            53:  *     Obligatory termination call (resets tty modes etc.).
        !            54:  *
        !            55:  * You may call these as one or more cycles of:
        !            56:  *     + trmstart
        !            57:  *     +    zero or more times any of the other routines
        !            58:  *     + trmend
        !            59:  * To catch interrupts and the like, you may call trmend even in the middle
        !            60:  * of trmstart.
        !            61:  */
        !            62: 
        !            63: 
        !            64: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !            65: /* Includes and data definitions.                                           */
        !            66: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !            67: 
        !            68: #include <stdio.h>
        !            69: #include <setjmp.h>
        !            70: #ifndef TERMIO
        !            71: #include <sgtty.h>
        !            72: #else
        !            73: #include <termio.h>
        !            74: #endif TERMIO
        !            75: #include <signal.h>
        !            76: #include <ctype.h>             /* for isprint() */
        !            77: 
        !            78: #include "vtrm.h"
        !            79: 
        !            80: #ifdef lint
        !            81: #define VOID (void)
        !            82: #else
        !            83: #define VOID
        !            84: #endif
        !            85: 
        !            86: #define Forward
        !            87: #define Visible
        !            88: #define Hidden static
        !            89: #define Procedure
        !            90: 
        !            91: typedef short intlet;
        !            92: typedef char *string;
        !            93: typedef char bool;
        !            94: #define Yes ((bool) 1)
        !            95: #define No  ((bool) 0)
        !            96: 
        !            97: #define Min(a,b) ((a) <= (b) ? (a) : (b))
        !            98: 
        !            99: /* tty modes */
        !           100: #ifndef TERMIO
        !           101: /* v7/BSD tty control */
        !           102: Hidden struct sgttyb oldtty, newtty;
        !           103: /* to enable type ahead for abled persons on systems that provide this: */
        !           104: #ifdef TIOCSETN
        !           105: #define stty(fd,bp) VOID ioctl(fd, TIOCSETN, bp)
        !           106: #endif
        !           107: #else
        !           108: /* AT&T tty control */
        !           109: Hidden struct termio oldtty, newtty;
        !           110: #define gtty(fd,bp) ioctl(fd, TCGETA, bp)
        !           111: #define stty(fd,bp) VOID ioctl(fd, TCSETAW, bp)
        !           112: #endif TERMIO
        !           113: Hidden bool know_ttys = No;
        !           114: 
        !           115: /* visible data for termcap */
        !           116: char PC;
        !           117: char *BC;
        !           118: char *UP;
        !           119: short ospeed;
        !           120: 
        !           121: Forward int outchar();                 /* procedure for termcap's tputs */
        !           122: #define Putstr(str)    tputs((str), 1, outchar)
        !           123: extern char *tgoto();
        !           124: 
        !           125: /* termcap terminal capabilities */
        !           126: 
        !           127: Hidden int lines;
        !           128: Hidden int cols;
        !           129: 
        !           130: Hidden bool has_am;            /* has automatic margins */
        !           131: Hidden bool has_da;            /* display may be retained above screen */
        !           132: Hidden bool has_db;            /* display may be retained below screen */
        !           133: Hidden bool has_in;            /* not save to have null chars on the screen */
        !           134: Hidden bool has_mi;            /* move safely in insert (and delete?) mode */
        !           135: Hidden bool has_ms;            /* move safely in standout mode */
        !           136: Hidden bool has_xs;            /* standout not erased by overwriting */
        !           137: 
        !           138: Hidden char *al_str;           /* add new blank line */
        !           139: Hidden char *par_al_str;       /* parametrized al (AL) */
        !           140: Hidden char *cd_str;           /* clear to end of display */
        !           141: Hidden char *ce_str;           /* clear to end of line */
        !           142: Hidden char *cl_str;           /* cursor home and clear screen */
        !           143: Hidden char *cm_str;           /* cursor motion */
        !           144: Hidden char *cr_str;           /* carriage return */
        !           145: Hidden char *cs_str;           /* change scrolling region */
        !           146: Hidden char *dc_str;           /* delete character */
        !           147: Hidden char *dl_str;           /* delete line */
        !           148: Hidden char *par_dl_str;       /* parametrized dl (DL) */
        !           149: Hidden char *do_str;           /* cursor down one line */
        !           150: Hidden char *dm_str;           /* enter delete mode */
        !           151: Hidden char *ed_str;           /* end delete mode */
        !           152: Hidden char *ei_str;           /* end insert mode */
        !           153: Hidden char *ho_str;           /* cursor home */
        !           154: Hidden char *ic_str;           /* insert character (iff necessary, maybe pad) */
        !           155: Hidden char *im_str;           /* enter insert mode */
        !           156: Hidden char *le_str;           /* cursor left */
        !           157: Hidden char *nd_str;           /* cursor right (non-destructive space) */
        !           158: Hidden char *se_str;           /* end standout mode */
        !           159: Hidden char *sf_str;           /* scroll text up (from bottom of region) */
        !           160: Hidden char *so_str;           /* begin standout mode */
        !           161: Hidden char *sr_str;           /* scroll text down (from top of region) */
        !           162: Hidden char *te_str;           /* end termcap */
        !           163: Hidden char *ti_str;           /* start termcap */
        !           164: Hidden char *up_str;           /* cursor up */
        !           165: Hidden char *vb_str;           /* visible bell */
        !           166: Hidden char *ve_str;           /* make cursor visible again */
        !           167: Hidden char *vi_str;           /* make cursor invisible */
        !           168: 
        !           169: /* sense cursor position, addition to termcap */
        !           170: Hidden char *cp_str;           /* format of returned Cursor Position string */
        !           171: Hidden char *sp_str;           /* Sense cursor Position from terminal */
        !           172: 
        !           173: /* terminal status */
        !           174: 
        !           175: /* calling order of Visible Procs */
        !           176: Hidden bool started = No;
        !           177: 
        !           178: /* to exports the capabilities mentioned in vtrm.h: */
        !           179: Hidden int flags = 0;
        !           180: 
        !           181: /* cost for impossible operations */
        !           182: #define Infinity 9999
        !           183:        /* Allow for adding Infinity+Infinity within range */
        !           184:        /* (Range is assumed at least 2**15 - 1) */
        !           185: 
        !           186: /* The following for all sorts of undefined things (except for UNKNOWN char) */
        !           187: #define Undefined (-1)
        !           188: 
        !           189: /* current mode of putting char's */
        !           190: #define Normal 0
        !           191: #define Insert 1
        !           192: #define        Delete  2
        !           193: Hidden short mode = Normal;
        !           194: 
        !           195: /* current standout mode */
        !           196: #define Off    0
        !           197: #define On     0200
        !           198: Hidden short so_mode = Off;
        !           199: 
        !           200: /* masks for char's and intlet's */
        !           201: #define NULCHAR        '\000'
        !           202: #define CHAR   0177
        !           203: #define SOBIT  On
        !           204: #define SOCHAR 0377
        !           205: /* if (has_xs) record cookies placed on screen in extra bit */
        !           206: /* type of cookie is determined by the SO bit */
        !           207: #define XSBIT  0400
        !           208: #define SOCOOK 0600
        !           209: #define COOKBITS SOCOOK
        !           210: #define UNKNOWN        1
        !           211: #define NOCOOK UNKNOWN
        !           212: 
        !           213: /* current cursor position */
        !           214: Hidden intlet cur_y = Undefined, cur_x = Undefined;
        !           215: 
        !           216: /* "line[y][x]" holds the char on the terminal, with the SOBIT and XSBIT.
        !           217:  * the SOBIT tells whether the character is standing out, the XSBIT whether
        !           218:  * there is a cookie on the screen at this position.
        !           219:  * In particular a standend-cookie may be recorded AFTER the line
        !           220:  * (just in case some trmputdata will write after that position).
        !           221:  * "lenline[y]" holds the length of the line.
        !           222:  * Unknown chars will be 1, so the optimising compare in putline will fail.
        !           223:  * (Partially) empty lines are distinghuished by "lenline[y] < cols".
        !           224:  */
        !           225: Hidden intlet **line = 0, *lenline = 0;
        !           226: 
        !           227: /* Clear the screen initially iff only memory cursor addressing available */
        !           228: Hidden bool mustclear = No;
        !           229: 
        !           230: /* Make the cursor invisible when trmsync() tries to move outside the screen */
        !           231: Hidden bool no_cursor = No;
        !           232: 
        !           233: /* Optimise cursor motion */
        !           234: Hidden int abs_cost;           /* cost of absolute cursor motion */
        !           235: Hidden int cr_cost;            /* cost of carriage return */
        !           236: Hidden int do_cost;            /* cost of down */
        !           237: Hidden int le_cost;            /* cost of left */
        !           238: Hidden int nd_cost;            /* cost of right */
        !           239: Hidden int up_cost;            /* cost of up */
        !           240: 
        !           241: /* Optimise trailing match in put_line, iff the terminal can insert and delete
        !           242:  * characters; the cost per n characters will be:
        !           243:  *     n * MultiplyFactor + OverHead
        !           244:  */
        !           245: Hidden int ins_mf, ins_oh, del_mf, del_oh;
        !           246: Hidden int ed_cost, ei_cost;           /* used in move() */
        !           247: 
        !           248: /* The type of scrolling possible determines which routines get used;
        !           249:  * these may be:
        !           250:  * (1) with addline and deleteline (termcap: al_str & dl_str);
        !           251:  * (2) with a settable scrolling region, like VT100 (cs_str, sr_str, sf_str);
        !           252:  * (3) no scrolling available. (NOT YET IMPLEMENTED)
        !           253:  */
        !           254: Hidden Procedure (*scr_up)();
        !           255: Hidden Procedure (*scr_down)();
        !           256: Forward Procedure scr1up();
        !           257: Forward Procedure scr1down();
        !           258: Forward Procedure scr2up();
        !           259: Forward Procedure scr2down();
        !           260: /*Forward Procedure scr3up(); */
        !           261: /*Forward Procedure scr3down(); */
        !           262: 
        !           263: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !           264: /* Starting, Ending and (fatal) Error.                                      */
        !           265: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !           266: 
        !           267: /* 
        !           268:  * Initialization call.
        !           269:  * Determine terminal capabilities from termcap.
        !           270:  * Set up tty modes.
        !           271:  * Start up terminal and internal administration.
        !           272:  * Return Yes if succeeded, No if trouble (e.g., bad terminal type).
        !           273:  */
        !           274: Visible int
        !           275: trmstart(plines, pcols, pflags)
        !           276: int *plines;
        !           277: int *pcols;
        !           278: int *pflags;
        !           279: {
        !           280: #ifdef TRACE
        !           281: fprintf(stderr, "\ttrmstart(&li, &co, &fl);\n");
        !           282: #endif
        !           283:        if (started)
        !           284:                trmerr("trmstart called twice in succession");
        !           285:        if (!gettermcaps())
        !           286:                return No;
        !           287:        if (!setttymode())
        !           288:                return No;
        !           289:        start_trm();
        !           290: 
        !           291:        *plines = lines;
        !           292:        *pcols = cols;
        !           293:        *pflags = flags;
        !           294:        
        !           295:        started = Yes;
        !           296:        return Yes;
        !           297: }
        !           298: 
        !           299: /*
        !           300:  * Termination call.
        !           301:  * Reset tty modes, etc.
        !           302:  * Beware that it might be called by a catched interrupt even in the middle
        !           303:  * of trmstart()!
        !           304:  */
        !           305: Visible Procedure
        !           306: trmend()
        !           307: {
        !           308: #ifdef TRACE
        !           309: fprintf(stderr, "\ttrmend();\n");
        !           310: #endif
        !           311:        set_mode(Normal);
        !           312:        if (so_mode != Off)
        !           313:                standend();
        !           314:        Putstr(te_str);
        !           315:        VOID fflush(stdout);
        !           316:        resetttymode();
        !           317: 
        !           318:        started = No;
        !           319: }
        !           320: 
        !           321: /*
        !           322:  * Set all internal statuses to undefined, especially the contents of
        !           323:  * the screen, so a hard redraw will not be optimised to heaven.
        !           324:  */
        !           325: Visible Procedure
        !           326: trmundefined()
        !           327: {
        !           328:        register int y, x;
        !           329: #ifdef TRACE
        !           330: fprintf(stderr, "\ttrmundefined();\n");
        !           331: #endif
        !           332: 
        !           333:        cur_y = cur_x = Undefined;
        !           334:        mode = so_mode = Undefined;
        !           335:        
        !           336:        for (y = 0; y < lines; y++) {
        !           337:                for (x = 0; x <= cols; x++)
        !           338:                        line[y][x] = 1; /* impossible char, no so bits */
        !           339:                lenline[y] = cols;
        !           340:        }
        !           341: }
        !           342: 
        !           343: /* 
        !           344:  * Give an error message, and abort.
        !           345:  * The abort can be catched by the calling process.
        !           346:  */
        !           347: Hidden Procedure
        !           348: trmerr(mess)
        !           349: string mess;
        !           350: {
        !           351:        trmreset();
        !           352:        fprintf(stderr,
        !           353:                "*** System error in screen output module:\n*** %s\n", mess);
        !           354:        VOID fflush(stderr);
        !           355:        abort();
        !           356: }
        !           357: 
        !           358: /*
        !           359:  * Give an error message and reset the tty modes (but don't abort).
        !           360:  */
        !           361: Hidden Procedure trmmess(mess)
        !           362: string mess;
        !           363: {
        !           364:        trmreset();
        !           365:        fprintf(stderr, "*** Fatal error: %s\n", mess);
        !           366:        VOID fflush(stderr);
        !           367: }
        !           368: 
        !           369: /*
        !           370:  * Complain about a missing terminal feature.  Otherwise like trmmess.
        !           371:  */
        !           372: Hidden Procedure
        !           373: trmsorry(mess)
        !           374: string mess;
        !           375: {
        !           376:     trmreset();
        !           377:     fprintf(stderr, (
        !           378: #ifdef BED
        !           379:       "*** Sorry, this terminal isn't powerful enough to run the B editor.\n"
        !           380: #else
        !           381:       "*** Sorry, this terminal isn't powerful emough.\n"
        !           382: #endif
        !           383:     ));
        !           384:     fprintf(stderr, "*** The problem is: %s.\n", mess);
        !           385: #ifdef BED
        !           386:     fprintf(stderr,
        !           387:       "*** (You might try 'b -e' to use a standard editor instead.)\n");
        !           388: #endif
        !           389:     VOID fflush(stderr);
        !           390: }
        !           391: 
        !           392: /*
        !           393:  * Prepare for giving a (more or less fatal) error message.
        !           394:  */
        !           395: Hidden Procedure
        !           396: trmreset()
        !           397: {
        !           398:        if (started) {
        !           399:                move(lines-1, 0);
        !           400:                clear_lines(lines-1, lines-1);
        !           401:        }
        !           402:        VOID fflush(stdout);
        !           403:        resetttymode();
        !           404: }
        !           405: 
        !           406: Hidden Procedure
        !           407: check_started(m)
        !           408: char *m;
        !           409: {
        !           410:        char s[80];
        !           411:        
        !           412:        if (!started) {
        !           413:                VOID sprintf(s, "%s called outside trmstart/trmend", m);
        !           414:                trmerr(s);
        !           415:        }
        !           416: }
        !           417: 
        !           418: int ccc;
        !           419: 
        !           420: /*ARGSUSED*/
        !           421: Hidden Procedure
        !           422: countchar(ch)
        !           423: char ch;
        !           424: {
        !           425:        ccc++;
        !           426: }
        !           427: 
        !           428: Hidden int
        !           429: strcost(str)
        !           430: char *str;
        !           431: {
        !           432:        if (str == NULL)
        !           433:                return Infinity;
        !           434:        return str0cost(str);
        !           435: }
        !           436: 
        !           437: Hidden int
        !           438: str0cost(str)
        !           439: char *str;
        !           440: {
        !           441:        ccc = 0;
        !           442:        tputs(str, 1, countchar);
        !           443:        return ccc;
        !           444: }
        !           445: 
        !           446: Hidden int
        !           447: gettermcaps()                  /* get terminal capabilities from termcap
        !           448:                                 * and related static properties
        !           449:                                 */
        !           450: {
        !           451:        string trmname;
        !           452:        char tc_buf[1024];
        !           453:        static char strbuf[1024];
        !           454:        char *area = strbuf;
        !           455:        char *xPC;
        !           456:        char *getenv();
        !           457:        int tgetent();
        !           458:        int tgetnum();
        !           459:        int tgetflag();
        !           460:        char *tgetstr();
        !           461:        int sg;
        !           462:        static bool tc_initialized = No;
        !           463: #ifdef TIOCGWINSZ
        !           464:        struct winsize win;
        !           465: #endif
        !           466:        
        !           467:        if (tc_initialized)
        !           468:                return Yes;
        !           469:        
        !           470:        if ((trmname=getenv("TERM")) == NULL) {
        !           471:                trmmess("terminal type not exported in $TERM variable");
        !           472:                return No;
        !           473:        }
        !           474:        if (tgetent(tc_buf, trmname) != 1) {
        !           475:                trmmess("unknown terminal type in $TERM envariable");
        !           476:                return No;
        !           477:        }
        !           478:        
        !           479:        if (tgetflag("hc")) {
        !           480:                trmsorry("can't use a hardcopy terminal");
        !           481:                return No;
        !           482:        }
        !           483: 
        !           484:        BC = tgetstr("le", &area);
        !           485:        if (BC == NULL)
        !           486:                BC = tgetstr("bc", &area);
        !           487:        if (BC == NULL)
        !           488:                if (tgetflag("bs"))
        !           489:                        BC="\b";
        !           490:                else {
        !           491:                        trmsorry("no LEFT cursor motion");
        !           492:                        return No;
        !           493:                }
        !           494:        UP = tgetstr("up", &area);
        !           495:        if (UP == NULL) {
        !           496:                trmsorry("no UP cursor motion");
        !           497:                return No;
        !           498:        }
        !           499:        xPC = tgetstr("pc", &area);
        !           500:        PC = (xPC != NULL? xPC[0] : NULCHAR);
        !           501: 
        !           502:        ho_str = tgetstr("ho", &area);
        !           503:        do_str = tgetstr("do", &area);
        !           504:        nd_str = tgetstr("nd", &area);
        !           505:        cm_str = tgetstr("cm", &area);
        !           506:        if (cm_str == NULL) {
        !           507:                cm_str = tgetstr("CM", &area);
        !           508:                if (cm_str == NULL) {
        !           509:                        if (ho_str == NULL || do_str == NULL || nd_str == NULL) {
        !           510:                                trmsorry("no absolute cursor motion");
        !           511:                                return No;
        !           512:                        }
        !           513:                }
        !           514:                else
        !           515:                        mustclear = Yes;
        !           516:        }
        !           517: 
        !           518:        al_str = tgetstr("al", &area);
        !           519:        dl_str = tgetstr("dl", &area);
        !           520:        par_al_str = tgetstr("AL", &area);
        !           521:        par_dl_str = tgetstr("DL", &area);
        !           522:        if (al_str && dl_str) {
        !           523:                scr_up = scr1up;
        !           524:                scr_down = scr1down;
        !           525:                flags |= CAN_SCROLL;
        !           526:        }
        !           527:        else {
        !           528:                cs_str = tgetstr("cs", &area);
        !           529:                sf_str = tgetstr("sf", &area);
        !           530:                if (sf_str == NULL)
        !           531:                        sf_str = "\n";
        !           532:                sr_str = tgetstr("sr", &area);
        !           533:                if (cs_str && sr_str) {
        !           534:                        scr_up = scr2up;
        !           535:                        scr_down = scr2down;
        !           536:                        flags |= CAN_SCROLL;
        !           537:                }
        !           538:                else {
        !           539:                        trmsorry("can't scroll");
        !           540:                        return No;
        !           541:                }
        !           542:        }
        !           543:                
        !           544:        lines = tgetnum("li");
        !           545:        cols = tgetnum("co");
        !           546: #ifdef TIOCGWINSZ
        !           547:        if (ioctl (0, TIOCGWINSZ, &win) == 0) {
        !           548:                if (win.ws_col)
        !           549:                        cols = win.ws_col;
        !           550:                if (win.ws_row)
        !           551:                        lines = win.ws_row;
        !           552:        }
        !           553: #endif
        !           554:        if (lines == -1) lines = 24;
        !           555:        if (cols == -1) cols = 80;
        !           556:        
        !           557:        has_am = tgetflag("am");
        !           558:        has_db = tgetflag("db");
        !           559:        has_in = tgetflag("in");
        !           560:        has_mi = tgetflag("mi");
        !           561:        has_ms = tgetflag("ms");
        !           562:        has_xs = tgetflag("xs");
        !           563:        if ((sg=tgetnum("sg")) == 0)
        !           564:                has_xs = Yes;
        !           565:        else if (sg > 0) {
        !           566:                trmsorry("video attributes take up space on the screen");
        !           567:                return No;
        !           568:        }
        !           569:        
        !           570:        cd_str = tgetstr("cd", &area);
        !           571:        ce_str = tgetstr("ce", &area);
        !           572:        if (!ce_str) {
        !           573:                trmsorry("can't clear to end of line");
        !           574:                return No;
        !           575:        }
        !           576:        cl_str = tgetstr("cl", &area);
        !           577:        cr_str = tgetstr("cr", &area);
        !           578:        if (cr_str == NULL) cr_str = "\r";
        !           579:        dc_str = tgetstr("dc", &area);
        !           580:        dm_str = tgetstr("dm", &area);
        !           581:        if (do_str == NULL) do_str = tgetstr("nl", &area);
        !           582:        if (do_str == NULL) do_str = "\n";
        !           583:        ed_str = tgetstr("ed", &area);
        !           584:        ei_str = tgetstr("ei", &area);
        !           585:        ic_str = tgetstr("ic", &area);
        !           586:        im_str = tgetstr("im", &area);
        !           587:        le_str = BC;
        !           588:        se_str = tgetstr("se", &area);
        !           589:        so_str = tgetstr("so", &area);
        !           590:        te_str = tgetstr("te", &area);
        !           591:        ti_str = tgetstr("ti", &area);
        !           592:        up_str = UP;
        !           593:        vb_str = tgetstr("vb", &area);
        !           594:        if (vb_str == NULL)     /* then we will do with the audible bell */
        !           595:                vb_str = "\007";
        !           596:        ve_str = tgetstr("ve", &area);
        !           597:        vi_str = tgetstr("vi", &area);
        !           598:        
        !           599:        /* cursor sensing (non standard) */
        !           600:        cp_str = tgetstr("cp", &area);
        !           601:        sp_str = tgetstr("sp", &area);
        !           602:        if (cp_str != NULL && sp_str != NULL)
        !           603:                flags |= CAN_SENSE;
        !           604: 
        !           605:        if (so_str != NULL && se_str != NULL)
        !           606:                flags |= HAS_STANDOUT;
        !           607: 
        !           608:        /* calculate costs of local and absolute cursor motions */
        !           609:        if (cm_str == NULL)
        !           610:                abs_cost = Infinity;
        !           611:        else
        !           612:                abs_cost = strcost(tgoto(cm_str, 0, 0));
        !           613:        cr_cost = strcost(cr_str);
        !           614:        do_cost = strcost(do_str);
        !           615:        le_cost = strcost(le_str);
        !           616:        nd_cost = strcost(nd_str);
        !           617:        up_cost = strcost(up_str);
        !           618: 
        !           619:        /* cost of leaving insert or delete mode, used in move() */
        !           620:        ei_cost = str0cost(ei_str);
        !           621:        ed_cost = str0cost(ed_str);
        !           622:        
        !           623:        /* calculate insert and delete cost multiply_factor and overhead */
        !           624:        if (((im_str && ei_str) || ic_str) && dc_str) {
        !           625:                flags |= CAN_OPTIMISE;
        !           626:                ins_mf = 1 + str0cost(ic_str);
        !           627:                ins_oh = str0cost(im_str) + ei_cost;
        !           628:                del_mf = str0cost(dc_str);
        !           629:                del_oh = str0cost(dm_str) + ed_cost;
        !           630:        }
        !           631:                
        !           632:        tc_initialized = Yes;
        !           633:        return Yes;
        !           634: }
        !           635: 
        !           636: Hidden int
        !           637: setttymode()
        !           638: {
        !           639:        if (!know_ttys) {
        !           640:                if (gtty(1, &oldtty) != 0 || gtty(1, &newtty) != 0) {
        !           641:                        trmmess("can't get tty modes (output not a terminal)");
        !           642:                        return No;
        !           643:                }
        !           644: #ifndef TERMIO
        !           645:                ospeed = oldtty.sg_ospeed;
        !           646: #ifdef PWB
        !           647:                newtty.sg_flags = (newtty.sg_flags & ~ECHO & ~CRMOD & ~XTABS)
        !           648:                                  | RAW;
        !           649: #else PWB
        !           650:                newtty.sg_flags = (newtty.sg_flags & ~ECHO & ~CRMOD & ~XTABS)
        !           651:                                  | CBREAK;
        !           652: #endif PWB
        !           653: #else TERMIO
        !           654:                ospeed= oldtty.c_lflag & CBAUD;
        !           655:                newtty.c_iflag &= ~ICRNL; /* No CR->NL mapping on input */
        !           656:                newtty.c_oflag &= ~ONLCR; /* NL doesn't output CR */
        !           657:                newtty.c_lflag &= ~(ICANON|ECHO); /* No line editing, no echo */
        !           658:                newtty.c_cc[VMIN]= 3; /* wait for 3 characters */
        !           659:                newtty.c_cc[VTIME]= 1; /* or 0.1 sec. */
        !           660: #endif TERMIO
        !           661:                know_ttys = Yes;
        !           662:        }
        !           663:        stty(1, &newtty);
        !           664:        return Yes;
        !           665: }
        !           666: 
        !           667: Hidden Procedure
        !           668: resetttymode()
        !           669: {
        !           670:        if (know_ttys)
        !           671:                stty(1, &oldtty);
        !           672: }
        !           673: 
        !           674: Hidden char*
        !           675: lalloc(size)
        !           676: unsigned size;
        !           677: {
        !           678:        char *l;
        !           679:        char *malloc();
        !           680:        
        !           681:        l = malloc(size);
        !           682:        if (l == NULL)
        !           683:                trmerr("not enough memory for screen buffer");
        !           684:        return l;
        !           685: }
        !           686: 
        !           687: Hidden Procedure
        !           688: start_trm()
        !           689: {
        !           690:        register int y;
        !           691:        
        !           692:        if (line == 0) {
        !           693:                line = (intlet**) lalloc((unsigned) lines * sizeof(intlet*));
        !           694:                for (y = 0; y < lines; y++)
        !           695:                        line[y] = (intlet*) lalloc((unsigned) ((cols+1)*sizeof(intlet)));
        !           696:        }
        !           697:        if (lenline == 0)
        !           698:                lenline = (intlet*) lalloc((unsigned) lines * sizeof(intlet));
        !           699: 
        !           700:        
        !           701:        trmundefined();
        !           702:        
        !           703:        Putstr(ti_str);
        !           704:        if (cs_str)
        !           705:                Putstr(tgoto(cs_str, lines-1, 0));
        !           706:        if (mustclear)
        !           707:                clear_lines(0, lines-1);
        !           708: }
        !           709: 
        !           710: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !           711: /* Sensing and moving the cursor.                                           */
        !           712: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !           713: 
        !           714: /*
        !           715:  * Sense the current (y, x) cursor position, after a possible manual
        !           716:  * change by the user with local cursor motions.
        !           717:  * If the terminal cannot be asked for the current cursor position,
        !           718:  * or if the string returned by the terminal is garbled,
        !           719:  * the position is made Undefined.
        !           720:  */
        !           721: Visible Procedure
        !           722: trmsense(py, px)
        !           723:        int *py;
        !           724:        int *px;
        !           725: {
        !           726:        bool getpos();
        !           727: 
        !           728: #ifdef TRACE
        !           729: fprintf(stderr, "\ttrmsense(&yy, &xx);\n");
        !           730: #endif
        !           731:        check_started("trmsense");
        !           732: 
        !           733:        *py = *px = Undefined;
        !           734:        set_mode(Normal);
        !           735:        if (so_mode != Off)
        !           736:                standend();
        !           737:        
        !           738:        if (flags&CAN_SENSE && getpos(py, px)) {
        !           739:                if (*py < 0 || lines <= *py || *px < 0 || cols <= *px)
        !           740:                        *py = *px = Undefined;
        !           741:        }
        !           742:        cur_y = *py;
        !           743:        cur_x = *px;
        !           744: }
        !           745: 
        !           746: Hidden bool
        !           747: getpos(py, px)
        !           748: int *py, *px;
        !           749: {
        !           750:        char *format = cp_str;
        !           751:        int fc;                 /* current format character */
        !           752:        int ic;                 /* current input character */
        !           753:        int num;
        !           754:        int on_y = 1;
        !           755:        bool incr_orig = No;
        !           756:        int i, ni;
        !           757: 
        !           758:        Putstr(sp_str);
        !           759:        VOID fflush(stdout);
        !           760: 
        !           761:        while (fc = *format++) {
        !           762:                if (fc != '%') {
        !           763:                        if (getchar() != fc)
        !           764:                                return No;
        !           765:                }
        !           766:                else {
        !           767:                        switch (fc = *format++) {
        !           768:                        case '%':
        !           769:                                if (getchar() != '%')
        !           770:                                        return No;
        !           771:                                continue;
        !           772:                        case 'r':
        !           773:                                on_y = 1 - on_y;
        !           774:                                continue;
        !           775:                        case 'i':
        !           776:                                incr_orig = Yes;
        !           777:                                continue;
        !           778:                        case 'd':
        !           779:                                ic = getchar();
        !           780:                                if (!isdigit(ic))
        !           781:                                        return No;
        !           782:                                num = ic - '0';
        !           783:                                while (isdigit(ic=getchar()))
        !           784:                                        num = 10*num + ic - '0';
        !           785:                                VOID ungetc(ic, stdin);
        !           786:                                break;
        !           787:                        case '2':
        !           788:                        case '3':
        !           789:                                ni = fc - '0';
        !           790:                                num = 0;
        !           791:                                for (i=0; i<ni; i++) {
        !           792:                                        ic = getchar();
        !           793:                                        if (isdigit(ic))
        !           794:                                                num = 10*num + ic - '0';
        !           795:                                        else
        !           796:                                                return No;
        !           797:                                }
        !           798:                                break;
        !           799:                        case '+':
        !           800:                                num = getchar() - *format++;
        !           801:                                break;
        !           802:                        case '-':
        !           803:                                num = getchar() + *format++;
        !           804:                                break;
        !           805:                        default:
        !           806:                                return No;
        !           807:                        }
        !           808:                        /* assign num to parameter */
        !           809:                        if (incr_orig)
        !           810:                                num--;
        !           811:                        if (on_y)
        !           812:                                *py = num;
        !           813:                        else
        !           814:                                *px = num;
        !           815:                        on_y = 1 - on_y;
        !           816:                }
        !           817:        }
        !           818: 
        !           819:        return Yes;
        !           820: }
        !           821:                
        !           822: /* 
        !           823:  * To move over characters by rewriting them, we have to check:
        !           824:  * (1) that the screen has been initialised on these positions;
        !           825:  * (2) we do not screw up characters
        !           826:  * when rewriting line[y] from x_from upto x_to
        !           827:  */
        !           828: Hidden bool
        !           829: rewrite_ok(y, xfrom, xto)
        !           830: int y, xfrom, xto;
        !           831: {
        !           832:        register intlet *plnyx, *plnyto;
        !           833:        
        !           834:        if (xto > lenline[y])
        !           835:                return No;
        !           836: 
        !           837:        plnyto = &line[y][xto];
        !           838:        for (plnyx = &line[y][xfrom]; plnyx <= plnyto; plnyx++)
        !           839:                if (*plnyx == UNKNOWN
        !           840:                    ||
        !           841:                    (!has_xs && (*plnyx & SOBIT) != so_mode)
        !           842:                   )
        !           843:                        return No;
        !           844:        return Yes;
        !           845: }
        !           846:                
        !           847: /*
        !           848:  * Move to position y,x on the screen
        !           849:  */
        !           850: /* possible move types for y and x respectively: */
        !           851: #define None   0
        !           852: #define Down   1
        !           853: #define Up     2
        !           854: #define Right  1
        !           855: #define ReWrite        2
        !           856: #define Left   3
        !           857: #define CrWrite        4
        !           858: 
        !           859: Hidden Procedure
        !           860: move(y, x)
        !           861: int y, x;
        !           862: {
        !           863:        int dy, dx;
        !           864:        int y_cost, x_cost, y_move, x_move;
        !           865:        int mode_cost;
        !           866:        int xi;
        !           867:        
        !           868:        if (cur_y == y && cur_x == x)
        !           869:                return;
        !           870:        
        !           871:        if (!has_mi || mode == Undefined)
        !           872:                set_mode(Normal);
        !           873:        if (!has_xs && ((!has_ms && so_mode != Off) || so_mode == Undefined))
        !           874:                standend();
        !           875:        
        !           876:        if (cur_y == Undefined || cur_x == Undefined)
        !           877:                goto absmove;
        !           878:        
        !           879:        dy = y - cur_y;
        !           880:        dx = x - cur_x;
        !           881: 
        !           882:        if (dy > 0) {
        !           883:                y_move = Down;
        !           884:                y_cost = dy * do_cost;
        !           885:        }
        !           886:        else if (dy < 0) {
        !           887:                y_move = Up;
        !           888:                y_cost = -dy * up_cost;
        !           889:        }
        !           890:        else {
        !           891:                y_move = None;
        !           892:                y_cost = 0;
        !           893:        }
        !           894:        if (y_cost < abs_cost) {
        !           895:                switch (mode) {
        !           896:                case Normal:
        !           897:                        mode_cost = 0;
        !           898:                        break;
        !           899:                case Insert:
        !           900:                        mode_cost = ei_cost;
        !           901:                        break;
        !           902:                case Delete:
        !           903:                        mode_cost = ed_cost;
        !           904:                        break;
        !           905:                }
        !           906:                if (dx > 0) {
        !           907:                        x_cost = dx + mode_cost;
        !           908:                        if (dx*nd_cost < x_cost || !rewrite_ok(y, cur_x, x)) {
        !           909:                                x_cost = dx * nd_cost;
        !           910:                                x_move = Right;
        !           911:                        }
        !           912:                        else
        !           913:                                x_move = ReWrite;
        !           914:                }
        !           915:                else if (dx < 0) {
        !           916:                        x_cost = -dx * le_cost;
        !           917:                        x_move = Left;
        !           918:                }
        !           919:                else {
        !           920:                        x_cost = 0;
        !           921:                        x_move = None;
        !           922:                }
        !           923:                if (cr_cost + x + mode_cost < x_cost && rewrite_ok(y, 0, x)) {
        !           924:                        x_move = CrWrite;
        !           925:                        x_cost = cr_cost + x + mode_cost;
        !           926:                }
        !           927:        }
        !           928:        else
        !           929:                x_cost = abs_cost;
        !           930: 
        !           931:        if (y_cost + x_cost < abs_cost) {
        !           932:                switch (y_move) {
        !           933:                case Down:
        !           934:                        while (dy-- > 0) Putstr(do_str);
        !           935:                        break;
        !           936:                case Up:
        !           937:                        while (dy++ < 0) Putstr(up_str);
        !           938:                        break;
        !           939:                }
        !           940:                switch (x_move) {
        !           941:                case Right:
        !           942:                        while (dx-- > 0) Putstr(nd_str);
        !           943:                        break;
        !           944:                case Left:
        !           945:                        while (dx++ < 0) Putstr(le_str);
        !           946:                        break;
        !           947:                case CrWrite:
        !           948:                        Putstr(cr_str);
        !           949:                        cur_x = 0;
        !           950:                        /* FALL THROUGH */
        !           951:                case ReWrite:
        !           952:                        set_mode(Normal);
        !           953:                        for (xi = cur_x; xi < x; xi++)
        !           954:                                putchar(line[y][xi]);
        !           955:                        break;
        !           956:                }
        !           957:        }
        !           958:        else
        !           959:        {
        !           960:     absmove:
        !           961:                if (cm_str == NULL) {
        !           962:                        Putstr(ho_str);
        !           963:                        for (cur_y = 0; cur_y < y; ++cur_y)
        !           964:                                Putstr(do_str);
        !           965:                        /* Should try to use tabs here: */
        !           966:                        for (cur_x = 0; cur_x < x; ++cur_x)
        !           967:                                Putstr(nd_str);
        !           968:                }
        !           969:                else
        !           970:                        Putstr(tgoto(cm_str, x, y));
        !           971:        }
        !           972:        
        !           973:        cur_y = y;
        !           974:        cur_x = x;
        !           975: }
        !           976: 
        !           977: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !           978: /* Putting data on the screen.                                              */
        !           979: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !           980: 
        !           981: /*
        !           982:  * Fill screen area with given data.
        !           983:  * Characters with the SO-bit (0200) set are put in standout mode.
        !           984:  */
        !           985: Visible Procedure
        !           986: trmputdata(yfirst, ylast, indent, data)
        !           987: int yfirst;
        !           988: int ylast;
        !           989: register int indent;
        !           990: register string data;
        !           991: {
        !           992:        register int y;
        !           993:        int x, len, lendata, space;
        !           994:                
        !           995: #ifdef TRACE
        !           996: fprintf(stderr, "\ttrmputdata(%d, %d, %d, \"%s\");\n", yfirst, ylast, indent, data);
        !           997: #endif
        !           998:        check_started("trmputdata");
        !           999:        
        !          1000:        if (yfirst < 0)
        !          1001:                yfirst = 0;
        !          1002:        if (ylast >= lines)
        !          1003:                ylast = lines-1;
        !          1004:        space = cols*(ylast-yfirst+1) - indent;
        !          1005:        if (space <= 0)
        !          1006:                return;
        !          1007:        yfirst += indent/cols;
        !          1008:        indent %= cols;
        !          1009:        if (data) {
        !          1010:                x = indent;
        !          1011:                lendata = strlen(data);
        !          1012:                if (ylast == lines-1 && lendata >= space)
        !          1013:                        lendata = space - 1;
        !          1014:                len = Min(lendata, cols-x);
        !          1015:                for (y = yfirst; y <= ylast; ) {
        !          1016:                        put_line(y, x, data, len);
        !          1017:                        y++;
        !          1018:                        lendata -= len;
        !          1019:                        if (lendata > 0) {
        !          1020:                                x = 0;
        !          1021:                                data += len;
        !          1022:                                len = Min(lendata, cols);
        !          1023:                        }
        !          1024:                        else
        !          1025:                                break;
        !          1026:                }
        !          1027:        }
        !          1028:        if (y <= ylast)
        !          1029:                clear_lines(y, ylast);
        !          1030: }
        !          1031: 
        !          1032: /* 
        !          1033:  * We will first try to get the picture:
        !          1034:  *
        !          1035:  *                  op>>>>>>>>>>>op          oq<<<<<<<<<<<<<<<<<<<<<<<<oq
        !          1036:  *                  ^            ^           ^                         ^
        !          1037:  *           <xskip><-----m1----><----od-----><-----------m2----------->
        !          1038:  *   OLD:   "You're in a maze of twisty little pieces of code, all alike"
        !          1039:  *   NEW:          "in a maze of little twisting pieces of code, all alike"
        !          1040:  *                  <-----m1----><-----nd------><-----------m2----------->
        !          1041:  *                  ^            ^             ^                         ^
        !          1042:  *                  np>>>>>>>>>>>np            nq<<<<<<<<<<<<<<<<<<<<<<<<nq
        !          1043:  * where
        !          1044:  *     op, oq, np, nq are pointers to start and end of Old and New data,
        !          1045:  * and
        !          1046:  *     xskip = length of indent to be skipped,
        !          1047:  *     m1 = length of Matching part at start,
        !          1048:  *     od = length of Differing mid on screen,
        !          1049:  *     nd = length of Differing mid in data to be put,
        !          1050:  *     m2 = length of Matching trail.
        !          1051:  *
        !          1052:  * Then we will try to find a long blank-or-cleared piece in <nd+m2>:
        !          1053:  *
        !          1054:  *    <---m1---><---d1---><---nb---><---d2---><---m2--->
        !          1055:  *              ^         ^         ^        ^         ^
        !          1056:  *              np        bp        bq1      nq        nend
        !          1057:  * where
        !          1058:  *     bp, bq are pointers to start and AFTER end of blank piece,
        !          1059:  * and
        !          1060:  *     d1 = length of differing part before blank piece,
        !          1061:  *     nb = length of blank piece to be skipped,
        !          1062:  *     d2 = length of differing part after blank piece.
        !          1063:  * Remarks:
        !          1064:  *     d1 + nb + d2 == nd,
        !          1065:  * and
        !          1066:  *     d2 maybe less than 0.
        !          1067:  */
        !          1068: Hidden int
        !          1069: put_line(y, xskip, data, len)
        !          1070: int y, xskip;
        !          1071: string data;
        !          1072: int len;
        !          1073: {
        !          1074:        register intlet *op, *oq;
        !          1075:        register char *np, *nq, *nend;
        !          1076:        char *bp, *bq1, *p, *q;
        !          1077:        int m1, m2, od, nd, delta, dd, d1, nb, d2;
        !          1078:        bool skipping;
        !          1079:        int cost, o_cost;       /* normal and optimising cost */
        !          1080:        
        !          1081:        /* calculate the magic parameters */
        !          1082:        op = &line[y][xskip];
        !          1083:        oq = &line[y][lenline[y]-1];
        !          1084:        np = data;
        !          1085:        nq = nend = data + len - 1;
        !          1086:        m1 = m2 = 0;
        !          1087:        while ((*op&SOCHAR) == (((intlet)*np)&SOCHAR) && op <= oq && np <= nq)
        !          1088:                op++, np++, m1++;
        !          1089:        if (flags & CAN_OPTIMISE)
        !          1090:                while ((*oq&SOCHAR) == (((intlet)*nq)&SOCHAR) && op <= oq && np <= nq)
        !          1091:                        oq--, nq--, m2++;
        !          1092:        od = oq - op + 1;
        !          1093:        nd = nq - np + 1;
        !          1094:        /* now we have the first picture above */
        !          1095: 
        !          1096:        if (od==0 && nd==0)
        !          1097:                return;
        !          1098:        delta = nd - od;
        !          1099: 
        !          1100:        /* find the blank piece */
        !          1101:        p = q = bp = bq1 = np;
        !          1102:        oq += m2;               /* back to current eol */
        !          1103:        if (!has_in) {
        !          1104:                while (p <= nend) {
        !          1105:                        while (q<=nend && *q==' ' && (op>oq || *op==' '))
        !          1106:                                q++, op++;
        !          1107:                        if (q - p > bq1 - bp)
        !          1108:                                bp = p, bq1 = q;
        !          1109:                        p = ++q;
        !          1110:                        op++;
        !          1111:                }
        !          1112:        }
        !          1113:        d1 = bp - np;
        !          1114:        nb = bq1 - bp;
        !          1115:        d2 = nq - bq1 + 1;
        !          1116:        
        !          1117:        /* what is cheapest:
        !          1118:         *      normal: put nd+m2;                         (dd = nd+m2)
        !          1119:         *      skipping: put d1, skip nb, put d2+m2;      (dd = d2+m2)
        !          1120:         *      optimise: put dd, insert or delete delta.  (dd = min(od,nd))
        !          1121:         */
        !          1122:        cost = nd + m2;         /* normal cost */
        !          1123:        if (nb > abs_cost || (d1 == 0 && nb > 0)) {
        !          1124:                skipping = Yes;
        !          1125:                cost -= nb - (d1>0 ? abs_cost : 0); /* skipping cost */
        !          1126:                dd = d2;
        !          1127:        }
        !          1128:        else {
        !          1129:                skipping = No;
        !          1130:                dd = nd;
        !          1131:        }
        !          1132:        
        !          1133:        if (m2 != 0) {
        !          1134:                /* try optimising */
        !          1135:                o_cost = Min(od, nd);
        !          1136:                if (delta > 0)
        !          1137:                        o_cost += delta * ins_mf + ins_oh;
        !          1138:                else if (delta < 0)
        !          1139:                        o_cost += -delta * del_mf + del_oh;
        !          1140:                if (o_cost >= cost) {
        !          1141:                        /* discard m2, no optimise */
        !          1142:                        dd += m2;
        !          1143:                        m2 = 0;
        !          1144:                }
        !          1145:                else {
        !          1146:                        dd = Min(od, nd);
        !          1147:                        skipping = No;
        !          1148:                }
        !          1149:        }
        !          1150: 
        !          1151:        /* and now for the real work */
        !          1152:        if (!skipping || d1 > 0)
        !          1153:                move(y, xskip + m1);
        !          1154: 
        !          1155:        if (has_xs)
        !          1156:                get_so_mode();
        !          1157:        
        !          1158:        if (skipping) {
        !          1159:                if (d1 > 0) {
        !          1160:                        set_mode(Normal);
        !          1161:                        put_str(np, d1, No);
        !          1162:                }
        !          1163:                if (has_xs && so_mode != Off)
        !          1164:                        standend();
        !          1165:                set_blanks(y, xskip+m1+d1, xskip+m1+d1+nb);
        !          1166:                if (dd != 0 || delta < 0) {
        !          1167:                        move(y, xskip+m1+d1+nb);
        !          1168:                        np = bq1;
        !          1169:                }
        !          1170:        }
        !          1171:        
        !          1172:        if (dd > 0) {
        !          1173:                set_mode(Normal);
        !          1174:                put_str(np, dd, No);
        !          1175:        }
        !          1176:        
        !          1177:        if (m2 > 0) {
        !          1178:                if (delta > 0) {
        !          1179:                        set_mode(Insert);
        !          1180:                        ins_str(np+dd, delta);
        !          1181:                }
        !          1182:                else if (delta < 0) {
        !          1183:                        set_mode(Delete);
        !          1184:                        del_str(-delta);
        !          1185:                }
        !          1186:        }
        !          1187:        else {
        !          1188:                if (delta < 0) {
        !          1189:                        clr_to_eol();
        !          1190:                        return;
        !          1191:                }
        !          1192:        }
        !          1193:        
        !          1194:        lenline[y] = xskip + len;
        !          1195:        if (cur_x == cols) {
        !          1196:                if (!has_mi)
        !          1197:                        set_mode(Normal);
        !          1198:                if (!has_ms)
        !          1199:                        so_mode = Undefined;
        !          1200:                if (has_am)
        !          1201:                        cur_y++;
        !          1202:                else
        !          1203:                        Putstr(cr_str);
        !          1204:                cur_x = 0;
        !          1205:        }
        !          1206:        else if (has_xs) {
        !          1207:                if (m2 == 0) {
        !          1208:                        if (so_mode == On)
        !          1209:                                standend();
        !          1210:                }
        !          1211:                else {
        !          1212:                        if (!(line[cur_y][cur_x] & XSBIT)) {
        !          1213:                                if (so_mode != (line[cur_y][cur_x] & SOBIT))
        !          1214:                                        (so_mode ? standend() : standout());
        !          1215:                        }
        !          1216:                }
        !          1217:        }
        !          1218: }
        !          1219: 
        !          1220: Hidden Procedure
        !          1221: set_mode(m)
        !          1222: int m;
        !          1223: {
        !          1224:        if (m == mode)
        !          1225:                return;
        !          1226:        switch (mode) {
        !          1227:        case Insert:
        !          1228:                Putstr(ei_str);
        !          1229:                break;
        !          1230:        case Delete:
        !          1231:                Putstr(ed_str);
        !          1232:                break;
        !          1233:        case Undefined:
        !          1234:                Putstr(ei_str);
        !          1235:                Putstr(ed_str);
        !          1236:                break;
        !          1237:        }
        !          1238:        switch (m) {
        !          1239:        case Insert:
        !          1240:                Putstr(im_str);
        !          1241:                break;
        !          1242:        case Delete:
        !          1243:                Putstr(dm_str);
        !          1244:                break;
        !          1245:        }
        !          1246:        mode = m;
        !          1247: }
        !          1248: 
        !          1249: Hidden Procedure
        !          1250: get_so_mode()
        !          1251: {
        !          1252:        if (cur_x >= lenline[cur_y] || line[cur_y][cur_x] == UNKNOWN)
        !          1253:                so_mode = Off;
        !          1254:        else
        !          1255:                so_mode = line[cur_y][cur_x] & SOBIT;
        !          1256: }
        !          1257: 
        !          1258: Hidden Procedure
        !          1259: standout()
        !          1260: {
        !          1261:        Putstr(so_str);
        !          1262:        so_mode = On;
        !          1263:        if (has_xs)
        !          1264:                line[cur_y][cur_x] |= SOCOOK;
        !          1265: }
        !          1266: 
        !          1267: Hidden Procedure
        !          1268: standend()
        !          1269: {
        !          1270:        Putstr(se_str);
        !          1271:        so_mode = Off;
        !          1272:        if (has_xs)
        !          1273:                line[cur_y][cur_x] = (line[cur_y][cur_x] & ~SOBIT) | XSBIT;
        !          1274: }
        !          1275: 
        !          1276: Hidden Procedure
        !          1277: put_str(data, n, inserting)
        !          1278: char *data;
        !          1279: int n;
        !          1280: bool inserting;
        !          1281: {
        !          1282:        register intlet c, so;
        !          1283:        intlet *ln_y_x, *ln_y_end;
        !          1284:        
        !          1285:        so = so_mode;
        !          1286:        if (has_xs) {
        !          1287:                ln_y_x = &line[cur_y][cur_x];
        !          1288:                ln_y_end = &line[cur_y][lenline[cur_y]];
        !          1289:        }
        !          1290:        while (n-- > 0) {
        !          1291:                if (has_xs && ln_y_x <= ln_y_end && ((*ln_y_x)&XSBIT))
        !          1292:                        so = so_mode = (*ln_y_x)&SOBIT;
        !          1293:                        /* this also checks for the standend cookie AFTER */
        !          1294:                        /* the line because off the equals sign in <= */
        !          1295:                c = ((intlet)(*data++))&SOCHAR;
        !          1296:                if ((c&SOBIT) != so) {
        !          1297:                        so = c&SOBIT;
        !          1298:                        so ? standout() : standend();
        !          1299:                }
        !          1300:                if (inserting)
        !          1301:                        Putstr(ic_str);
        !          1302:                put_c(c);
        !          1303:                if (has_xs)
        !          1304:                        ln_y_x++;
        !          1305:        }
        !          1306: }
        !          1307: 
        !          1308: Hidden Procedure
        !          1309: ins_str(data, n)
        !          1310: char *data;
        !          1311: int n;
        !          1312: {
        !          1313:        int x;
        !          1314:        
        !          1315:        /* x will start AFTER the line, because there might be a cookie */
        !          1316:        for (x = lenline[cur_y]; x >= cur_x; x--)
        !          1317:                line[cur_y][x+n] = line[cur_y][x];
        !          1318:        put_str(data, n, Yes);
        !          1319: }
        !          1320: 
        !          1321: Hidden Procedure
        !          1322: del_str(n)
        !          1323: int n;
        !          1324: {
        !          1325:        int x, xto;
        !          1326:        
        !          1327:        xto = lenline[cur_y] - n; /* again one too far because of cookie */
        !          1328:        if (has_xs) {
        !          1329:                for (x = cur_x + n; x >= cur_x; x--) {
        !          1330:                        if (line[cur_y][x] & XSBIT)
        !          1331:                                break;
        !          1332:                }
        !          1333:                if (x >= cur_x)
        !          1334:                        line[cur_y][cur_x+n] =
        !          1335:                                (line[cur_y][cur_x+n] & CHAR)
        !          1336:                                |
        !          1337:                                (line[cur_y][x] & COOKBITS);
        !          1338:        }
        !          1339:        for (x = cur_x; x <= xto; x++)
        !          1340:                line[cur_y][x] = line[cur_y][x+n];
        !          1341:        while (n-- > 0)
        !          1342:                Putstr(dc_str);
        !          1343: }
        !          1344: 
        !          1345: Hidden Procedure
        !          1346: put_c(c)
        !          1347: intlet c;
        !          1348: {
        !          1349:        char ch;
        !          1350:        intlet xs_flag;
        !          1351:        
        !          1352:        ch = c&CHAR;
        !          1353:        if (!isprint(ch) && ch != ' ') { /* V7 isprint doesn't include blank */
        !          1354:                ch = '?';
        !          1355:                c = (c&SOBIT)|'?';
        !          1356:        }
        !          1357:        putchar(ch);
        !          1358:        if (has_xs)
        !          1359:                xs_flag = line[cur_y][cur_x]&XSBIT;
        !          1360:        else
        !          1361:                xs_flag = 0;
        !          1362:        line[cur_y][cur_x] = (c&SOCHAR)|xs_flag;
        !          1363:        cur_x++;
        !          1364: }
        !          1365: 
        !          1366: Hidden Procedure
        !          1367: clear_lines(yfirst, ylast)
        !          1368: int yfirst, ylast ;
        !          1369: {
        !          1370:        register int y;
        !          1371:        
        !          1372:        if (!has_xs && so_mode != Off)
        !          1373:                standend();
        !          1374:        if (cl_str && yfirst == 0 && ylast == lines-1) {
        !          1375:                Putstr(cl_str);
        !          1376:                cur_y = cur_x = 0;
        !          1377:                return;
        !          1378:        }
        !          1379:        for (y = yfirst; y <= ylast; y++) {
        !          1380:                if (lenline[y] > 0) {
        !          1381:                        move(y, 0);
        !          1382:                        if (ylast == lines-1 && cd_str) {
        !          1383:                                Putstr(cd_str);
        !          1384:                                while (y <= ylast) {
        !          1385:                                        if (has_xs) line[y][0] = NOCOOK;
        !          1386:                                        lenline[y++] = 0;
        !          1387:                                }
        !          1388:                                break;
        !          1389:                        }
        !          1390:                        else {
        !          1391:                                clr_to_eol();
        !          1392:                        }
        !          1393:                }
        !          1394:        }
        !          1395: }
        !          1396: 
        !          1397: Hidden Procedure
        !          1398: clr_to_eol()
        !          1399: {
        !          1400:        lenline[cur_y] = cur_x;
        !          1401:        if (!has_xs && so_mode != Off)
        !          1402:                standend();
        !          1403:        Putstr(ce_str);
        !          1404:        if (has_xs) {
        !          1405:                if (cur_x == 0)
        !          1406:                        line[cur_y][0] = NOCOOK;
        !          1407:                else if (line[cur_y][cur_x-1]&SOBIT)
        !          1408:                        standend();
        !          1409:        }
        !          1410: }
        !          1411: 
        !          1412: Hidden Procedure
        !          1413: set_blanks
        !          1414: (y, xfrom, xto)
        !          1415: int y, xfrom, xto;
        !          1416: {
        !          1417:        register int x;
        !          1418:        
        !          1419:        for (x = xfrom; x < xto; x++) {
        !          1420:                line[y][x] = (line[y][x]&XSBIT) | ' ';
        !          1421:        }
        !          1422: }
        !          1423: 
        !          1424: /* 
        !          1425:  * outchar() is used by termcap's tputs;
        !          1426:  * we can't use putchar because that's probably a macro
        !          1427:  */
        !          1428: Hidden int
        !          1429: outchar(ch)
        !          1430: char ch;
        !          1431: {
        !          1432:        putchar(ch);
        !          1433: }
        !          1434: 
        !          1435: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !          1436: /* Scrolling (part of) the screen up (or down, dy<0).                       */
        !          1437: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !          1438: 
        !          1439: Visible Procedure
        !          1440: trmscrollup(yfirst, ylast, by)
        !          1441: register int yfirst;
        !          1442: register int ylast;
        !          1443: register int by;
        !          1444: {
        !          1445: #ifdef TRACE
        !          1446: fprintf(stderr, "\ttrmscrollup(%d, %d, %d);\n", yfirst, ylast, by);
        !          1447: #endif
        !          1448:        check_started("trmscrollup");
        !          1449:        
        !          1450:        if (yfirst < 0)
        !          1451:                yfirst = 0;
        !          1452:        if (ylast >= lines)
        !          1453:                ylast = lines-1;
        !          1454: 
        !          1455:        if (yfirst > ylast)
        !          1456:                return;
        !          1457: 
        !          1458:        if (!has_xs && so_mode != Off)
        !          1459:                standend();
        !          1460:        
        !          1461:        if (by > 0 && yfirst + by > ylast
        !          1462:            ||
        !          1463:            by < 0 && yfirst - by > ylast)
        !          1464:        {
        !          1465:                clear_lines(yfirst, ylast);
        !          1466:                return;
        !          1467:        }
        !          1468:        
        !          1469:        if (by > 0) {
        !          1470:                (*scr_up)(yfirst, ylast, by);
        !          1471:                scr_lines(yfirst, ylast, by, 1);
        !          1472:        }
        !          1473:        else if (by < 0) {
        !          1474:                (*scr_down)(yfirst, ylast, -by);
        !          1475:                scr_lines(ylast, yfirst, -by, -1);
        !          1476:        }
        !          1477: }
        !          1478: 
        !          1479: Hidden Procedure
        !          1480: scr_lines(yfrom, yto, n, dy)
        !          1481: int yfrom, yto, n, dy;
        !          1482: {
        !          1483:        register int y;
        !          1484:        intlet *saveln;
        !          1485:        
        !          1486:        while (n-- > 0) {
        !          1487:                saveln = line[yfrom];
        !          1488:                for (y = yfrom; y != yto; y += dy) {
        !          1489:                        line[y] = line[y+dy];
        !          1490:                        lenline[y] = lenline[y+dy];
        !          1491:                }
        !          1492:                line[yto] = saveln;
        !          1493:                lenline[yto] = 0;
        !          1494:                if (has_xs) line[yto][0] = NOCOOK;
        !          1495:        }
        !          1496: }
        !          1497: 
        !          1498: Hidden Procedure
        !          1499: scr1up(yfirst, ylast, n)
        !          1500:        int yfirst;
        !          1501:        int ylast;
        !          1502:        int n;
        !          1503: {
        !          1504:        move(yfirst, 0);
        !          1505:        dellines(n);
        !          1506:        if (ylast < lines-1) {
        !          1507:                move(ylast-n+1, 0);
        !          1508:                addlines(n);
        !          1509:        }
        !          1510: }
        !          1511: 
        !          1512: Hidden Procedure
        !          1513: scr1down(yfirst, ylast, n)
        !          1514:        int yfirst;
        !          1515:        int ylast;
        !          1516:        int n;
        !          1517: {
        !          1518:        if (ylast == lines-1) {
        !          1519:                clear_lines(ylast-n+1, ylast);
        !          1520:        }
        !          1521:        else {
        !          1522:                move(ylast-n+1, 0);
        !          1523:                dellines(n);
        !          1524:        }
        !          1525:        move(yfirst, 0);
        !          1526:        addlines(n);
        !          1527: }
        !          1528: 
        !          1529: Hidden Procedure
        !          1530: addlines(n)
        !          1531: register int n;
        !          1532: {
        !          1533:        if (par_al_str && n > 1)
        !          1534:                        Putstr(tgoto(par_al_str, n, n));
        !          1535:        else {
        !          1536:                while (n-- > 0)
        !          1537:                        Putstr(al_str);
        !          1538:        }
        !          1539: }
        !          1540: 
        !          1541: Hidden Procedure
        !          1542: dellines(n)
        !          1543: register int n;
        !          1544: {
        !          1545:        if (par_dl_str && n > 1)
        !          1546:                Putstr(tgoto(par_dl_str, n, n));
        !          1547:        else {
        !          1548:                while (n-- > 0)
        !          1549:                        Putstr(dl_str);
        !          1550:        }
        !          1551: }
        !          1552: 
        !          1553: Hidden Procedure
        !          1554: scr2up(yfirst, ylast, n)
        !          1555: int yfirst, ylast, n;
        !          1556: {
        !          1557:        Putstr(tgoto(cs_str, ylast, yfirst));
        !          1558:        cur_y = cur_x = Undefined;
        !          1559:        move(ylast, 0);
        !          1560:        while (n-- > 0) {
        !          1561:                Putstr(sf_str);
        !          1562:                if (has_db && ylast == lines-1)
        !          1563:                        clr_to_eol();
        !          1564:        }
        !          1565:        Putstr(tgoto(cs_str, lines-1, 0));
        !          1566:        cur_y = cur_x = Undefined;
        !          1567: }
        !          1568: 
        !          1569: Hidden Procedure
        !          1570: scr2down(yfirst, ylast, n)
        !          1571: int yfirst, ylast, n;
        !          1572: {
        !          1573:        Putstr(tgoto(cs_str, ylast, yfirst));
        !          1574:        cur_y = cur_x = Undefined;
        !          1575:        move(yfirst, 0);
        !          1576:        while (n-- > 0) {
        !          1577:                Putstr(sr_str);
        !          1578:                if (has_da && yfirst == 0)
        !          1579:                        clr_to_eol();
        !          1580:        }
        !          1581:        Putstr(tgoto(cs_str, lines-1, 0));
        !          1582:        cur_y = cur_x = Undefined;
        !          1583: }
        !          1584: 
        !          1585: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !          1586: /* Synchronization, move cursor to given position (or previous if < 0).     */
        !          1587: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !          1588: 
        !          1589: Visible Procedure
        !          1590: trmsync(y, x)
        !          1591:        int y;
        !          1592:        int x;
        !          1593: {
        !          1594: #ifdef TRACE
        !          1595: fprintf(stderr, "\ttrmsync(%d, %d);\n", y, x);
        !          1596: #endif
        !          1597:        check_started("trmsync");
        !          1598:        
        !          1599:        if (0 <= y && y < lines && 0 <= x && x < cols) {
        !          1600:                move(y, x);
        !          1601:                if (no_cursor) {
        !          1602:                        Putstr(ve_str);
        !          1603:                        no_cursor = No;
        !          1604:                }
        !          1605:        }
        !          1606:        else if (no_cursor == No) {
        !          1607:                Putstr(vi_str);
        !          1608:                no_cursor = Yes;
        !          1609:        }
        !          1610:        VOID fflush(stdout);
        !          1611: }
        !          1612: 
        !          1613: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !          1614: /* Send a bell, visible if possible.                                        */
        !          1615: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !          1616: 
        !          1617: Visible Procedure
        !          1618: trmbell()
        !          1619: {
        !          1620: #ifdef TRACE
        !          1621: fprintf(stderr, "\ttrmbell();\n");
        !          1622: #endif
        !          1623:        check_started("trmbell");
        !          1624:        
        !          1625:        Putstr(vb_str);
        !          1626:        VOID fflush(stdout);
        !          1627: }
        !          1628: 
        !          1629: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !          1630: /* Show the current internal statuses of the screen on stderr.              */
        !          1631: /* For debugging only.                                                      */
        !          1632: /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
        !          1633: 
        !          1634: #ifdef SHOW
        !          1635: Visible Procedure
        !          1636: trmshow(s)
        !          1637: char *s;
        !          1638: {
        !          1639:        int y, x;
        !          1640:        
        !          1641:        fprintf(stderr, "<<< %s >>>\n", s);
        !          1642:        for (y = 0; y < lines; y++) {
        !          1643:                for (x = 0; x <= lenline[y] /*** && x < cols-1 ***/ ; x++) {
        !          1644:                        fputc(line[y][x]&CHAR, stderr);
        !          1645:                }
        !          1646:                fputc('\n', stderr);
        !          1647:                for (x = 0; x <= lenline[y] && x < cols-1; x++) {
        !          1648:                        if (line[y][x]&SOBIT)
        !          1649:                                fputc('-', stderr);
        !          1650:                        else
        !          1651:                                fputc(' ', stderr);
        !          1652:                }
        !          1653:                fputc('\n', stderr);
        !          1654:                for (x = 0; x <= lenline[y] && x < cols-1; x++) {
        !          1655:                        if (line[y][x]&XSBIT)
        !          1656:                                fputc('+', stderr);
        !          1657:                        else
        !          1658:                                fputc(' ', stderr);
        !          1659:                }
        !          1660:                fputc('\n', stderr);
        !          1661:        }
        !          1662:        fprintf(stderr, "CUR_Y = %d, CUR_X = %d.\n", cur_y, cur_x);
        !          1663:        VOID fflush(stderr);
        !          1664: }
        !          1665: #endif

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