Changeset View
Changeset View
Standalone View
Standalone View
contrib/mg/display.c
- This file was added.
/* $OpenBSD: display.c,v 1.48 2017/07/06 19:27:37 schwarze Exp $ */ | |||||
/* This file is in the public domain. */ | |||||
/* | |||||
* The functions in this file handle redisplay. The | |||||
* redisplay system knows almost nothing about the editing | |||||
* process; the editing functions do, however, set some | |||||
* hints to eliminate a lot of the grinding. There is more | |||||
* that can be done; the "vtputc" interface is a real | |||||
* pig. | |||||
*/ | |||||
#include <sys/queue.h> | |||||
#include <ctype.h> | |||||
#include <signal.h> | |||||
#include <stdio.h> | |||||
#include <stdlib.h> | |||||
#include <string.h> | |||||
#include <term.h> | |||||
#include "def.h" | |||||
#include "kbd.h" | |||||
/* | |||||
* A video structure always holds | |||||
* an array of characters whose length is equal to | |||||
* the longest line possible. v_text is allocated | |||||
* dynamically to fit the screen width. | |||||
*/ | |||||
struct video { | |||||
short v_hash; /* Hash code, for compares. */ | |||||
short v_flag; /* Flag word. */ | |||||
short v_color; /* Color of the line. */ | |||||
int v_cost; /* Cost of display. */ | |||||
char *v_text; /* The actual characters. */ | |||||
}; | |||||
#define VFCHG 0x0001 /* Changed. */ | |||||
#define VFHBAD 0x0002 /* Hash and cost are bad. */ | |||||
#define VFEXT 0x0004 /* extended line (beond ncol) */ | |||||
/* | |||||
* SCORE structures hold the optimal | |||||
* trace trajectory, and the cost of redisplay, when | |||||
* the dynamic programming redisplay code is used. | |||||
*/ | |||||
struct score { | |||||
int s_itrace; /* "i" index for track back. */ | |||||
int s_jtrace; /* "j" index for trace back. */ | |||||
int s_cost; /* Display cost. */ | |||||
}; | |||||
void vtmove(int, int); | |||||
void vtputc(int); | |||||
void vtpute(int); | |||||
int vtputs(const char *); | |||||
void vteeol(void); | |||||
void updext(int, int); | |||||
void modeline(struct mgwin *, int); | |||||
void setscores(int, int); | |||||
void traceback(int, int, int, int); | |||||
void ucopy(struct video *, struct video *); | |||||
void uline(int, struct video *, struct video *); | |||||
void hash(struct video *); | |||||
int sgarbf = TRUE; /* TRUE if screen is garbage. */ | |||||
int vtrow = HUGE; /* Virtual cursor row. */ | |||||
int vtcol = HUGE; /* Virtual cursor column. */ | |||||
int tthue = CNONE; /* Current color. */ | |||||
int ttrow = HUGE; /* Physical cursor row. */ | |||||
int ttcol = HUGE; /* Physical cursor column. */ | |||||
int tttop = HUGE; /* Top of scroll region. */ | |||||
int ttbot = HUGE; /* Bottom of scroll region. */ | |||||
int lbound = 0; /* leftmost bound of the current */ | |||||
/* line being displayed */ | |||||
struct video **vscreen; /* Edge vector, virtual. */ | |||||
struct video **pscreen; /* Edge vector, physical. */ | |||||
struct video *video; /* Actual screen data. */ | |||||
struct video blanks; /* Blank line image. */ | |||||
/* | |||||
* This matrix is written as an array because | |||||
* we do funny things in the "setscores" routine, which | |||||
* is very compute intensive, to make the subscripts go away. | |||||
* It would be "SCORE score[NROW][NROW]" in old speak. | |||||
* Look at "setscores" to understand what is up. | |||||
*/ | |||||
struct score *score; /* [NROW * NROW] */ | |||||
static int linenos = TRUE; | |||||
static int colnos = FALSE; | |||||
/* Is macro recording enabled? */ | |||||
extern int macrodef; | |||||
/* Is working directory global? */ | |||||
extern int globalwd; | |||||
/* | |||||
* Since we don't have variables (we probably should) these are command | |||||
* processors for changing the values of mode flags. | |||||
*/ | |||||
/* ARGSUSED */ | |||||
int | |||||
linenotoggle(int f, int n) | |||||
{ | |||||
if (f & FFARG) | |||||
linenos = n > 0; | |||||
else | |||||
linenos = !linenos; | |||||
sgarbf = TRUE; | |||||
return (TRUE); | |||||
} | |||||
/* ARGSUSED */ | |||||
int | |||||
colnotoggle(int f, int n) | |||||
{ | |||||
if (f & FFARG) | |||||
colnos = n > 0; | |||||
else | |||||
colnos = !colnos; | |||||
sgarbf = TRUE; | |||||
return (TRUE); | |||||
} | |||||
/* | |||||
* Reinit the display data structures, this is called when the terminal | |||||
* size changes. | |||||
*/ | |||||
int | |||||
vtresize(int force, int newrow, int newcol) | |||||
{ | |||||
int i; | |||||
int rowchanged, colchanged; | |||||
static int first_run = 1; | |||||
struct video *vp; | |||||
if (newrow < 1 || newcol < 1) | |||||
return (FALSE); | |||||
rowchanged = (newrow != nrow); | |||||
colchanged = (newcol != ncol); | |||||
#define TRYREALLOC(a, n) do { \ | |||||
void *tmp; \ | |||||
if ((tmp = realloc((a), (n))) == NULL) { \ | |||||
panic("out of memory in display code"); \ | |||||
} \ | |||||
(a) = tmp; \ | |||||
} while (0) | |||||
#define TRYREALLOCARRAY(a, n, m) do { \ | |||||
void *tmp; \ | |||||
if ((tmp = reallocarray((a), (n), (m))) == NULL) {\ | |||||
panic("out of memory in display code"); \ | |||||
} \ | |||||
(a) = tmp; \ | |||||
} while (0) | |||||
/* No update needed */ | |||||
if (!first_run && !force && !rowchanged && !colchanged) | |||||
return (TRUE); | |||||
if (first_run) | |||||
memset(&blanks, 0, sizeof(blanks)); | |||||
if (rowchanged || first_run) { | |||||
int vidstart; | |||||
/* | |||||
* This is not pretty. | |||||
*/ | |||||
if (nrow == 0) | |||||
vidstart = 0; | |||||
else | |||||
vidstart = 2 * (nrow - 1); | |||||
/* | |||||
* We're shrinking, free some internal data. | |||||
*/ | |||||
if (newrow < nrow) { | |||||
for (i = 2 * (newrow - 1); i < 2 * (nrow - 1); i++) { | |||||
free(video[i].v_text); | |||||
video[i].v_text = NULL; | |||||
} | |||||
} | |||||
TRYREALLOCARRAY(score, newrow, newrow * sizeof(struct score)); | |||||
TRYREALLOCARRAY(vscreen, (newrow - 1), sizeof(struct video *)); | |||||
TRYREALLOCARRAY(pscreen, (newrow - 1), sizeof(struct video *)); | |||||
TRYREALLOCARRAY(video, (newrow - 1), 2 * sizeof(struct video)); | |||||
/* | |||||
* Zero-out the entries we just allocated. | |||||
*/ | |||||
for (i = vidstart; i < 2 * (newrow - 1); i++) | |||||
memset(&video[i], 0, sizeof(struct video)); | |||||
/* | |||||
* Reinitialize vscreen and pscreen arrays completely. | |||||
*/ | |||||
vp = &video[0]; | |||||
for (i = 0; i < newrow - 1; ++i) { | |||||
vscreen[i] = vp; | |||||
++vp; | |||||
pscreen[i] = vp; | |||||
++vp; | |||||
} | |||||
} | |||||
if (rowchanged || colchanged || first_run) { | |||||
for (i = 0; i < 2 * (newrow - 1); i++) | |||||
TRYREALLOC(video[i].v_text, newcol); | |||||
TRYREALLOC(blanks.v_text, newcol); | |||||
} | |||||
nrow = newrow; | |||||
ncol = newcol; | |||||
if (ttrow > nrow) | |||||
ttrow = nrow; | |||||
if (ttcol > ncol) | |||||
ttcol = ncol; | |||||
first_run = 0; | |||||
return (TRUE); | |||||
} | |||||
#undef TRYREALLOC | |||||
#undef TRYREALLOCARRAY | |||||
/* | |||||
* Initialize the data structures used | |||||
* by the display code. The edge vectors used | |||||
* to access the screens are set up. The operating | |||||
* system's terminal I/O channel is set up. Fill the | |||||
* "blanks" array with ASCII blanks. The rest is done | |||||
* at compile time. The original window is marked | |||||
* as needing full update, and the physical screen | |||||
* is marked as garbage, so all the right stuff happens | |||||
* on the first call to redisplay. | |||||
*/ | |||||
void | |||||
vtinit(void) | |||||
{ | |||||
int i; | |||||
ttopen(); | |||||
ttinit(); | |||||
/* | |||||
* ttinit called ttresize(), which called vtresize(), so our data | |||||
* structures are setup correctly. | |||||
*/ | |||||
blanks.v_color = CTEXT; | |||||
for (i = 0; i < ncol; ++i) | |||||
blanks.v_text[i] = ' '; | |||||
} | |||||
/* | |||||
* Tidy up the virtual display system | |||||
* in anticipation of a return back to the host | |||||
* operating system. Right now all we do is position | |||||
* the cursor to the last line, erase the line, and | |||||
* close the terminal channel. | |||||
*/ | |||||
void | |||||
vttidy(void) | |||||
{ | |||||
ttcolor(CTEXT); | |||||
ttnowindow(); /* No scroll window. */ | |||||
ttmove(nrow - 1, 0); /* Echo line. */ | |||||
tteeol(); | |||||
tttidy(); | |||||
ttflush(); | |||||
ttclose(); | |||||
} | |||||
/* | |||||
* Move the virtual cursor to an origin | |||||
* 0 spot on the virtual display screen. I could | |||||
* store the column as a character pointer to the spot | |||||
* on the line, which would make "vtputc" a little bit | |||||
* more efficient. No checking for errors. | |||||
*/ | |||||
void | |||||
vtmove(int row, int col) | |||||
{ | |||||
vtrow = row; | |||||
vtcol = col; | |||||
} | |||||
/* | |||||
* Write a character to the virtual display, | |||||
* dealing with long lines and the display of unprintable | |||||
* things like control characters. Also expand tabs every 8 | |||||
* columns. This code only puts printing characters into | |||||
* the virtual display image. Special care must be taken when | |||||
* expanding tabs. On a screen whose width is not a multiple | |||||
* of 8, it is possible for the virtual cursor to hit the | |||||
* right margin before the next tab stop is reached. This | |||||
* makes the tab code loop if you are not careful. | |||||
* Three guesses how we found this. | |||||
*/ | |||||
void | |||||
vtputc(int c) | |||||
{ | |||||
struct video *vp; | |||||
c &= 0xff; | |||||
vp = vscreen[vtrow]; | |||||
if (vtcol >= ncol) | |||||
vp->v_text[ncol - 1] = '$'; | |||||
else if (c == '\t' | |||||
#ifdef NOTAB | |||||
&& !(curbp->b_flag & BFNOTAB) | |||||
#endif | |||||
) { | |||||
do { | |||||
vtputc(' '); | |||||
} while (vtcol < ncol && (vtcol & 0x07) != 0); | |||||
} else if (ISCTRL(c)) { | |||||
vtputc('^'); | |||||
vtputc(CCHR(c)); | |||||
} else if (isprint(c)) | |||||
vp->v_text[vtcol++] = c; | |||||
else { | |||||
char bf[5]; | |||||
snprintf(bf, sizeof(bf), "\\%o", c); | |||||
vtputs(bf); | |||||
} | |||||
} | |||||
/* | |||||
* Put a character to the virtual screen in an extended line. If we are not | |||||
* yet on left edge, don't print it yet. Check for overflow on the right | |||||
* margin. | |||||
*/ | |||||
void | |||||
vtpute(int c) | |||||
{ | |||||
struct video *vp; | |||||
c &= 0xff; | |||||
vp = vscreen[vtrow]; | |||||
if (vtcol >= ncol) | |||||
vp->v_text[ncol - 1] = '$'; | |||||
else if (c == '\t' | |||||
#ifdef NOTAB | |||||
&& !(curbp->b_flag & BFNOTAB) | |||||
#endif | |||||
) { | |||||
do { | |||||
vtpute(' '); | |||||
} while (((vtcol + lbound) & 0x07) != 0 && vtcol < ncol); | |||||
} else if (ISCTRL(c) != FALSE) { | |||||
vtpute('^'); | |||||
vtpute(CCHR(c)); | |||||
} else if (isprint(c)) { | |||||
if (vtcol >= 0) | |||||
vp->v_text[vtcol] = c; | |||||
++vtcol; | |||||
} else { | |||||
char bf[5], *cp; | |||||
snprintf(bf, sizeof(bf), "\\%o", c); | |||||
for (cp = bf; *cp != '\0'; cp++) | |||||
vtpute(*cp); | |||||
} | |||||
} | |||||
/* | |||||
* Erase from the end of the software cursor to the end of the line on which | |||||
* the software cursor is located. The display routines will decide if a | |||||
* hardware erase to end of line command should be used to display this. | |||||
*/ | |||||
void | |||||
vteeol(void) | |||||
{ | |||||
struct video *vp; | |||||
vp = vscreen[vtrow]; | |||||
while (vtcol < ncol) | |||||
vp->v_text[vtcol++] = ' '; | |||||
} | |||||
/* | |||||
* Make sure that the display is | |||||
* right. This is a three part process. First, | |||||
* scan through all of the windows looking for dirty | |||||
* ones. Check the framing, and refresh the screen. | |||||
* Second, make sure that "currow" and "curcol" are | |||||
* correct for the current window. Third, make the | |||||
* virtual and physical screens the same. | |||||
*/ | |||||
void | |||||
update(int modelinecolor) | |||||
{ | |||||
struct line *lp; | |||||
struct mgwin *wp; | |||||
struct video *vp1; | |||||
struct video *vp2; | |||||
int c, i, j; | |||||
int hflag; | |||||
int currow, curcol; | |||||
int offs, size; | |||||
if (charswaiting()) | |||||
return; | |||||
if (sgarbf) { /* must update everything */ | |||||
wp = wheadp; | |||||
while (wp != NULL) { | |||||
wp->w_rflag |= WFMODE | WFFULL; | |||||
wp = wp->w_wndp; | |||||
} | |||||
} | |||||
if (linenos || colnos) { | |||||
wp = wheadp; | |||||
while (wp != NULL) { | |||||
wp->w_rflag |= WFMODE; | |||||
wp = wp->w_wndp; | |||||
} | |||||
} | |||||
hflag = FALSE; /* Not hard. */ | |||||
for (wp = wheadp; wp != NULL; wp = wp->w_wndp) { | |||||
/* | |||||
* Nothing to be done. | |||||
*/ | |||||
if (wp->w_rflag == 0) | |||||
continue; | |||||
if ((wp->w_rflag & WFFRAME) == 0) { | |||||
lp = wp->w_linep; | |||||
for (i = 0; i < wp->w_ntrows; ++i) { | |||||
if (lp == wp->w_dotp) | |||||
goto out; | |||||
if (lp == wp->w_bufp->b_headp) | |||||
break; | |||||
lp = lforw(lp); | |||||
} | |||||
} | |||||
/* | |||||
* Put the middle-line in place. | |||||
*/ | |||||
i = wp->w_frame; | |||||
if (i > 0) { | |||||
--i; | |||||
if (i >= wp->w_ntrows) | |||||
i = wp->w_ntrows - 1; | |||||
} else if (i < 0) { | |||||
i += wp->w_ntrows; | |||||
if (i < 0) | |||||
i = 0; | |||||
} else | |||||
i = wp->w_ntrows / 2; /* current center, no change */ | |||||
/* | |||||
* Find the line. | |||||
*/ | |||||
lp = wp->w_dotp; | |||||
while (i != 0 && lback(lp) != wp->w_bufp->b_headp) { | |||||
--i; | |||||
lp = lback(lp); | |||||
} | |||||
wp->w_linep = lp; | |||||
wp->w_rflag |= WFFULL; /* Force full. */ | |||||
out: | |||||
lp = wp->w_linep; /* Try reduced update. */ | |||||
i = wp->w_toprow; | |||||
if ((wp->w_rflag & ~WFMODE) == WFEDIT) { | |||||
while (lp != wp->w_dotp) { | |||||
++i; | |||||
lp = lforw(lp); | |||||
} | |||||
vscreen[i]->v_color = CTEXT; | |||||
vscreen[i]->v_flag |= (VFCHG | VFHBAD); | |||||
vtmove(i, 0); | |||||
for (j = 0; j < llength(lp); ++j) | |||||
vtputc(lgetc(lp, j)); | |||||
vteeol(); | |||||
} else if ((wp->w_rflag & (WFEDIT | WFFULL)) != 0) { | |||||
hflag = TRUE; | |||||
while (i < wp->w_toprow + wp->w_ntrows) { | |||||
vscreen[i]->v_color = CTEXT; | |||||
vscreen[i]->v_flag |= (VFCHG | VFHBAD); | |||||
vtmove(i, 0); | |||||
if (lp != wp->w_bufp->b_headp) { | |||||
for (j = 0; j < llength(lp); ++j) | |||||
vtputc(lgetc(lp, j)); | |||||
lp = lforw(lp); | |||||
} | |||||
vteeol(); | |||||
++i; | |||||
} | |||||
} | |||||
if ((wp->w_rflag & WFMODE) != 0) | |||||
modeline(wp, modelinecolor); | |||||
wp->w_rflag = 0; | |||||
wp->w_frame = 0; | |||||
} | |||||
lp = curwp->w_linep; /* Cursor location. */ | |||||
currow = curwp->w_toprow; | |||||
while (lp != curwp->w_dotp) { | |||||
++currow; | |||||
lp = lforw(lp); | |||||
} | |||||
curcol = 0; | |||||
i = 0; | |||||
while (i < curwp->w_doto) { | |||||
c = lgetc(lp, i++); | |||||
if (c == '\t' | |||||
#ifdef NOTAB | |||||
&& !(curbp->b_flag & BFNOTAB) | |||||
#endif | |||||
) { | |||||
curcol |= 0x07; | |||||
curcol++; | |||||
} else if (ISCTRL(c) != FALSE) | |||||
curcol += 2; | |||||
else if (isprint(c)) | |||||
curcol++; | |||||
else { | |||||
char bf[5]; | |||||
snprintf(bf, sizeof(bf), "\\%o", c); | |||||
curcol += strlen(bf); | |||||
} | |||||
} | |||||
if (curcol >= ncol - 1) { /* extended line. */ | |||||
/* flag we are extended and changed */ | |||||
vscreen[currow]->v_flag |= VFEXT | VFCHG; | |||||
updext(currow, curcol); /* and output extended line */ | |||||
} else | |||||
lbound = 0; /* not extended line */ | |||||
/* | |||||
* Make sure no lines need to be de-extended because the cursor is no | |||||
* longer on them. | |||||
*/ | |||||
wp = wheadp; | |||||
while (wp != NULL) { | |||||
lp = wp->w_linep; | |||||
i = wp->w_toprow; | |||||
while (i < wp->w_toprow + wp->w_ntrows) { | |||||
if (vscreen[i]->v_flag & VFEXT) { | |||||
/* always flag extended lines as changed */ | |||||
vscreen[i]->v_flag |= VFCHG; | |||||
if ((wp != curwp) || (lp != wp->w_dotp) || | |||||
(curcol < ncol - 1)) { | |||||
vtmove(i, 0); | |||||
for (j = 0; j < llength(lp); ++j) | |||||
vtputc(lgetc(lp, j)); | |||||
vteeol(); | |||||
/* this line no longer is extended */ | |||||
vscreen[i]->v_flag &= ~VFEXT; | |||||
} | |||||
} | |||||
lp = lforw(lp); | |||||
++i; | |||||
} | |||||
/* if garbaged then fix up mode lines */ | |||||
if (sgarbf != FALSE) | |||||
vscreen[i]->v_flag |= VFCHG; | |||||
/* and onward to the next window */ | |||||
wp = wp->w_wndp; | |||||
} | |||||
if (sgarbf != FALSE) { /* Screen is garbage. */ | |||||
sgarbf = FALSE; /* Erase-page clears. */ | |||||
epresf = FALSE; /* The message area. */ | |||||
tttop = HUGE; /* Forget where you set. */ | |||||
ttbot = HUGE; /* scroll region. */ | |||||
tthue = CNONE; /* Color unknown. */ | |||||
ttmove(0, 0); | |||||
tteeop(); | |||||
for (i = 0; i < nrow - 1; ++i) { | |||||
uline(i, vscreen[i], &blanks); | |||||
ucopy(vscreen[i], pscreen[i]); | |||||
} | |||||
ttmove(currow, curcol - lbound); | |||||
ttflush(); | |||||
return; | |||||
} | |||||
if (hflag != FALSE) { /* Hard update? */ | |||||
for (i = 0; i < nrow - 1; ++i) {/* Compute hash data. */ | |||||
hash(vscreen[i]); | |||||
hash(pscreen[i]); | |||||
} | |||||
offs = 0; /* Get top match. */ | |||||
while (offs != nrow - 1) { | |||||
vp1 = vscreen[offs]; | |||||
vp2 = pscreen[offs]; | |||||
if (vp1->v_color != vp2->v_color | |||||
|| vp1->v_hash != vp2->v_hash) | |||||
break; | |||||
uline(offs, vp1, vp2); | |||||
ucopy(vp1, vp2); | |||||
++offs; | |||||
} | |||||
if (offs == nrow - 1) { /* Might get it all. */ | |||||
ttmove(currow, curcol - lbound); | |||||
ttflush(); | |||||
return; | |||||
} | |||||
size = nrow - 1; /* Get bottom match. */ | |||||
while (size != offs) { | |||||
vp1 = vscreen[size - 1]; | |||||
vp2 = pscreen[size - 1]; | |||||
if (vp1->v_color != vp2->v_color | |||||
|| vp1->v_hash != vp2->v_hash) | |||||
break; | |||||
uline(size - 1, vp1, vp2); | |||||
ucopy(vp1, vp2); | |||||
--size; | |||||
} | |||||
if ((size -= offs) == 0) /* Get screen size. */ | |||||
panic("Illegal screen size in update"); | |||||
setscores(offs, size); /* Do hard update. */ | |||||
traceback(offs, size, size, size); | |||||
for (i = 0; i < size; ++i) | |||||
ucopy(vscreen[offs + i], pscreen[offs + i]); | |||||
ttmove(currow, curcol - lbound); | |||||
ttflush(); | |||||
return; | |||||
} | |||||
for (i = 0; i < nrow - 1; ++i) { /* Easy update. */ | |||||
vp1 = vscreen[i]; | |||||
vp2 = pscreen[i]; | |||||
if ((vp1->v_flag & VFCHG) != 0) { | |||||
uline(i, vp1, vp2); | |||||
ucopy(vp1, vp2); | |||||
} | |||||
} | |||||
ttmove(currow, curcol - lbound); | |||||
ttflush(); | |||||
} | |||||
/* | |||||
* Update a saved copy of a line, | |||||
* kept in a video structure. The "vvp" is | |||||
* the one in the "vscreen". The "pvp" is the one | |||||
* in the "pscreen". This is called to make the | |||||
* virtual and physical screens the same when | |||||
* display has done an update. | |||||
*/ | |||||
void | |||||
ucopy(struct video *vvp, struct video *pvp) | |||||
{ | |||||
vvp->v_flag &= ~VFCHG; /* Changes done. */ | |||||
pvp->v_flag = vvp->v_flag; /* Update model. */ | |||||
pvp->v_hash = vvp->v_hash; | |||||
pvp->v_cost = vvp->v_cost; | |||||
pvp->v_color = vvp->v_color; | |||||
bcopy(vvp->v_text, pvp->v_text, ncol); | |||||
} | |||||
/* | |||||
* updext: update the extended line which the cursor is currently on at a | |||||
* column greater than the terminal width. The line will be scrolled right or | |||||
* left to let the user see where the cursor is. | |||||
*/ | |||||
void | |||||
updext(int currow, int curcol) | |||||
{ | |||||
struct line *lp; /* pointer to current line */ | |||||
int j; /* index into line */ | |||||
if (ncol < 2) | |||||
return; | |||||
/* | |||||
* calculate what column the left bound should be | |||||
* (force cursor into middle half of screen) | |||||
*/ | |||||
lbound = curcol - (curcol % (ncol >> 1)) - (ncol >> 2); | |||||
/* | |||||
* scan through the line outputing characters to the virtual screen | |||||
* once we reach the left edge | |||||
*/ | |||||
vtmove(currow, -lbound); /* start scanning offscreen */ | |||||
lp = curwp->w_dotp; /* line to output */ | |||||
for (j = 0; j < llength(lp); ++j) /* until the end-of-line */ | |||||
vtpute(lgetc(lp, j)); | |||||
vteeol(); /* truncate the virtual line */ | |||||
vscreen[currow]->v_text[0] = '$'; /* and put a '$' in column 1 */ | |||||
} | |||||
/* | |||||
* Update a single line. This routine only | |||||
* uses basic functionality (no insert and delete character, | |||||
* but erase to end of line). The "vvp" points at the video | |||||
* structure for the line on the virtual screen, and the "pvp" | |||||
* is the same for the physical screen. Avoid erase to end of | |||||
* line when updating CMODE color lines, because of the way that | |||||
* reverse video works on most terminals. | |||||
*/ | |||||
void | |||||
uline(int row, struct video *vvp, struct video *pvp) | |||||
{ | |||||
char *cp1; | |||||
char *cp2; | |||||
char *cp3; | |||||
char *cp4; | |||||
char *cp5; | |||||
int nbflag; | |||||
if (vvp->v_color != pvp->v_color) { /* Wrong color, do a */ | |||||
ttmove(row, 0); /* full redraw. */ | |||||
#ifdef STANDOUT_GLITCH | |||||
if (pvp->v_color != CTEXT && magic_cookie_glitch >= 0) | |||||
tteeol(); | |||||
#endif | |||||
ttcolor(vvp->v_color); | |||||
#ifdef STANDOUT_GLITCH | |||||
cp1 = &vvp->v_text[magic_cookie_glitch > 0 ? magic_cookie_glitch : 0]; | |||||
/* | |||||
* The odd code for magic_cookie_glitch==0 is to avoid | |||||
* putting the invisible glitch character on the next line. | |||||
* (Hazeltine executive 80 model 30) | |||||
*/ | |||||
cp2 = &vvp->v_text[ncol - (magic_cookie_glitch >= 0 ? | |||||
(magic_cookie_glitch != 0 ? magic_cookie_glitch : 1) : 0)]; | |||||
#else | |||||
cp1 = &vvp->v_text[0]; | |||||
cp2 = &vvp->v_text[ncol]; | |||||
#endif | |||||
while (cp1 != cp2) { | |||||
ttputc(*cp1++); | |||||
++ttcol; | |||||
} | |||||
ttcolor(CTEXT); | |||||
return; | |||||
} | |||||
cp1 = &vvp->v_text[0]; /* Compute left match. */ | |||||
cp2 = &pvp->v_text[0]; | |||||
while (cp1 != &vvp->v_text[ncol] && cp1[0] == cp2[0]) { | |||||
++cp1; | |||||
++cp2; | |||||
} | |||||
if (cp1 == &vvp->v_text[ncol]) /* All equal. */ | |||||
return; | |||||
nbflag = FALSE; | |||||
cp3 = &vvp->v_text[ncol]; /* Compute right match. */ | |||||
cp4 = &pvp->v_text[ncol]; | |||||
while (cp3[-1] == cp4[-1]) { | |||||
--cp3; | |||||
--cp4; | |||||
if (cp3[0] != ' ') /* Note non-blanks in */ | |||||
nbflag = TRUE; /* the right match. */ | |||||
} | |||||
cp5 = cp3; /* Is erase good? */ | |||||
if (nbflag == FALSE && vvp->v_color == CTEXT) { | |||||
while (cp5 != cp1 && cp5[-1] == ' ') | |||||
--cp5; | |||||
/* Alcyon hack */ | |||||
if ((int) (cp3 - cp5) <= tceeol) | |||||
cp5 = cp3; | |||||
} | |||||
/* Alcyon hack */ | |||||
ttmove(row, (int) (cp1 - &vvp->v_text[0])); | |||||
#ifdef STANDOUT_GLITCH | |||||
if (vvp->v_color != CTEXT && magic_cookie_glitch > 0) { | |||||
if (cp1 < &vvp->v_text[magic_cookie_glitch]) | |||||
cp1 = &vvp->v_text[magic_cookie_glitch]; | |||||
if (cp5 > &vvp->v_text[ncol - magic_cookie_glitch]) | |||||
cp5 = &vvp->v_text[ncol - magic_cookie_glitch]; | |||||
} else if (magic_cookie_glitch < 0) | |||||
#endif | |||||
ttcolor(vvp->v_color); | |||||
while (cp1 != cp5) { | |||||
ttputc(*cp1++); | |||||
++ttcol; | |||||
} | |||||
if (cp5 != cp3) /* Do erase. */ | |||||
tteeol(); | |||||
} | |||||
/* | |||||
* Redisplay the mode line for the window pointed to by the "wp". | |||||
* This is the only routine that has any idea of how the mode line is | |||||
* formatted. You can change the modeline format by hacking at this | |||||
* routine. Called by "update" any time there is a dirty window. Note | |||||
* that if STANDOUT_GLITCH is defined, first and last magic_cookie_glitch | |||||
* characters may never be seen. | |||||
*/ | |||||
void | |||||
modeline(struct mgwin *wp, int modelinecolor) | |||||
{ | |||||
int n, md; | |||||
struct buffer *bp; | |||||
char sl[21]; /* Overkill. Space for 2^64 in base 10. */ | |||||
int len; | |||||
n = wp->w_toprow + wp->w_ntrows; /* Location. */ | |||||
vscreen[n]->v_color = modelinecolor; /* Mode line color. */ | |||||
vscreen[n]->v_flag |= (VFCHG | VFHBAD); /* Recompute, display. */ | |||||
vtmove(n, 0); /* Seek to right line. */ | |||||
bp = wp->w_bufp; | |||||
vtputc('-'); | |||||
vtputc('-'); | |||||
if ((bp->b_flag & BFREADONLY) != 0) { | |||||
vtputc('%'); | |||||
if ((bp->b_flag & BFCHG) != 0) | |||||
vtputc('*'); | |||||
else | |||||
vtputc('%'); | |||||
} else if ((bp->b_flag & BFCHG) != 0) { /* "*" if changed. */ | |||||
vtputc('*'); | |||||
vtputc('*'); | |||||
} else { | |||||
vtputc('-'); | |||||
vtputc('-'); | |||||
} | |||||
vtputc('-'); | |||||
n = 5; | |||||
n += vtputs("Mg: "); | |||||
if (bp->b_bname[0] != '\0') | |||||
n += vtputs(&(bp->b_bname[0])); | |||||
while (n < 42) { /* Pad out with blanks. */ | |||||
vtputc(' '); | |||||
++n; | |||||
} | |||||
vtputc('('); | |||||
++n; | |||||
for (md = 0; ; ) { | |||||
n += vtputs(bp->b_modes[md]->p_name); | |||||
if (++md > bp->b_nmodes) | |||||
break; | |||||
vtputc('-'); | |||||
++n; | |||||
} | |||||
/* XXX These should eventually move to a real mode */ | |||||
if (macrodef == TRUE) | |||||
n += vtputs("-def"); | |||||
if (globalwd == TRUE) | |||||
n += vtputs("-gwd"); | |||||
vtputc(')'); | |||||
++n; | |||||
if (linenos && colnos) | |||||
len = snprintf(sl, sizeof(sl), "--L%d--C%d", wp->w_dotline, | |||||
getcolpos(wp)); | |||||
else if (linenos) | |||||
len = snprintf(sl, sizeof(sl), "--L%d", wp->w_dotline); | |||||
else if (colnos) | |||||
len = snprintf(sl, sizeof(sl), "--C%d", getcolpos(wp)); | |||||
if ((linenos || colnos) && len < sizeof(sl) && len != -1) | |||||
n += vtputs(sl); | |||||
while (n < ncol) { /* Pad out. */ | |||||
vtputc('-'); | |||||
++n; | |||||
} | |||||
} | |||||
/* | |||||
* Output a string to the mode line, report how long it was. | |||||
*/ | |||||
int | |||||
vtputs(const char *s) | |||||
{ | |||||
int n = 0; | |||||
while (*s != '\0') { | |||||
vtputc(*s++); | |||||
++n; | |||||
} | |||||
return (n); | |||||
} | |||||
/* | |||||
* Compute the hash code for the line pointed to by the "vp". | |||||
* Recompute it if necessary. Also set the approximate redisplay | |||||
* cost. The validity of the hash code is marked by a flag bit. | |||||
* The cost understand the advantages of erase to end of line. | |||||
* Tuned for the VAX by Bob McNamara; better than it used to be on | |||||
* just about any machine. | |||||
*/ | |||||
void | |||||
hash(struct video *vp) | |||||
{ | |||||
int i, n; | |||||
char *s; | |||||
if ((vp->v_flag & VFHBAD) != 0) { /* Hash bad. */ | |||||
s = &vp->v_text[ncol - 1]; | |||||
for (i = ncol; i != 0; --i, --s) | |||||
if (*s != ' ') | |||||
break; | |||||
n = ncol - i; /* Erase cheaper? */ | |||||
if (n > tceeol) | |||||
n = tceeol; | |||||
vp->v_cost = i + n; /* Bytes + blanks. */ | |||||
for (n = 0; i != 0; --i, --s) | |||||
n = (n << 5) + n + *s; | |||||
vp->v_hash = n; /* Hash code. */ | |||||
vp->v_flag &= ~VFHBAD; /* Flag as all done. */ | |||||
} | |||||
} | |||||
/* | |||||
* Compute the Insert-Delete | |||||
* cost matrix. The dynamic programming algorithm | |||||
* described by James Gosling is used. This code assumes | |||||
* that the line above the echo line is the last line involved | |||||
* in the scroll region. This is easy to arrange on the VT100 | |||||
* because of the scrolling region. The "offs" is the origin 0 | |||||
* offset of the first row in the virtual/physical screen that | |||||
* is being updated; the "size" is the length of the chunk of | |||||
* screen being updated. For a full screen update, use offs=0 | |||||
* and size=nrow-1. | |||||
* | |||||
* Older versions of this code implemented the score matrix by | |||||
* a two dimensional array of SCORE nodes. This put all kinds of | |||||
* multiply instructions in the code! This version is written to | |||||
* use a linear array and pointers, and contains no multiplication | |||||
* at all. The code has been carefully looked at on the VAX, with | |||||
* only marginal checking on other machines for efficiency. In | |||||
* fact, this has been tuned twice! Bob McNamara tuned it even | |||||
* more for the VAX, which is a big issue for him because of | |||||
* the 66 line X displays. | |||||
* | |||||
* On some machines, replacing the "for (i=1; i<=size; ++i)" with | |||||
* i = 1; do { } while (++i <=size)" will make the code quite a | |||||
* bit better; but it looks ugly. | |||||
*/ | |||||
void | |||||
setscores(int offs, int size) | |||||
{ | |||||
struct score *sp; | |||||
struct score *sp1; | |||||
struct video **vp, **pp; | |||||
struct video **vbase, **pbase; | |||||
int tempcost; | |||||
int bestcost; | |||||
int j, i; | |||||
vbase = &vscreen[offs - 1]; /* By hand CSE's. */ | |||||
pbase = &pscreen[offs - 1]; | |||||
score[0].s_itrace = 0; /* [0, 0] */ | |||||
score[0].s_jtrace = 0; | |||||
score[0].s_cost = 0; | |||||
sp = &score[1]; /* Row 0, inserts. */ | |||||
tempcost = 0; | |||||
vp = &vbase[1]; | |||||
for (j = 1; j <= size; ++j) { | |||||
sp->s_itrace = 0; | |||||
sp->s_jtrace = j - 1; | |||||
tempcost += tcinsl; | |||||
tempcost += (*vp)->v_cost; | |||||
sp->s_cost = tempcost; | |||||
++vp; | |||||
++sp; | |||||
} | |||||
sp = &score[nrow]; /* Column 0, deletes. */ | |||||
tempcost = 0; | |||||
for (i = 1; i <= size; ++i) { | |||||
sp->s_itrace = i - 1; | |||||
sp->s_jtrace = 0; | |||||
tempcost += tcdell; | |||||
sp->s_cost = tempcost; | |||||
sp += nrow; | |||||
} | |||||
sp1 = &score[nrow + 1]; /* [1, 1]. */ | |||||
pp = &pbase[1]; | |||||
for (i = 1; i <= size; ++i) { | |||||
sp = sp1; | |||||
vp = &vbase[1]; | |||||
for (j = 1; j <= size; ++j) { | |||||
sp->s_itrace = i - 1; | |||||
sp->s_jtrace = j; | |||||
bestcost = (sp - nrow)->s_cost; | |||||
if (j != size) /* Cd(A[i])=0 @ Dis. */ | |||||
bestcost += tcdell; | |||||
tempcost = (sp - 1)->s_cost; | |||||
tempcost += (*vp)->v_cost; | |||||
if (i != size) /* Ci(B[j])=0 @ Dsj. */ | |||||
tempcost += tcinsl; | |||||
if (tempcost < bestcost) { | |||||
sp->s_itrace = i; | |||||
sp->s_jtrace = j - 1; | |||||
bestcost = tempcost; | |||||
} | |||||
tempcost = (sp - nrow - 1)->s_cost; | |||||
if ((*pp)->v_color != (*vp)->v_color | |||||
|| (*pp)->v_hash != (*vp)->v_hash) | |||||
tempcost += (*vp)->v_cost; | |||||
if (tempcost < bestcost) { | |||||
sp->s_itrace = i - 1; | |||||
sp->s_jtrace = j - 1; | |||||
bestcost = tempcost; | |||||
} | |||||
sp->s_cost = bestcost; | |||||
++sp; /* Next column. */ | |||||
++vp; | |||||
} | |||||
++pp; | |||||
sp1 += nrow; /* Next row. */ | |||||
} | |||||
} | |||||
/* | |||||
* Trace back through the dynamic programming cost | |||||
* matrix, and update the screen using an optimal sequence | |||||
* of redraws, insert lines, and delete lines. The "offs" is | |||||
* the origin 0 offset of the chunk of the screen we are about to | |||||
* update. The "i" and "j" are always started in the lower right | |||||
* corner of the matrix, and imply the size of the screen. | |||||
* A full screen traceback is called with offs=0 and i=j=nrow-1. | |||||
* There is some do-it-yourself double subscripting here, | |||||
* which is acceptable because this routine is much less compute | |||||
* intensive then the code that builds the score matrix! | |||||
*/ | |||||
void | |||||
traceback(int offs, int size, int i, int j) | |||||
{ | |||||
int itrace, jtrace; | |||||
int k; | |||||
int ninsl, ndraw, ndell; | |||||
if (i == 0 && j == 0) /* End of update. */ | |||||
return; | |||||
itrace = score[(nrow * i) + j].s_itrace; | |||||
jtrace = score[(nrow * i) + j].s_jtrace; | |||||
if (itrace == i) { /* [i, j-1] */ | |||||
ninsl = 0; /* Collect inserts. */ | |||||
if (i != size) | |||||
ninsl = 1; | |||||
ndraw = 1; | |||||
while (itrace != 0 || jtrace != 0) { | |||||
if (score[(nrow * itrace) + jtrace].s_itrace != itrace) | |||||
break; | |||||
jtrace = score[(nrow * itrace) + jtrace].s_jtrace; | |||||
if (i != size) | |||||
++ninsl; | |||||
++ndraw; | |||||
} | |||||
traceback(offs, size, itrace, jtrace); | |||||
if (ninsl != 0) { | |||||
ttcolor(CTEXT); | |||||
ttinsl(offs + j - ninsl, offs + size - 1, ninsl); | |||||
} | |||||
do { /* B[j], A[j] blank. */ | |||||
k = offs + j - ndraw; | |||||
uline(k, vscreen[k], &blanks); | |||||
} while (--ndraw); | |||||
return; | |||||
} | |||||
if (jtrace == j) { /* [i-1, j] */ | |||||
ndell = 0; /* Collect deletes. */ | |||||
if (j != size) | |||||
ndell = 1; | |||||
while (itrace != 0 || jtrace != 0) { | |||||
if (score[(nrow * itrace) + jtrace].s_jtrace != jtrace) | |||||
break; | |||||
itrace = score[(nrow * itrace) + jtrace].s_itrace; | |||||
if (j != size) | |||||
++ndell; | |||||
} | |||||
if (ndell != 0) { | |||||
ttcolor(CTEXT); | |||||
ttdell(offs + i - ndell, offs + size - 1, ndell); | |||||
} | |||||
traceback(offs, size, itrace, jtrace); | |||||
return; | |||||
} | |||||
traceback(offs, size, itrace, jtrace); | |||||
k = offs + j - 1; | |||||
uline(k, vscreen[k], pscreen[offs + i - 1]); | |||||
} |