home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / VILE327.ZIP / VILE327.TAR / vile3.27 / display.c < prev    next >
C/C++ Source or Header  |  1992-12-14  |  43KB  |  2,143 lines
  1. /*
  2.  * The functions in this file handle redisplay. There are two halves, the
  3.  * ones that update the virtual display screen, and the ones that make the
  4.  * physical display screen the same as the virtual display screen. These
  5.  * functions use hints that are left in the windows by the commands.
  6.  *
  7.  *
  8.  * $Log: display.c,v $
  9.  * Revision 1.54  1992/12/04  09:12:25  foxharp
  10.  * deleted unused assigns
  11.  *
  12.  * Revision 1.53  1992/08/20  23:40:48  foxharp
  13.  * typo fixes -- thanks, eric
  14.  *
  15.  * Revision 1.52  1992/08/05  21:55:16  foxharp
  16.  * handle files with DOS drive designators properly on mode line
  17.  *
  18.  * Revision 1.51  1992/07/24  07:49:38  foxharp
  19.  * shorten_name changes
  20.  *
  21.  * Revision 1.50  1992/07/22  19:25:57  foxharp
  22.  * handle non-printables correctly -- how did I get involved in this, anyway!
  23.  *
  24.  * Revision 1.49  1992/07/22  09:18:16  foxharp
  25.  * got it.  sheesh.
  26.  *
  27.  * Revision 1.48  1992/07/22  00:50:43  foxharp
  28.  * interim -- still dumping core in vtset
  29.  *
  30.  * Revision 1.47  1992/07/21  09:08:30  foxharp
  31.  * now pass lp to vtset()
  32.  *
  33.  * Revision 1.46  1992/07/21  08:57:53  foxharp
  34.  * pushed list mode choice into vtset()
  35.  *
  36.  * Revision 1.45  1992/07/20  22:44:44  foxharp
  37.  * performance improvements -- fewer vtputc's
  38.  *
  39.  * Revision 1.44  1992/07/18  13:13:56  foxharp
  40.  * put all path-shortening in one place (shorten_path()), and took out
  41.  * some old code now unnecessary
  42.  *
  43.  * Revision 1.43  1992/07/13  20:03:54  foxharp
  44.  * the "terse" variable is now a boolean mode
  45.  *
  46.  * Revision 1.42  1992/07/13  19:37:00  foxharp
  47.  * trim leading `pwd` from filenames in modeline, now that filenames are
  48.  * usually absolute
  49.  *
  50.  * Revision 1.41  1992/07/01  16:59:46  foxharp
  51.  * scwrite() arg changes, and some fore/background color cleanup
  52.  *
  53.  * Revision 1.40  1992/06/26  22:21:05  foxharp
  54.  * small almost cosmetic changes to mlsav'ing
  55.  *
  56.  * Revision 1.39  1992/05/29  08:36:06  foxharp
  57.  * moved the SVR3_PTEM ifdef so it works with POSIX too
  58.  *
  59.  * Revision 1.38  1992/05/19  08:55:44  foxharp
  60.  * more prototype and shadowed decl fixups
  61.  *
  62.  * Revision 1.37  1992/05/16  12:00:31  pgf
  63.  * prototypes/ansi/void-int stuff/microsoftC
  64.  *
  65.  * Revision 1.36  1992/04/27  19:50:43  pgf
  66.  * fixed ifdefs on termio inclusion
  67.  *
  68.  * Revision 1.35  1992/04/14  08:50:01  pgf
  69.  * fix SIGWINCH handling for X11 case
  70.  *
  71.  * Revision 1.34  1992/03/25  19:13:17  pgf
  72.  * BSD portability changes
  73.  *
  74.  * Revision 1.33  1992/03/19  23:31:54  pgf
  75.  * mlputc now converts tabs to single spaces, since we don't really
  76.  * know how wide they should be anyway
  77.  *
  78.  * Revision 1.32  1992/03/19  23:13:04  pgf
  79.  * SIGT for signals
  80.  *
  81.  * Revision 1.31  1992/03/07  10:21:29  pgf
  82.  * suppress prompts (mlprompt()) if execing buff or file
  83.  *
  84.  * Revision 1.30  1992/03/05  09:17:21  pgf
  85.  * added support for new "terse" variable, to control unnecessary messages
  86.  *
  87.  * Revision 1.29  1992/03/01  18:38:40  pgf
  88.  * compilation error #if COLOR
  89.  *
  90.  * Revision 1.28  1992/02/17  08:57:36  pgf
  91.  * added "showmode" support
  92.  *
  93.  * Revision 1.27  1992/01/22  20:26:00  pgf
  94.  * fixed ifdef conflict: SVR3_PTEM
  95.  *
  96.  * Revision 1.26  1992/01/05  00:05:24  pgf
  97.  * split mlwrite into mlwrite/mlprompt/mlforce to make errors visible more
  98.  * often.  also normalized message appearance somewhat.
  99.  *
  100.  * Revision 1.25  1991/11/13  20:09:27  pgf
  101.  * X11 changes, from dave lemke
  102.  *
  103.  * Revision 1.24  1991/11/08  13:14:40  pgf
  104.  * more lint
  105.  *
  106.  * Revision 1.23  1991/11/07  03:58:31  pgf
  107.  * lint cleanup
  108.  *
  109.  * Revision 1.22  1991/11/03  17:35:06  pgf
  110.  * don't access unset vt column 80 if screen isn't that wide
  111.  *
  112.  * Revision 1.21  1991/11/01  14:38:00  pgf
  113.  * saber cleanup
  114.  *
  115.  * Revision 1.20  1991/10/28  14:22:46  pgf
  116.  * no more TABVAL macro, curtabstopval renamed curtabval
  117.  *
  118.  * Revision 1.19  1991/10/26  00:14:56  pgf
  119.  * put termio.h back in, and switch to SVR3 around ptem.h
  120.  *
  121.  * Revision 1.18  1991/10/23  12:05:37  pgf
  122.  * we don't need termio.h
  123.  *
  124.  * Revision 1.17  1991/10/08  01:28:43  pgf
  125.  * dbgwrite now uses raw'est i/o
  126.  *
  127.  * Revision 1.16  1991/09/26  13:16:19  pgf
  128.  * LIST mode and w_sideways are now both window values
  129.  *
  130.  * Revision 1.15  1991/09/11  02:30:22  pgf
  131.  * use get_recorded_char, now that we have it
  132.  *
  133.  * Revision 1.14  1991/08/16  11:10:46  pgf
  134.  * added insert mode indicator to modeline: I for insert, O for overwrite, and
  135.  * R for replace-char
  136.  *
  137.  * Revision 1.13  1991/08/07  12:35:07  pgf
  138.  * added RCS log messages
  139.  *
  140.  * revision 1.12
  141.  * date: 1991/08/06 15:12:29;
  142.  * global/local values, and printf/list changes
  143.  * 
  144.  * revision 1.11
  145.  * date: 1991/06/28 10:53:18;
  146.  * make update quit early if !curbp
  147.  * 
  148.  * revision 1.10
  149.  * date: 1991/06/25 19:52:13;
  150.  * massive data structure restructure
  151.  * 
  152.  * revision 1.9
  153.  * date: 1991/06/16 17:34:57;
  154.  * switched to modulo tab calculations
  155.  * 
  156.  * revision 1.8
  157.  * date: 1991/05/31 10:35:55;
  158.  * added new "dbgwrite()" routine, for debugging
  159.  * 
  160.  * revision 1.7
  161.  * date: 1991/04/22 09:04:14;
  162.  * more ODT support
  163.  * 
  164.  * revision 1.6
  165.  * date: 1991/03/19 12:15:08;
  166.  * fix flag checking
  167.  * 
  168.  * revision 1.5
  169.  * date: 1991/02/21 10:04:01;
  170.  * horizontal scrolling is most of the way there.  only thing
  171.  * left to do is to extend lines where the cursor is beyond the
  172.  * left edge of a scrolled screen
  173.  * 
  174.  * revision 1.4
  175.  * date: 1990/10/05 14:19:31;
  176.  * fixed typo in ODT ifdef.
  177.  * propagated mode line changes to all windows holding a given buffer
  178.  * 
  179.  * revision 1.3
  180.  * date: 1990/10/01 11:04:42;
  181.  * atatus return in newscreensize
  182.  * 
  183.  * revision 1.2
  184.  * date: 1990/09/25 11:38:06;
  185.  * took out old ifdef BEFORE code
  186.  * 
  187.  * revision 1.1
  188.  * date: 1990/09/21 10:24:58;
  189.  * initial vile RCS revision
  190.  */
  191.  
  192.  
  193. #include    "estruct.h"
  194. #include        "edef.h"
  195. #if UNIX
  196. # include <signal.h>
  197. # if POSIX
  198. #  include <termios.h>
  199. # else
  200. #  if USG
  201. #   include <termio.h>
  202. #  else
  203. #   if BERK
  204. #    include "ioctl.h"
  205. #   endif
  206. #  endif
  207. # endif
  208. # if SVR3_PTEM
  209. #  include <sys/types.h>
  210. #  include <sys/stream.h>
  211. #  include <sys/ptem.h>
  212. # endif
  213. #endif
  214.  
  215.  
  216. VIDEO   **vscreen;                      /* Virtual screen. */
  217. #if    ! MEMMAP
  218. VIDEO   **pscreen;                      /* Physical screen. */
  219. #endif
  220.  
  221.  
  222. int displaying = FALSE;
  223. /* for window size changes */
  224. int chg_width, chg_height;
  225.  
  226. /*
  227.  * Initialize the data structures used by the display code. The edge vectors
  228.  * used to access the screens are set up. The operating system's terminal I/O
  229.  * channel is set up. All the other things get initialized at compile time.
  230.  * The original window has "WFCHG" set, so that it will get completely
  231.  * redrawn on the first call to "update".
  232.  */
  233. void
  234. vtinit()
  235. {
  236.     register int i;
  237.     register VIDEO *vp;
  238.  
  239.     TTopen();        /* open the screen */
  240.     TTkopen();        /* open the keyboard */
  241.     TTrev(FALSE);
  242.     vscreen = (VIDEO **) malloc(term.t_mrow*sizeof(VIDEO *));
  243.  
  244.     if (vscreen == NULL)
  245.         exit(1);
  246.  
  247.  
  248. #if    ! MEMMAP
  249.     pscreen = (VIDEO **) malloc(term.t_mrow*sizeof(VIDEO *));
  250.  
  251.     if (pscreen == NULL)
  252.         exit(1);
  253. #endif
  254.  
  255.     for (i = 0; i < term.t_mrow; ++i) {
  256.         /* struct VIDEO already has 4 of the bytes */
  257.         vp = (VIDEO *) malloc(sizeof(struct VIDEO) + term.t_mcol - 4);
  258.  
  259.         if (vp == NULL)
  260.             exit(1);
  261.  
  262.  
  263.     /* unnecessary */
  264.     /* (void)memset(vp, ' ', sizeof(struct VIDEO) + term.t_mcol - 4); */
  265.     vp->v_flag = 0;
  266. #if    COLOR
  267.     vp->v_rfcolor = gfcolor;
  268.     vp->v_rbcolor = gbcolor;
  269. #endif
  270.         vscreen[i] = vp;
  271. #if    ! MEMMAP
  272.         /* struct VIDEO already has 4 of the bytes */
  273.         vp = (VIDEO *) malloc(sizeof(struct VIDEO) + term.t_mcol - 4);
  274.  
  275.         if (vp == NULL)
  276.             exit(1);
  277.  
  278.     /* unnecessary */
  279.     /* (void)memset(vp, 0, sizeof(struct VIDEO) + term.t_mcol - 4); */
  280.  
  281.     vp->v_flag = 0;
  282.         pscreen[i] = vp;
  283. #endif
  284.         }
  285. }
  286.  
  287. /*
  288.  * Clean up the virtual terminal system, in anticipation for a return to the
  289.  * operating system. Move down to the last line and advance, to make room
  290.  * for the system prompt. Shut down the channel to the
  291.  * terminal.
  292.  */
  293. void
  294. vttidy(f)
  295. int f;
  296. {
  297.     ttclean(f);    /* does it all now */
  298. }
  299.  
  300. /*
  301.  * Set the virtual cursor to the specified row and column on the virtual
  302.  * screen. There is no checking for nonsense values.
  303.  */
  304. void
  305. vtmove(row, col)
  306. int row,col;
  307. {
  308.     vtrow = row;
  309.     vtcol = col;
  310. }
  311.  
  312. /* Write a character to the virtual screen. The virtual row and
  313.    column are updated. If we are not yet on left edge, don't print
  314.    it yet. If the line is too long put a ">" in the last column.
  315.    This routine only puts printing characters into the virtual
  316.    terminal buffers. Only column overflow is checked.
  317. */
  318.  
  319. void
  320. vtputc(c)
  321. int c;
  322. {
  323.     register VIDEO *vp;    /* ptr to line being updated */
  324.  
  325.     vp = vscreen[vtrow];
  326.  
  327.     if (isprint(c) && vtcol >= 0 && vtcol < term.t_ncol) {
  328.         vp->v_text[vtcol] = c;
  329.         ++vtcol;
  330.         return;
  331.     }
  332.     if (c == '\t') {
  333.         do {
  334.             vtputc(' ');
  335.         } while (((vtcol + taboff)%curtabval) != 0);
  336.     } else if (c == '\n') {
  337.         return;
  338.     } else if (vtcol >= term.t_ncol) {
  339.         ++vtcol;
  340.         vp->v_text[term.t_ncol - 1] = '>';
  341.     } else if (isprint(c)) {
  342.         ++vtcol;
  343.     } else {
  344.         vtputc('^');
  345.         vtputc(toalpha(c));
  346.     }
  347. }
  348.  
  349. /* as above, but tabs and newlines are made visible */
  350. void
  351. vtlistc(c)
  352. int c;
  353. {
  354.     register VIDEO *vp;    /* ptr to line being updated */
  355.  
  356.     vp = vscreen[vtrow];
  357.  
  358.     if (vtcol >= term.t_ncol) {
  359.         ++vtcol;
  360.         vp->v_text[term.t_ncol - 1] = '>';
  361.     } else if (isprint(c)) {
  362.         if (vtcol >= 0)
  363.             vp->v_text[vtcol] = c;
  364.         ++vtcol;
  365.     } else {
  366.         vtputc('^');
  367.         vtputc(toalpha(c));
  368.     }
  369. }
  370.  
  371. int
  372. vtgetc(col)
  373. int col;
  374. {
  375.     return vscreen[vtrow]->v_text[col];
  376. }
  377.  
  378. void
  379. vtputsn(s,n)
  380. char *s;
  381. int n;
  382. {
  383.     int c;
  384.     while (n-- && (c = *s++) != 0)
  385.         vtputc(c);
  386. }
  387.  
  388.  
  389. void
  390. vtset(lp,wp)
  391. LINE *lp;
  392. WINDOW *wp;
  393. {
  394.     register char *from;
  395.     register int n;
  396.  
  397.     from = lp->l_text;
  398.     n = llength(lp);
  399.  
  400.     if (w_val(wp,WMDLIST)) {
  401.         while (vtcol <= term.t_ncol && n)
  402.             vtlistc(*from++), n--;
  403.         if (!n)
  404.             vtlistc('\n');
  405.     } else {
  406.         while (vtcol <= term.t_ncol && n)
  407.             vtputc(*from++), n--;
  408.     }
  409. }
  410.  
  411. /* VARARGS1 */
  412. void
  413. #ifdef __STDC__
  414. vtprintf( char *fmt, ...)
  415. #else
  416. vtprintf(va_alist)
  417. va_dcl
  418. #endif
  419. {
  420.  
  421.     va_list ap;
  422. #ifdef __STDC__
  423.     va_start(ap,fmt);
  424. #else
  425.     va_start(ap);
  426. #endif
  427.  
  428.     dfoutfn = vtputc;
  429.  
  430. #ifdef __STDC__
  431.     dofmt(fmt,&ap);
  432. #else
  433.     dofmt(&ap);
  434. #endif
  435.     va_end(ap);
  436.  
  437. } 
  438.  
  439. /*
  440.  * Erase from the end of the software cursor to the end of the line on which
  441.  * the software cursor is located.
  442.  */
  443. void
  444. vteeol()
  445. {
  446.     if (vtcol < term.t_ncol) {
  447.         (void)memset(&vscreen[vtrow]->v_text[vtcol],
  448.             ' ', term.t_ncol-vtcol);
  449.         vtcol = term.t_ncol;
  450.     }
  451. }
  452.  
  453. /* upscreen:    user routine to force a screen update
  454.         always finishes complete update        */
  455. /* ARGSUSED */
  456. int
  457. upscreen(f, n)
  458. int f,n;
  459. {
  460.     update(TRUE);
  461.     return(TRUE);
  462. }
  463.  
  464. int scrflags;
  465. /*
  466.  * Make sure that the display is right. This is a three part process. First,
  467.  * scan through all of the windows looking for dirty ones. Check the framing,
  468.  * and refresh the screen. Second, make sure that "currow" and "curcol" are
  469.  * correct for the current window. Third, make the virtual and physical
  470.  * screens the same.
  471.  */
  472. int
  473. update(force)
  474. int force;    /* force update past type ahead? */
  475. {
  476.     register WINDOW *wp;
  477.     register int screencol;
  478.  
  479.     if (!curbp) /* not initialized */
  480.         return FALSE;
  481. #if    TYPEAH
  482.     if (force == FALSE && typahead())
  483.         return SORTOFTRUE;
  484. #endif
  485. #if    VISMAC == 0
  486.     if (force == FALSE && (get_recorded_char(FALSE) != -1))
  487.         return SORTOFTRUE;
  488. #endif
  489.  
  490.     displaying = TRUE;
  491.  
  492.     /* first, propagate mode line changes to all instances of
  493.         a buffer displayed in more than one window */
  494.     wp = wheadp;
  495.     while (wp != NULL) {
  496.         if (wp->w_flag & WFMODE) {
  497.             if (wp->w_bufp->b_nwnd > 1) {
  498.                 /* make sure all previous windows have this */
  499.                 register WINDOW *owp;
  500.                 owp = wheadp;
  501.                 while (owp != NULL) {
  502.                     if (owp->w_bufp == wp->w_bufp)
  503.                         owp->w_flag |= WFMODE;
  504.                     owp = owp->w_wndp;
  505.                 }
  506.             }
  507.         }
  508.         wp = wp->w_wndp;
  509.     }
  510.  
  511.     /* update any windows that need refreshing */
  512.     wp = wheadp;
  513.     while (wp != NULL) {
  514.         if (wp->w_flag) {
  515.             curtabval = tabstop_val(wp->w_bufp);
  516.             /* if the window has changed, service it */
  517.             reframe(wp);    /* check the framing */
  518.             if (wp->w_flag & (WFKILLS|WFINS)) {
  519.                 scrflags |= (wp->w_flag & (WFINS|WFKILLS));
  520.                 wp->w_flag &= ~(WFKILLS|WFINS);
  521.             }
  522.             if ((wp->w_flag & ~(/* WFMOVE| */WFMODE)) == WFEDIT)
  523.                 updone(wp);    /* update EDITed line */
  524.             else if (wp->w_flag & ~(WFMOVE))
  525.                 updall(wp);    /* update all lines */
  526.             if (scrflags || (wp->w_flag & WFMODE))
  527.                 modeline(wp);    /* update modeline */
  528.             wp->w_flag = 0;
  529.             wp->w_force = 0;
  530.         }
  531.         /* on to the next window */
  532.         wp = wp->w_wndp;
  533.     }
  534.     curtabval = tabstop_val(curbp);
  535.  
  536.     /* recalc the current hardware cursor location */
  537.     screencol = updpos();
  538.  
  539. #if    MEMMAP
  540.     /* update the cursor and flush the buffers */
  541.     /* movecursor(currow, screencol); */
  542. #endif
  543.  
  544.     /* check for lines to de-extend */
  545.     upddex();
  546.  
  547.     /* if screen is garbage, re-plot it */
  548.     if (sgarbf)
  549.         updgar();
  550.  
  551.     /* update the virtual screen to the physical screen */
  552.     updupd(force);
  553.  
  554.     /* update the cursor and flush the buffers */
  555.     movecursor(currow, screencol);
  556.     
  557.     TTflush();
  558.     displaying = FALSE;
  559.     while (chg_width || chg_height)
  560.         newscreensize(chg_height,chg_width);
  561.     return(TRUE);
  562. }
  563.  
  564. /*    reframe:    check to see if the cursor is on in the window
  565.             and re-frame it if needed or wanted        */
  566. void
  567. reframe(wp)
  568. WINDOW *wp;
  569. {
  570.     register LINE *lp;
  571.     register int i = 0;
  572.  
  573.     /* if not a requested reframe, check for a needed one */
  574.     if ((wp->w_flag & WFFORCE) == 0) {
  575. #if SCROLLCODE && ! MEMMAP
  576.         /* loop from one line above the window to one line after */
  577.         lp = lback(wp->w_line.l);
  578.         for (i = -1; i <= wp->w_ntrows; i++)
  579. #else
  580.         /* loop through the window */
  581.         lp = wp->w_line.l;
  582.         for (i = 0; i < wp->w_ntrows; i++)
  583. #endif
  584.         {
  585.  
  586.             /* if the line is in the window, no reframe */
  587.             if (lp == wp->w_dot.l) {
  588. #if SCROLLCODE && ! MEMMAP
  589.                 /* if not _quite_ in, we'll reframe gently */
  590.                 if ( i < 0 || i == wp->w_ntrows) {
  591.                     /* if the terminal can't help, then
  592.                         we're simply outside */
  593.                     if (term.t_scroll == NULL)
  594.                         i = wp->w_force;
  595.                     break;
  596.                 }
  597. #endif
  598.                 return;
  599.             }
  600.  
  601.             /* if we are at the end of the file, reframe */
  602.             if (i >= 0 && lp == wp->w_bufp->b_line.l)
  603.                 break;
  604.  
  605.             /* on to the next line */
  606.             lp = lforw(lp);
  607.         }
  608.     }
  609.  
  610. #if SCROLLCODE && ! MEMMAP
  611.     if (i == -1) {    /* we're just above the window */
  612.         i = 1;    /* put dot at first line */
  613.         scrflags |= WFINS;
  614.     } else if (i == wp->w_ntrows) { /* we're just below the window */
  615.         i = -1;    /* put dot at last line */
  616.         scrflags |= WFKILLS;
  617.     } else /* put dot where requested */
  618. #endif
  619.         i = wp->w_force;  /* (is 0, unless reposition() was called) */
  620.  
  621.     wp->w_flag |= WFMODE;
  622.     
  623.     /* w_force specifies which line of the window dot should end up on */
  624.     /*     positive --> lines from the top                */
  625.     /*     negative --> lines from the bottom            */
  626.     /*     zero --> middle of window                */
  627.     
  628.     /* enforce some maximums */
  629.     if (i > 0) {
  630.         if (--i >= wp->w_ntrows)
  631.             i = wp->w_ntrows - 1;
  632.     } else if (i < 0) {    /* negative update???? */
  633.         i += wp->w_ntrows;
  634.         if (i < 0)
  635.             i = 0;
  636.     } else
  637.         i = wp->w_ntrows / 2;
  638.  
  639.     /* backup to new line at top of window */
  640.     lp = wp->w_dot.l;
  641.     while (i != 0 && lback(lp) != wp->w_bufp->b_line.l) {
  642.         --i;
  643.         lp = lback(lp);
  644.     }
  645.  
  646.     if (lp == wp->w_bufp->b_line.l)
  647.         lp = lback(lp);
  648.         
  649.     /* and reset the current line-at-top-of-window */
  650.     wp->w_line.l = lp;
  651.     wp->w_flag |= WFHARD;
  652.     wp->w_flag &= ~WFFORCE;
  653. }
  654.  
  655. /*    updone:    update the current line    to the virtual screen        */
  656.  
  657. void
  658. updone(wp)
  659. WINDOW *wp;    /* window to update current line in */
  660. {
  661.     register LINE *lp;    /* line to update */
  662.     register int sline;    /* physical screen line to update */
  663.  
  664.     /* search down the line we want */
  665.     lp = wp->w_line.l;
  666.     sline = wp->w_toprow;
  667.     while (lp != wp->w_dot.l) {
  668.         ++sline;
  669.         lp = lforw(lp);
  670.     }
  671.  
  672.     l_to_vline(wp,lp,sline);
  673.     vteeol();
  674. }
  675.  
  676. /*    updall:    update all the lines in a window on the virtual screen */
  677.  
  678. void
  679. updall(wp)
  680. WINDOW *wp;    /* window to update lines in */
  681. {
  682.     register LINE *lp;    /* line to update */
  683.     register int sline;    /* physical screen line to update */
  684.  
  685.     /* search down the lines, updating them */
  686.     lp = wp->w_line.l;
  687.     sline = wp->w_toprow;
  688.     while (sline < wp->w_toprow + wp->w_ntrows) {
  689.         l_to_vline(wp,lp,sline);
  690.         vteeol();
  691.         if (lp != wp->w_bufp->b_line.l)
  692.             lp = lforw(lp);
  693.         ++sline;
  694.     }
  695.  
  696. }
  697.  
  698. /* line to virtual screen line */
  699. void
  700. l_to_vline(wp,lp,sline)
  701. WINDOW *wp;    /* window to update lines in */
  702. LINE *lp;
  703. int sline;
  704. {
  705.  
  706.     /* and update the virtual line */
  707.     vscreen[sline]->v_flag |= VFCHG;
  708.     vscreen[sline]->v_flag &= ~VFREQ;
  709.     if (w_val(wp,WVAL_SIDEWAYS))
  710.         taboff = w_val(wp,WVAL_SIDEWAYS);
  711.     if (lp != wp->w_bufp->b_line.l) {
  712.         vtmove(sline, -w_val(wp,WVAL_SIDEWAYS));
  713.         vtset(lp, wp);
  714.         if (w_val(wp,WVAL_SIDEWAYS)) {
  715.             vscreen[sline]->v_text[0] = '<';
  716.             if (vtcol < 1) vtcol = 1;
  717.         }
  718.     } else {
  719.         vtmove(sline, 0);
  720.         vtputc('~');
  721.     }
  722.     taboff = 0;
  723. #if    COLOR
  724.     vscreen[sline]->v_rfcolor = w_val(wp,WVAL_FCOLOR);
  725.     vscreen[sline]->v_rbcolor = w_val(wp,WVAL_BCOLOR);
  726. #endif
  727. }
  728.  
  729. /*    updpos:    update the position of the hardware cursor and handle extended
  730.         lines. This is the only update for simple moves.
  731.         returns the screen column for the cursor    */
  732. int
  733. updpos()
  734. {
  735.     register LINE *lp;
  736.     register int c;
  737.     register int i;
  738.  
  739.     /* find the current row */
  740.     lp = curwp->w_line.l;
  741.     currow = curwp->w_toprow;
  742.     while (lp != DOT.l) {
  743.         ++currow;
  744.         lp = lforw(lp);
  745.         if (lp == curwp->w_line.l) {
  746.             mlforce("BUG:  lost dot updpos().  setting at top");
  747.             curwp->w_line.l = DOT.l  = lforw(curbp->b_line.l);
  748.             currow = curwp->w_toprow;
  749.         }
  750.     }
  751.  
  752.     /* find the current column */
  753.     curcol = -w_val(curwp,WVAL_SIDEWAYS);
  754.     i = 0;
  755.     while (i < DOT.o) {
  756.         c = lgetc(lp, i++);
  757.         if (c == '\t' && !w_val(curwp,WMDLIST)) {
  758.             do {
  759.                 curcol++;
  760.             } while (((curcol +
  761.                 w_val(curwp,WVAL_SIDEWAYS))%curtabval) != 0);
  762.         } else {
  763.             if (!isprint(c))
  764.                 ++curcol;
  765.             ++curcol;
  766.         }
  767.  
  768.     }
  769.  
  770.     /* if extended, flag so and update the virtual line image */
  771.     if (curcol >=  term.t_ncol - 1) {
  772.         return updext_past();
  773.     } else if (w_val(curwp,WVAL_SIDEWAYS) && curcol < 1) {
  774.         return updext_before();
  775.     } else {
  776.         return curcol;
  777.     }
  778. }
  779.  
  780. /*    upddex:    de-extend any line that deserves it        */
  781.  
  782. void
  783. upddex()
  784. {
  785.     register WINDOW *wp;
  786.     register LINE *lp;
  787.     register int i;
  788.  
  789.     wp = wheadp;
  790.  
  791.     while (wp != NULL) {
  792.         lp = wp->w_line.l;
  793.         i = wp->w_toprow;
  794.  
  795.         curtabval = tabstop_val(wp->w_bufp);
  796.  
  797.         while (i < wp->w_toprow + wp->w_ntrows) {
  798.             if (vscreen[i]->v_flag & VFEXT) {
  799.                 if ((wp != curwp) || (lp != wp->w_dot.l) ||
  800.                    (curcol < term.t_ncol - 1)) {
  801.                     l_to_vline(wp,lp,i);
  802.                     vteeol();
  803.                     /* this line no longer is extended */
  804.                     vscreen[i]->v_flag &= ~VFEXT;
  805.                 }
  806.             }
  807.             lp = lforw(lp);
  808.             ++i;
  809.         }
  810.         /* and onward to the next window */
  811.         wp = wp->w_wndp;
  812.     }
  813.     curtabval = tabstop_val(curbp);
  814. }
  815.  
  816. /*    updgar:    if the screen is garbage, clear the physical screen and
  817.         the virtual screen and force a full update        */
  818.  
  819. extern char mlsave[];
  820.  
  821. void
  822. updgar()
  823. {
  824.     register char *txt;
  825.     register int i,j;
  826.  
  827.     for (i = 0; i < term.t_nrow; ++i) {
  828.         vscreen[i]->v_flag |= VFCHG;
  829. #if    REVSTA
  830.         vscreen[i]->v_flag &= ~VFREV;
  831. #endif
  832. #if    COLOR
  833.         vscreen[i]->v_fcolor = gfcolor;
  834.         vscreen[i]->v_bcolor = gbcolor;
  835. #endif
  836. #if    ! MEMMAP
  837.         txt = pscreen[i]->v_text;
  838.         for (j = 0; j < term.t_ncol; ++j)
  839.             txt[j] = ' ';
  840. #endif
  841.     }
  842.  
  843.     movecursor(0, 0);         /* Erase the screen. */
  844.     (*term.t_eeop)();
  845.     sgarbf = FALSE;             /* Erase-page clears */
  846.     mpresf = FALSE;             /* the message area. */
  847.     if (mlsave[0]) {
  848.         mlforce(mlsave);
  849.     }
  850. #if    COLOR
  851.     else
  852.         mlerase();        /* needs to be cleared if colored */
  853. #endif
  854. }
  855.  
  856. /*    updupd:    update the physical screen from the virtual screen    */
  857.  
  858. void
  859. updupd(force)
  860. int force;    /* forced update flag */
  861. {
  862.     register VIDEO *vp1;
  863.     register int i;
  864. #if SCROLLCODE && ! MEMMAP
  865.     if (scrflags & WFKILLS)
  866.         scrolls(FALSE);
  867.     if (scrflags & WFINS)
  868.         scrolls(TRUE);
  869.     scrflags = 0;
  870. #endif
  871.  
  872.     for (i = 0; i < term.t_nrow; ++i) {
  873.         vp1 = vscreen[i];
  874.  
  875.         /* for each line that needs to be updated*/
  876.         if ((vp1->v_flag & VFCHG) != 0) {
  877. #if    TYPEAH
  878.             if (force == FALSE && typahead())
  879.                 return;
  880. #endif
  881. #if    MEMMAP
  882.             updateline(i, vp1, vp1);
  883. #else
  884.             updateline(i, vp1, pscreen[i]);
  885. #endif
  886.         }
  887.     }
  888. }
  889.  
  890. #if SCROLLCODE && ! MEMMAP
  891. /* optimize out scrolls (line breaks, and newlines) */
  892. /* arg. chooses between looking for inserts or deletes */
  893. int    
  894. scrolls(inserts)    /* returns true if it does something */
  895. int inserts;
  896. {
  897.     struct    VIDEO *vpv ;    /* virtual screen image */
  898.     struct    VIDEO *vpp ;    /* physical screen image */
  899.     int    i, j, k ;
  900.     int    rows, cols ;
  901.     int    first, match, count, ptarget = 0, vtarget = 0, end ;
  902.     int    longmatch, longcount;
  903.     int    from, to;
  904.  
  905.     if (!term.t_scroll) /* no way to scroll */
  906.         return FALSE;
  907.  
  908.     rows = term.t_nrow ;
  909.     cols = term.t_ncol ;
  910.  
  911.     first = -1 ;
  912.     for (i = 0; i < rows; i++) {    /* find first wrong line */
  913.         if (!texttest(i,i)) {
  914.             first = i;
  915.             break;
  916.         }
  917.     }
  918.  
  919.     if (first < 0)
  920.         return FALSE;        /* no text changes */
  921.  
  922.     vpv = vscreen[first] ;
  923.     vpp = pscreen[first] ;
  924.  
  925.     if (inserts) {
  926.         /* determine types of potential scrolls */
  927.         end = endofline(vpv->v_text,cols) ;
  928.         if ( end == 0 )
  929.             ptarget = first ;        /* newlines */
  930.         else if ( strncmp(vpp->v_text, vpv->v_text, end) == 0 )
  931.             ptarget = first + 1 ;    /* broken line newlines */
  932.         else 
  933.             ptarget = first ;
  934.         from = ptarget;
  935.     } else {
  936.         from = vtarget = first + 1 ;
  937.     }
  938.  
  939.     /* find the matching shifted area */
  940.     longmatch = -1;
  941.     longcount = 0;
  942.     for (i = from+1; i < rows; i++) {
  943.         if (inserts ? texttest(i,from) : texttest(from,i) ) {
  944.             match = i ;
  945.             count = 1 ;
  946.             for (j=match+1, k=from+1; j<rows && k<rows; j++, k++) {
  947.                 if (inserts ? texttest(j,k) : texttest(k,j))
  948.                     count++ ;
  949.                 else
  950.                     break ;
  951.             }
  952.             if (longcount < count) {
  953.                 longcount = count;
  954.                 longmatch = match;
  955.             }
  956.         }
  957.     }
  958.     match = longmatch;
  959.     count = longcount;
  960.  
  961.     if (!inserts) {
  962.         /* full kill case? */
  963.         if (match > 0 && texttest(first, match-1)) {
  964.             vtarget-- ;
  965.             match-- ;
  966.             count++ ;
  967.         }
  968.     }
  969.  
  970.     /* do the scroll */
  971.     if (match>0 && count>2) {         /* got a scroll */
  972.         /* move the count lines starting at ptarget to match */
  973.         /* mlwrite("scrolls: move the %d lines starting at %d to %d",
  974.                         count,ptarget,match);
  975.         */
  976.         if (inserts) {
  977.             from = ptarget;
  978.             to = match;
  979.         } else {
  980.             from = match;
  981.             to = vtarget;
  982.         }
  983.         scrscroll(from, to, count) ;
  984.         for (i = 0; i < count; i++) {
  985.             vpp = pscreen[to+i] ;
  986.             vpv = vscreen[to+i];
  987.             strncpy(vpp->v_text, vpv->v_text, cols) ;
  988.         }
  989.         if (inserts) {
  990.             from = ptarget;
  991.             to = match;
  992.         } else {
  993.             from = vtarget+count;
  994.             to = match+count;
  995.         }
  996.         for (i = from; i < to; i++) {
  997.             char *txt;
  998.             txt = pscreen[i]->v_text;
  999.             for (j = 0; j < term.t_ncol; ++j)
  1000.                 txt[j] = ' ';
  1001.             vscreen[i]->v_flag |= VFCHG;
  1002.         }
  1003.         return(TRUE) ;
  1004.     }
  1005.     return(FALSE) ;
  1006. }
  1007.  
  1008. /* move the "count" lines starting at "from" to "to" */
  1009. void
  1010. scrscroll(from, to, count)
  1011. int from, to, count;
  1012. {
  1013.     ttrow = ttcol = -1;
  1014.     (*term.t_scroll)(from,to,count);
  1015. }
  1016.  
  1017. int
  1018. texttest(vrow,prow)        /* return TRUE on text match */
  1019. int    vrow, prow ;        /* virtual, physical rows */
  1020. {
  1021.     struct    VIDEO *vpv = vscreen[vrow] ;    /* virtual screen image */
  1022.     struct    VIDEO *vpp = pscreen[prow]  ;    /* physical screen image */
  1023.  
  1024.     return (!memcmp(vpv->v_text, vpp->v_text, term.t_ncol)) ;
  1025. }
  1026.  
  1027. /* return the index of the first blank of trailing whitespace */
  1028. int    
  1029. endofline(s,n) 
  1030. char     *s;
  1031. int    n;
  1032. {
  1033.     int    i;
  1034.     for (i = n - 1; i >= 0; i--)
  1035.         if (s[i] != ' ') return(i+1) ;
  1036.     return(0) ;
  1037. }
  1038.  
  1039. #endif /* SCROLLCODE */
  1040.  
  1041.  
  1042. /*    updext_past: update the extended line which the cursor is currently
  1043.         on at a column greater than the terminal width. The line
  1044.         will be scrolled right or left to let the user see where
  1045.         the cursor is        */
  1046. int
  1047. updext_past()
  1048. {
  1049.     register int lbound, rcursor;
  1050.  
  1051.     /* calculate what column the real cursor will end up in */
  1052.     /* why is term.t_ncol in here? */
  1053.     rcursor = ((curcol - term.t_ncol) % term.t_scrsiz) + term.t_margin;
  1054.     lbound = curcol - rcursor;
  1055.     taboff = lbound + w_val(curwp,WVAL_SIDEWAYS);
  1056.  
  1057.     /* scan through the line outputing characters to the virtual screen */
  1058.     /* once we reach the left edge                    */
  1059.  
  1060.     /* start scanning offscreen */
  1061.     vtmove(currow, -lbound-w_val(curwp,WVAL_SIDEWAYS));
  1062.     vtset(DOT.l, curwp);
  1063.  
  1064.     /* truncate the virtual line, restore tab offset */
  1065.     vteeol();
  1066.     taboff = 0;
  1067.  
  1068.     /* and put a '<' in column 1 */
  1069.     vscreen[currow]->v_text[0] = '<';
  1070.     vscreen[currow]->v_flag |= (VFEXT | VFCHG);
  1071.     return rcursor;
  1072. }
  1073.  
  1074. /*    updext_before: update the extended line which the cursor is currently
  1075.         on at a column less than the terminal width. The line
  1076.         will be scrolled right or left to let the user see where
  1077.         the cursor is        */
  1078. int
  1079. updext_before()
  1080. {
  1081.     register int lbound, rcursor;
  1082.  
  1083.     /* calculate what column the real cursor will end up in */
  1084.     rcursor = (curcol % (term.t_ncol-term.t_margin));
  1085.     lbound = curcol - rcursor + 1;
  1086.     taboff = lbound;
  1087.  
  1088.     /* scan through the line outputing characters to the virtual screen */
  1089.     /* once we reach the left edge                    */
  1090.     vtmove(currow, -lbound);    /* start scanning offscreen */
  1091.     vtset(DOT.l, curwp);
  1092.  
  1093.     /* truncate the virtual line, restore tab offset */
  1094.     vteeol();
  1095.     taboff = 0;
  1096.  
  1097.     /* and put a '<' in column 1 */
  1098.     vscreen[currow]->v_text[0] = '<';
  1099.     vscreen[currow]->v_flag |= (VFEXT | VFCHG);
  1100.     return rcursor;
  1101. }
  1102.  
  1103.  
  1104.  
  1105. /*
  1106.  * Update a single line. This does not know how to use insert or delete
  1107.  * character sequences; we are using VT52 functionality. Update the physical
  1108.  * row and column variables. It does try an exploit erase to end of line. The
  1109.  * RAINBOW version of this routine uses fast video.
  1110.  */
  1111. #if    MEMMAP
  1112. /*    UPDATELINE specific code for the IBM-PC and other compatibles */
  1113.  
  1114. void
  1115. updateline(row, vp1, vpdummy)
  1116.  
  1117. int row;        /* row of screen to update */
  1118. struct VIDEO *vp1;    /* virtual screen image */
  1119. struct VIDEO *vpdummy;    /* virtual screen image */
  1120.  
  1121. {
  1122. #if    COLOR
  1123.     scwrite(row, 0, term.t_ncol-1,
  1124.         vp1->v_text, vp1->v_rfcolor, vp1->v_rbcolor);
  1125.     vp1->v_fcolor = vp1->v_rfcolor;
  1126.     vp1->v_bcolor = vp1->v_rbcolor;
  1127. #else
  1128.     if (vp1->v_flag & VFREQ)
  1129.         scwrite(row, 0, term.t_ncol-1, vp1->v_text, 0, 7);
  1130.     else
  1131.         scwrite(row, 0, term.t_ncol-1, vp1->v_text, 7, 0);
  1132. #endif
  1133.     vp1->v_flag &= ~(VFCHG | VFCOL);    /* flag this line as changed */
  1134.  
  1135. }
  1136.  
  1137. #else
  1138.  
  1139. void
  1140. updateline(row, vp1, vp2)
  1141.  
  1142. int row;        /* row of screen to update */
  1143. struct VIDEO *vp1;    /* virtual screen image */
  1144. struct VIDEO *vp2;    /* physical screen image */
  1145.  
  1146. {
  1147. #if RAINBOW
  1148. /*    UPDATELINE specific code for the DEC rainbow 100 micro    */
  1149.  
  1150.     register char *cp1;
  1151.     register char *cp2;
  1152.     register int nch;
  1153.  
  1154.     /* since we don't know how to make the rainbow do this, turn it off */
  1155.     flags &= (~VFREV & ~VFREQ);
  1156.  
  1157.     cp1 = &vp1->v_text[0];                    /* Use fast video. */
  1158.     cp2 = &vp2->v_text[0];
  1159.     putline(row+1, 1, cp1);
  1160.     nch = term.t_ncol;
  1161.  
  1162.     do
  1163.         {
  1164.         *cp2 = *cp1;
  1165.         ++cp2;
  1166.         ++cp1;
  1167.         }
  1168.     while (--nch);
  1169.     *flags &= ~VFCHG;
  1170. #else
  1171. /*    UPDATELINE code for all other versions        */
  1172.  
  1173.     register char *cp1;
  1174.     register char *cp2;
  1175.     register char *cp3;
  1176.     register char *cp4;
  1177.     register char *cp5;
  1178.     register int nbflag;    /* non-blanks to the right flag? */
  1179.     int rev;        /* reverse video flag */
  1180.     int req;        /* reverse video request flag */
  1181.  
  1182.  
  1183.     /* set up pointers to virtual and physical lines */
  1184.     cp1 = &vp1->v_text[0];
  1185.     cp2 = &vp2->v_text[0];
  1186.  
  1187. #if    COLOR
  1188.     TTforg(vp1->v_rfcolor);
  1189.     TTbacg(vp1->v_rbcolor);
  1190. #endif
  1191.  
  1192. #if    REVSTA | COLOR
  1193.     /* if we need to change the reverse video status of the
  1194.        current line, we need to re-write the entire line     */
  1195.     rev = (vp1->v_flag & VFREV) == VFREV;
  1196.     req = (vp1->v_flag & VFREQ) == VFREQ;
  1197.     if ((rev != req)
  1198. #if    COLOR
  1199.         || (vp1->v_fcolor != vp1->v_rfcolor) || (vp1->v_bcolor != vp1->v_rbcolor)
  1200. #endif
  1201. #if    HP150
  1202.     /* the HP150 has some reverse video problems */
  1203.         || req || rev
  1204. #endif
  1205.             ) {
  1206.         movecursor(row, 0);    /* Go to start of line. */
  1207.         /* set rev video if needed */
  1208.         if (rev != req)
  1209.             (*term.t_rev)(req);
  1210.  
  1211.         /* scan through the line and dump it to the screen and
  1212.            the virtual screen array                */
  1213.         cp3 = &vp1->v_text[term.t_ncol];
  1214. #if X11
  1215.         x_putline(row, cp1, cp3 - cp1);
  1216. #endif
  1217.         while (cp1 < cp3) {
  1218. #if !X11
  1219.             TTputc(*cp1);
  1220. #endif
  1221.             ++ttcol;
  1222.             *cp2++ = *cp1++;
  1223.         }
  1224.         /* turn rev video off */
  1225.         if (rev != req)
  1226.             (*term.t_rev)(FALSE);
  1227.  
  1228.         /* update the needed flags */
  1229.         vp1->v_flag &= ~VFCHG;
  1230.         if (req)
  1231.             vp1->v_flag |= VFREV;
  1232.         else
  1233.             vp1->v_flag &= ~VFREV;
  1234. #if    COLOR
  1235.         vp1->v_fcolor = vp1->v_rfcolor;
  1236.         vp1->v_bcolor = vp1->v_rbcolor;
  1237. #endif
  1238.         return;
  1239.     }
  1240. #endif
  1241.  
  1242.     /* advance past any common chars at the left */
  1243.     while (cp1 != &vp1->v_text[term.t_ncol] && *cp1 == *cp2) {
  1244.         ++cp1;
  1245.         ++cp2;
  1246.     }
  1247.  
  1248. /* This can still happen, even though we only call this routine on changed
  1249.  * lines. A hard update is always done when a line splits, a massive
  1250.  * change is done, or a buffer is displayed twice. This optimizes out most
  1251.  * of the excess updating. A lot of computes are used, but these tend to
  1252.  * be hard operations that do a lot of update, so I don't really care.
  1253.  */
  1254.     /* if both lines are the same, no update needs to be done */
  1255.     if (cp1 == &vp1->v_text[term.t_ncol]) {
  1256.          vp1->v_flag &= ~VFCHG;        /* flag this line is changed */
  1257.         return;
  1258.     }
  1259.  
  1260.     /* find out if there is a match on the right */
  1261.     nbflag = FALSE;
  1262.     cp3 = &vp1->v_text[term.t_ncol];
  1263.     cp4 = &vp2->v_text[term.t_ncol];
  1264.  
  1265.     while (cp3[-1] == cp4[-1]) {
  1266.         --cp3;
  1267.         --cp4;
  1268.         if (cp3[0] != ' ')        /* Note if any nonblank */
  1269.             nbflag = TRUE;        /* in right match. */
  1270.     }
  1271.  
  1272.     cp5 = cp3;
  1273.  
  1274.     /* Erase to EOL ? */
  1275.     if (nbflag == FALSE && eolexist == TRUE && (req != TRUE)) {
  1276.         while (cp5!=cp1 && cp5[-1]==' ')
  1277.             --cp5;
  1278.  
  1279.         if (cp3-cp5 <= 3)        /* Use only if erase is */
  1280.             cp5 = cp3;        /* fewer characters. */
  1281.     }
  1282.  
  1283.     movecursor(row, cp1 - &vp1->v_text[0]);    /* Go to start of line. */
  1284. #if    REVSTA
  1285.     TTrev(rev);
  1286. #endif
  1287.  
  1288. #if X11
  1289.     x_putline(row, cp1, cp5 - cp1 + 1);
  1290. #endif
  1291.     while (cp1 != cp5) {        /* Ordinary. */
  1292. #if !X11
  1293.         TTputc(*cp1);
  1294. #endif
  1295.         ++ttcol;
  1296.         *cp2++ = *cp1++;
  1297.     }
  1298.  
  1299.     if (cp5 != cp3) {        /* Erase. */
  1300.         TTeeol();
  1301.         while (cp1 != cp3)
  1302.             *cp2++ = *cp1++;
  1303.     }
  1304. #if    REVSTA
  1305.     TTrev(FALSE);
  1306. #endif
  1307.     vp1->v_flag &= ~VFCHG;        /* flag this line as updated */
  1308.     return;
  1309. #endif
  1310. }
  1311. #endif
  1312.  
  1313.  
  1314. /*
  1315.  * Redisplay the mode line for the window pointed to by the "wp". This is the
  1316.  * only routine that has any idea of how the modeline is formatted. You can
  1317.  * change the modeline format by hacking at this routine. Called by "update"
  1318.  * any time there is a dirty window.
  1319.  */
  1320. void
  1321. modeline(wp)
  1322. WINDOW *wp;
  1323. {
  1324.     register int n;
  1325.     register BUFFER *bp;
  1326.     register lchar;        /* character to draw line in buffer with */
  1327.  
  1328.     n = wp->w_toprow+wp->w_ntrows;          /* Location. */
  1329.     vscreen[n]->v_flag |= VFCHG | VFREQ | VFCOL;/* Redraw next time. */
  1330.  
  1331.  
  1332. #if    COLOR
  1333.     vscreen[n]->v_rfcolor = gbcolor;        /* black on */
  1334.     vscreen[n]->v_rbcolor = gfcolor;        /* white.....*/
  1335. #endif
  1336.     vtmove(n, 0);                           /* Seek to right line. */
  1337.     if (wp == curwp) {                /* mark the current buffer */
  1338.         lchar = '=';
  1339.     } else {
  1340. #if    REVSTA
  1341.         if (revexist)
  1342.             lchar = ' ';
  1343.         else
  1344. #endif
  1345.             lchar = '-';
  1346.     }
  1347.     bp = wp->w_bufp;
  1348.  
  1349.     vtputc(lchar);
  1350.     if (b_val(bp, MDSHOWMODE)) {
  1351.         register int ic;
  1352.         ic = lchar;
  1353.         if (wp == curwp) {
  1354.             if (insertmode == INSERT)
  1355.                 ic = 'I';
  1356.             else if (insertmode == REPLACECHAR)
  1357.                 ic = 'R';
  1358.             else if (insertmode == OVERWRITE)
  1359.                 ic = 'O';
  1360.         }
  1361.         vtputc(ic);
  1362.     }
  1363.     vtprintf("%c %s",lchar,bp->b_bname);
  1364.     if (b_val(bp,MDVIEW))
  1365.         vtputsn(" [view only]", 20);
  1366.     if (b_val(bp,MDDOS))
  1367.         vtputsn(" [dos-style]", 20);
  1368.     if (bp->b_flag&BFCHG)
  1369.         vtputsn(" [modified]", 20);
  1370.     if (bp->b_fname && bp->b_fname[0]) {
  1371.         char *p;
  1372.         p = shorten_path(bp->b_fname);
  1373.         if (p && strcmp(p,bp->b_bname) != 0) {
  1374.             if (!isspace(p[0])) {
  1375.                 vtprintf(" is ");
  1376. #if MSDOS
  1377.                 if (isupper(p[0]) && p[1] == ':') {
  1378.                     vtprintf("%c:",p[0]);
  1379.                     p += 2;
  1380.                 }
  1381. #endif
  1382.                 if (p[0] != slash &&
  1383.                     p[0] != '.' &&
  1384.                     p[0] != '!')
  1385.                     vtprintf(".%c",slash);
  1386.             }
  1387.             vtprintf("%s",p);
  1388.         }
  1389.     }
  1390.     vtputc(' ');
  1391.  
  1392.  
  1393.     /* Pad to full width, then go back and overwrite right-end info */
  1394.     n = term.t_ncol;
  1395.     while (vtcol < n)
  1396.         vtputc(lchar);
  1397.         
  1398.     { /* determine if top line, bottom line, or both are visible */
  1399.         LINE *lp = wp->w_line.l;
  1400.         int rows = wp->w_ntrows;
  1401.         char *msg = NULL;
  1402.         
  1403.         vtcol = n - 7;  /* strlen(" top ") plus a couple */
  1404.         while (rows--) {
  1405.             lp = lforw(lp);
  1406.             if (lp == wp->w_bufp->b_line.l) {
  1407.                 msg = " bot ";
  1408.                 break;
  1409.             }
  1410.         }
  1411.         if (lback(wp->w_line.l) == wp->w_bufp->b_line.l) {
  1412.             if (msg) {
  1413.                 if (wp->w_line.l == wp->w_bufp->b_line.l)
  1414.                     msg = " emp ";
  1415.                 else 
  1416.                     msg = " all ";
  1417.             } else {
  1418.                 msg = " top ";
  1419.             }
  1420.         }
  1421.         if (!msg)
  1422.             msg = " mid ";
  1423.         vtputsn(msg,20);
  1424.         vtputc(lchar);
  1425.         vtputc(lchar);
  1426.  
  1427.     }
  1428. #ifdef show_tabstop_on_modeline
  1429.     { /* put in the tabstop value */
  1430.         int t = tabstop_val(wp->w_bufp);
  1431.         vtcol = n - 11;
  1432.         while (t) {
  1433.             vtputc((t%10)+'0');
  1434.             t /= 10;
  1435.             vtcol -= 2;
  1436.         }
  1437.     }
  1438. #endif
  1439.  
  1440.     /* mark column 80 */
  1441.     if (n > 80 && vtgetc(80) == lchar) {
  1442.         vtcol = 80;
  1443.         vtputc('|');
  1444.     }
  1445. }
  1446.  
  1447. void
  1448. upmode()    /* update all the mode lines */
  1449. {
  1450.     register WINDOW *wp;
  1451.  
  1452.     wp = wheadp;
  1453.     while (wp != NULL) {
  1454.         wp->w_flag |= WFMODE;
  1455.         wp = wp->w_wndp;
  1456.     }
  1457. }
  1458.  
  1459. /*
  1460.  * Send a command to the terminal to move the hardware cursor to row "row"
  1461.  * and column "col". The row and column arguments are origin 0. Optimize out
  1462.  * random calls. Update "ttrow" and "ttcol".
  1463.  */
  1464. void
  1465. movecursor(row, col)
  1466. int row,col;
  1467. {
  1468.     if (row!=ttrow || col!=ttcol)
  1469.         {
  1470.             ttrow = row;
  1471.             ttcol = col;
  1472.             TTmove(row, col);
  1473.         }
  1474. }
  1475.  
  1476.  
  1477.  
  1478.  
  1479. /*
  1480.  * Erase the message line. This is a special routine because the message line
  1481.  * is not considered to be part of the virtual screen. It always works
  1482.  * immediately; the terminal buffer is flushed via a call to the flusher.
  1483.  */
  1484. void
  1485. mlerase()
  1486. {
  1487.     int i;
  1488.  
  1489.     if (mpresf == FALSE)
  1490.         return;
  1491.     movecursor(term.t_nrow, 0);
  1492.     if (discmd == FALSE)
  1493.         return;
  1494.  
  1495. #if    COLOR
  1496.      TTforg(gfcolor);
  1497.      TTbacg(gbcolor);
  1498. #endif
  1499.     if (eolexist == TRUE)
  1500.         TTeeol();
  1501.     else {
  1502.         for (i = 0; i < term.t_ncol - 1; i++)
  1503.             TTputc(' ');
  1504.         movecursor(term.t_nrow, 1);    /* force the move! */
  1505.         movecursor(term.t_nrow, 0);
  1506.     }
  1507.     TTflush();
  1508.     mpresf = FALSE;
  1509. }
  1510.  
  1511.  
  1512.  
  1513. #ifndef __STDC__
  1514.  
  1515. #ifndef va_dcl     /* then try these out */
  1516.  
  1517. typedef char *va_list;
  1518. #define va_dcl int va_alist;
  1519. #define va_start(list) list = (char *) &va_alist
  1520. #define va_end(list)
  1521. #define va_arg(list, mode) ((mode *)(list += sizeof(mode)))[-1]
  1522.  
  1523. #endif
  1524.  
  1525. #endif /* __STDC__ */
  1526.  
  1527. char *mlsavep;
  1528. char mlsave[NSTRING];
  1529.  
  1530. void
  1531. mlsavec(c)
  1532. int c;
  1533. {
  1534.     if (mlsavep - mlsave < NSTRING-1) {
  1535.         *mlsavep++ = c;
  1536.         *mlsavep = '\0';
  1537.     }
  1538.  
  1539. }
  1540.  
  1541. /*
  1542.  * Write a message into the message line only if appropriate.
  1543.  */
  1544. /* VARARGS1 */
  1545. void
  1546. #ifdef __STDC__
  1547. mlwrite( char *fmt, ...)
  1548. #else
  1549. mlwrite(va_alist)
  1550. va_dcl
  1551. #endif
  1552. {
  1553.     va_list ap;
  1554.     /* if we are not currently echoing on the command line, abort this */
  1555.     if (global_b_val(MDTERSE) || dotcmdmode == PLAY || discmd == FALSE) {
  1556.         movecursor(term.t_nrow, 0);
  1557.         return;
  1558.     }
  1559. #ifdef __STDC__
  1560.     va_start(ap,fmt);
  1561.     mlmsg(fmt,&ap);
  1562. #else
  1563.     va_start(ap);
  1564.     mlmsg(&ap);
  1565. #endif
  1566.     va_end(ap);
  1567. }
  1568.  
  1569. /*    Put a string out to the message line regardless of the
  1570.     current $discmd setting. This is needed when $debug is TRUE
  1571.     and for the write-message and clear-message-line commands
  1572.     Also used for most errors, to be sure they're seen.
  1573. */
  1574. /* VARARGS1 */
  1575. void
  1576. #ifdef __STDC__
  1577. mlforce(char *fmt, ...)
  1578. #else
  1579. mlforce(va_alist)
  1580. va_dcl
  1581. #endif
  1582. {
  1583.     va_list ap;
  1584. #ifdef __STDC__
  1585.     va_start(ap,fmt);
  1586.     mlmsg(fmt,&ap);
  1587. #else
  1588.     va_start(ap);
  1589.     mlmsg(&ap);
  1590. #endif
  1591.     va_end(ap);
  1592. }
  1593.  
  1594. /* VARARGS1 */
  1595. void
  1596. #ifdef __STDC__
  1597. mlprompt( char *fmt, ...)
  1598. #else
  1599. mlprompt(va_alist)
  1600. va_dcl
  1601. #endif
  1602. {
  1603.     va_list ap;
  1604.     int osgarbf = sgarbf;
  1605.     if (discmd == FALSE) {
  1606.         movecursor(term.t_nrow, 0);
  1607.         return;
  1608.     }
  1609.     sgarbf = FALSE;
  1610. #ifdef __STDC__
  1611.     va_start(ap,fmt);
  1612.     mlmsg(fmt,&ap);
  1613. #else
  1614.     va_start(ap);
  1615.     mlmsg(&ap);
  1616. #endif
  1617.     va_end(ap);
  1618.     sgarbf = osgarbf;
  1619. }
  1620.  
  1621. /* VARARGS */
  1622. void
  1623. #ifdef __STDC__
  1624. dbgwrite( char *fmt, ...)
  1625. #else
  1626. dbgwrite(va_alist)
  1627. va_dcl
  1628. #endif
  1629. {
  1630.     va_list ap;    /* ptr to current data field */
  1631. #ifdef __STDC__
  1632.     va_start(ap,fmt);
  1633.     mlmsg(fmt,&ap);
  1634. #else
  1635.     va_start(ap);
  1636.     mlmsg(&ap);
  1637. #endif
  1638.     va_end(ap);
  1639.     TTgetc();
  1640. }
  1641.  
  1642. /*
  1643.  * Do the real message-line work.  Keep track of the physical cursor
  1644.  * position. A small class of printf like format items is handled.
  1645.  * Set the "message line" flag TRUE.
  1646.  */
  1647. void
  1648. #ifdef __STDC__
  1649. mlmsg( char *fmt, va_list *app)
  1650. #else
  1651. mlmsg(app)
  1652. va_list *app;    /* ptr to current data field */
  1653. #endif
  1654. {
  1655.  
  1656.     if (sgarbf) {
  1657.         /* then we'll lose the message on the next update(), so save it now */
  1658.         mlsavep = mlsave;
  1659.         dfoutfn = mlsavec;
  1660. #ifdef __STDC__
  1661.         dofmt(fmt,app);
  1662. #else
  1663.         dofmt(app);
  1664. #endif
  1665.         return;
  1666.     }
  1667.  
  1668. #if    COLOR
  1669.     /* set up the proper colors for the command line */
  1670.     TTforg(gfcolor);
  1671.     TTbacg(gbcolor);
  1672. #endif
  1673.  
  1674.     /* if we cannot erase to end-of-line, do it manually */
  1675.     if (eolexist == FALSE) {
  1676.         mlerase();
  1677.         TTflush();
  1678.     }
  1679.  
  1680.  
  1681.     movecursor(term.t_nrow, 0);
  1682.  
  1683.     dfoutfn = mlputc;
  1684. #ifdef __STDC__
  1685.     dofmt(fmt,app);
  1686. #else
  1687.     dofmt(app);
  1688. #endif
  1689.  
  1690.     /* if we can, erase to the end of screen */
  1691.     if (eolexist == TRUE)
  1692.         TTeeol();
  1693.     TTflush();
  1694.     mpresf = TRUE;
  1695.     mlsave[0] = '\0';
  1696. } 
  1697.  
  1698. /*
  1699.  * Write out a character. Update the physical cursor position. This assumes that
  1700.  * the character has width "1"; if this is not the case
  1701.  * things will get screwed up a little.
  1702.  */
  1703. void
  1704. mlputc(c)
  1705. int c;
  1706. {
  1707.     if (c == '\r') ttcol = 0;
  1708.     if (c == '\t') c = ' ';
  1709.     if (ttcol < term.t_ncol-1) {
  1710.             TTputc(c);
  1711.             ++ttcol;
  1712.     }
  1713. }
  1714.  
  1715. /* 
  1716.  * Generic string formatter.  Takes printf-like args, and calls
  1717.  * the global function (*dfoutfn)(c) for each c
  1718.  */
  1719. void
  1720. #ifdef __STDC__
  1721. dofmt( char *fmt, va_list *app)
  1722. #else
  1723. dofmt(app)
  1724. va_list *app;
  1725. #endif
  1726. {
  1727. #ifndef __STDC__
  1728.     register char *fmt;
  1729. #endif
  1730.     register int c;        /* current char in format string */
  1731.     register int wid;
  1732.     register int n;
  1733.     register int nchars = 0;
  1734.     int islong;
  1735. #ifndef __STDC__
  1736.     fmt = va_arg(*app, char *);
  1737. #endif
  1738.     while ((c = *fmt++) != 0 ) {
  1739.         if (c != '%') {
  1740.             (*dfoutfn)(c);
  1741.             nchars++;
  1742.             continue;
  1743.         }
  1744.         c = *fmt++;
  1745.         wid = 0;
  1746.         islong = FALSE;
  1747.         if (c == '*') {
  1748.             wid = va_arg(*app,int);
  1749.             c = *fmt++;
  1750.         } else while (isdigit(c)) {
  1751.             wid = (wid * 10) + c - '0';
  1752.             c = *fmt++;
  1753.         }
  1754.         if (c == 'l') {
  1755.             islong = TRUE;
  1756.             c = *fmt++;
  1757.         }
  1758.         switch (c) {
  1759.             case '\0':
  1760.                 n = 0;
  1761.                 break;
  1762.             case 'c':
  1763.                 (*dfoutfn)(va_arg(*app,int));
  1764.                 n = 1;
  1765.                 break;
  1766.  
  1767.             case 'd':
  1768.                 if (!islong) {
  1769.                     n = dfputi(va_arg(*app,int), 10);
  1770.                     break;
  1771.                 }
  1772.                 /* fall through */
  1773.             case 'D':
  1774.                 n = dfputli(va_arg(*app,long), 10);
  1775.                 break;
  1776.  
  1777.             case 'o':
  1778.                 n = dfputi(va_arg(*app,int), 8);
  1779.                 break;
  1780.  
  1781.             case 'x':
  1782.                 if (!islong) {
  1783.                     n = dfputi(va_arg(*app,int), 16);
  1784.                     break;
  1785.                 }
  1786.                 /* fall through */
  1787.             case 'X':
  1788.                 n = dfputli(va_arg(*app,long), 16);
  1789.                 break;
  1790.  
  1791.             case 's':
  1792.                 n = dfputs(va_arg(*app,char *));
  1793.                 break;
  1794.  
  1795.             case 'S': /* use wid as max width */
  1796.                 n = dfputsn(va_arg(*app,char *),wid);
  1797.                 break;
  1798.  
  1799.             case 'f':
  1800.                 n = dfputf(va_arg(*app,int));
  1801.                 break;
  1802.  
  1803.             case 'P': /* output padding -- pads total output to
  1804.                     "wid" chars, using c as the pad char */
  1805.                 wid -= nchars;
  1806.                 /* fall through */
  1807.  
  1808.             case 'p': /* field padding -- puts out "wid"
  1809.                     copies of c */
  1810.                 n = 0;
  1811.                 c = va_arg(*app,int);
  1812.                 while (n < wid) {
  1813.                     (*dfoutfn)(c);
  1814.                     n++;
  1815.                 }
  1816.                 break;
  1817.  
  1818.  
  1819.             default:
  1820.                 (*dfoutfn)(c);
  1821.                 n = 1;
  1822.         }
  1823.         wid -= n;
  1824.         nchars += n;
  1825.         while (wid-- > 0) {
  1826.             (*dfoutfn)(' ');
  1827.             nchars++;
  1828.         }
  1829.     }
  1830.  
  1831. }
  1832.  
  1833. /*
  1834.  * Do format a string.
  1835.  */
  1836. int
  1837. dfputs(s)
  1838. char *s;
  1839. {
  1840.     register int c;
  1841.     register int l = 0;
  1842.  
  1843.     while ((c = *s++) != 0) {
  1844.             (*dfoutfn)(c);
  1845.         l++;
  1846.     }
  1847.     return l;
  1848. }
  1849.  
  1850. /* as above, but takes a count for s's length */
  1851. int
  1852. dfputsn(s,n)
  1853. char *s;
  1854. int n;
  1855. {
  1856.     register int c;
  1857.     register int l = 0;
  1858.     while ((c = *s++) != 0 && n-- != 0) {
  1859.             (*dfoutfn)(c);
  1860.         l++;
  1861.     }
  1862.     return l;
  1863. }
  1864.  
  1865. /*
  1866.  * Do format an integer, in the specified radix.
  1867.  */
  1868. int
  1869. dfputi(i, r)
  1870. int i,r;
  1871. {
  1872.     register int q;
  1873.     static char hexdigits[] = "0123456789ABCDEF";
  1874.  
  1875.     if (i < 0) {
  1876.         (*dfoutfn)('-');
  1877.         i = -i;
  1878.     return dfputi(i, r) + 1;
  1879.     }
  1880.  
  1881.     q = i/r;
  1882.  
  1883.     if (q != 0)
  1884.         q = dfputi(q, r);
  1885.  
  1886.     (*dfoutfn)(hexdigits[i%r]);
  1887.     return q + 1; /* number of digits printed */
  1888. }
  1889.  
  1890. /*
  1891.  * do the same except as a long integer.
  1892.  */
  1893. int
  1894. dfputli(l, r)
  1895. long l;
  1896. int r;
  1897. {
  1898.     register long q;
  1899.  
  1900.     if (l < 0) {
  1901.         l = -l;
  1902.         (*dfoutfn)('-');
  1903.     }
  1904.  
  1905.     q = l/r;
  1906.  
  1907.     if (q != 0)
  1908.         q = dfputli(q, r);
  1909.  
  1910.     (*dfoutfn)((int)(l%r)+'0');
  1911.     return q + 1;
  1912. }
  1913.  
  1914. /*
  1915.  *    Do format a scaled integer with two decimal places
  1916.  */
  1917. int
  1918. dfputf(s)
  1919. int s;    /* scaled integer to output */
  1920. {
  1921.     register int i;    /* integer portion of number */
  1922.     register int f;    /* fractional portion of number */
  1923.  
  1924.     /* break it up */
  1925.     i = s / 100;
  1926.     f = s % 100;
  1927.  
  1928.     /* send out the integer portion */
  1929.     i = dfputi(i, 10);
  1930.     (*dfoutfn)('.');
  1931.     (*dfoutfn)((f / 10) + '0');
  1932.     (*dfoutfn)((f % 10) + '0');
  1933.     return i + 3;
  1934. }    
  1935.  
  1936. /* 
  1937.  * Local sprintf -- similar to standard libc, but
  1938.  *  returns pointer to null character at end of buffer, so it can
  1939.  *  be called repeatedly, as in:
  1940.  *    cp = lsprintf(cp, fmt, args...);
  1941.  *
  1942.  */
  1943.  
  1944. char *lsp;
  1945.  
  1946. void
  1947. lspputc(c)
  1948. int c;
  1949. {
  1950.     *lsp++ = c;
  1951. }
  1952.  
  1953. /* VARARGS1 */
  1954. char *
  1955. #ifdef __STDC__
  1956. lsprintf( char *buf, char *fmt, ...)
  1957. #else
  1958. lsprintf(va_alist)
  1959. va_dcl
  1960. #endif
  1961. {
  1962.  
  1963.     va_list ap;
  1964. #ifdef __STDC__
  1965.     va_start(ap,fmt);
  1966. #else
  1967.     char *buf;
  1968.     va_start(ap);
  1969.     buf = va_arg(ap, char *);
  1970. #endif
  1971.  
  1972.     lsp = buf;
  1973.     dfoutfn = lspputc;
  1974.  
  1975. #ifdef __STDC__
  1976.     dofmt(fmt,&ap);
  1977. #else
  1978.     dofmt(&ap);
  1979. #endif
  1980.     va_end(ap);
  1981.  
  1982.     *lsp = '\0';
  1983.     return lsp;
  1984. } 
  1985.  
  1986. static char *lsbuf;
  1987.  
  1988. void
  1989. lssetbuf(buf)
  1990. char *buf;
  1991. {
  1992.     lsbuf = buf;
  1993. }
  1994.  
  1995. /* VARARGS1 */
  1996. char *
  1997. #ifdef __STDC__
  1998. _lsprintf( char *fmt, ...)
  1999. #else
  2000. _lsprintf(va_alist)
  2001. va_dcl
  2002. #endif
  2003. {
  2004.  
  2005.     va_list ap;
  2006. #ifdef __STDC__
  2007.     va_start(ap,fmt);
  2008. #else
  2009.     va_start(ap);
  2010. #endif
  2011.  
  2012.     lsp = lsbuf;
  2013.     dfoutfn = lspputc;
  2014.  
  2015. #ifdef __STDC__
  2016.     dofmt(fmt,&ap);
  2017. #else
  2018.     dofmt(&ap);
  2019. #endif
  2020.     va_end(ap);
  2021.  
  2022.     *lsp = '\0';
  2023.     return lsp;
  2024. } 
  2025.  
  2026. /*
  2027.  * Buffer printf -- like regular printf, but puts characters
  2028.  *    into the BUFFER.
  2029.  *
  2030.  */
  2031.  
  2032. void
  2033. bputc(c)
  2034. int c;
  2035. {
  2036.     if (c == '\n')
  2037.         lnewline();
  2038.     else
  2039.         linsert(1,c);
  2040. }
  2041.  
  2042. /* printf into curbp, at DOT */
  2043. /* VARARGS */
  2044. void
  2045. #ifdef __STDC__
  2046. bprintf( char *fmt, ...)
  2047. #else
  2048. bprintf(va_alist)
  2049. va_dcl
  2050. #endif
  2051. {
  2052.     va_list ap;
  2053.  
  2054.     dfoutfn = bputc;
  2055.  
  2056. #ifdef __STDC__
  2057.     va_start(ap,fmt);
  2058.     dofmt(fmt,&ap);
  2059. #else
  2060.     va_start(ap);
  2061.     dofmt(&ap);
  2062. #endif
  2063.     va_end(ap);
  2064.  
  2065. } 
  2066.  
  2067. #if RAINBOW
  2068.  
  2069. putline(row, col, buf)
  2070. int row, col;
  2071. char buf[];
  2072. {
  2073.     int n;
  2074.  
  2075.     n = strlen(buf);
  2076.     if (col + n - 1 > term.t_ncol)
  2077.         n = term.t_ncol - col + 1;
  2078.     Put_Data(row, col, n, buf);
  2079. }
  2080. #endif
  2081.  
  2082. /* Get terminal size from system.
  2083.    Store number of lines into *heightp and width into *widthp.
  2084.    If zero or a negative number is stored, the value is not valid.  */
  2085.  
  2086. void
  2087. getscreensize (widthp, heightp)
  2088. int *widthp, *heightp;
  2089. {
  2090. #ifdef TIOCGWINSZ
  2091.     struct winsize size;
  2092.     *widthp = 0;
  2093.     *heightp = 0;
  2094.     if (ioctl (0, TIOCGWINSZ, &size) < 0)
  2095.         return;
  2096.     *widthp = size.ws_col;
  2097.     *heightp = size.ws_row;
  2098. #else
  2099.     *widthp = 0;
  2100.     *heightp = 0;
  2101. #endif
  2102. }
  2103.  
  2104. #if defined( SIGWINCH) && ! X11
  2105. SIGT
  2106. sizesignal (signo)
  2107. int signo;
  2108. {
  2109.     int w, h;
  2110.     extern int errno;
  2111.     int old_errno = errno;
  2112.  
  2113.     getscreensize (&w, &h);
  2114.  
  2115.     if ((h && h-1 != term.t_nrow) || (w && w != term.t_ncol))
  2116.         newscreensize(h, w);
  2117.  
  2118.     signal (SIGWINCH, sizesignal);
  2119.     errno = old_errno;
  2120.     SIGRET;
  2121. }
  2122. #endif
  2123.  
  2124. void
  2125. newscreensize (h, w)
  2126. int h, w;
  2127. {
  2128.     /* do the change later */
  2129.     if (displaying) {
  2130.         chg_width = w;
  2131.         chg_height = h;
  2132.         return;
  2133.     }
  2134.     chg_width = chg_height = 0;
  2135.     if (h - 1 < term.t_mrow)
  2136.         newlength(TRUE,h);
  2137.     if (w < term.t_mcol)
  2138.         newwidth(TRUE,w);
  2139.  
  2140.     update(TRUE);
  2141. }
  2142.  
  2143.