2 * Copyright (c) 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1992, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
7 * See the LICENSE file for redistribution information.
13 static const char sccsid[] = "@(#)vs_line.c 10.19 (Berkeley) 9/26/96";
16 #include <sys/types.h>
17 #include <sys/queue.h>
20 #include <bitstring.h>
25 #include "../common/common.h"
28 #ifdef VISIBLE_TAB_CHARS
36 * Update one line on the screen.
38 * PUBLIC: int vs_line __P((SCR *, SMAP *, size_t *, size_t *));
41 vs_line(sp, smp, yp, xp)
49 size_t chlen, cno_cnt, cols_per_screen, len, nlen;
50 size_t offset_in_char, offset_in_line, oldx, oldy;
51 size_t scno, skip_cols, skip_screens;
52 int ch, dne, is_cached, is_partial, is_tab;
53 int list_tab, list_dollar;
54 char *p, *cbp, *ecbp, cbuf[128];
56 #if defined(DEBUG) && 0
57 TRACE(sp, "vs_line: row %u: line: %u off: %u\n",
58 smp - HMAP, smp->lno, smp->off);
61 * If ex modifies the screen after ex output is already on the screen,
62 * don't touch it -- we'll get scrolling wrong, at best.
64 if (!F_ISSET(sp, SC_TINPUT_INFO) && VIP(sp)->totalcount > 1)
66 if (F_ISSET(sp, SC_SCR_EXWROTE) && smp - HMAP != LASTLINE(sp))
70 * Assume that, if the cache entry for the line is filled in, the
71 * line is already on the screen, and all we need to do is return
72 * the cursor position. If the calling routine doesn't need the
73 * cursor position, we can just return.
75 is_cached = SMAP_CACHE(smp);
76 if (yp == NULL && is_cached)
80 * A nasty side effect of this routine is that it returns the screen
81 * position for the "current" character. Not pretty, but this is the
82 * only routine that really knows what's out there.
84 * Move to the line. This routine can be called by vs_sm_position(),
85 * which uses it to fill in the cache entry so it can figure out what
86 * the real contents of the screen are. Because of this, we have to
87 * return to whereever we started from.
90 (void)gp->scr_cursor(sp, &oldy, &oldx);
91 (void)gp->scr_move(sp, smp - HMAP, 0);
94 dne = db_get(sp, smp->lno, 0, &p, &len);
97 * Special case if we're printing the info/mode line. Skip printing
98 * the leading number, as well as other minor setup. The only time
99 * this code paints the mode line is when the user is entering text
100 * for a ":" command, so we can put the code here instead of dealing
101 * with the empty line logic below. This is a kludge, but it's pretty
102 * much confined to this module.
104 * Set the number of columns for this screen.
105 * Set the number of chars or screens to skip until a character is to
108 cols_per_screen = sp->cols;
109 if (O_ISSET(sp, O_LEFTRIGHT)) {
111 skip_cols = smp->coff;
113 skip_screens = smp->soff - 1;
114 skip_cols = skip_screens * cols_per_screen;
117 list_tab = O_ISSET(sp, O_LIST);
118 if (F_ISSET(sp, SC_TINPUT_INFO))
121 list_dollar = list_tab;
124 * If O_NUMBER is set, the line doesn't exist and it's line
125 * number 1, i.e., an empty file, display the line number.
127 * If O_NUMBER is set, the line exists and the first character
128 * on the screen is the first character in the line, display
132 * If O_NUMBER set, decrement the number of columns in the
133 * first screen. DO NOT CHANGE THIS -- IT'S RIGHT! The
134 * rest of the code expects this to reflect the number of
135 * columns in the first screen, regardless of the number of
136 * columns we're going to skip.
138 if (O_ISSET(sp, O_NUMBER)) {
139 cols_per_screen -= O_NUMBER_LENGTH;
140 if ((!dne || smp->lno == 1) && skip_cols == 0) {
141 nlen = snprintf(cbuf, sizeof(cbuf),
142 O_NUMBER_FMT, (u_long)smp->lno);
143 (void)gp->scr_addstr(sp, cbuf, nlen);
149 * Special case non-existent lines and the first line of an empty
150 * file. In both cases, the cursor position is 0, but corrected
151 * as necessary for the O_NUMBER field, if it was displayed.
153 if (dne || len == 0) {
154 /* Fill in the cursor. */
155 if (yp != NULL && smp->lno == sp->lno) {
157 *xp = sp->cols - cols_per_screen;
160 /* If the line is on the screen, quit. */
164 /* Set line cache information. */
165 smp->c_sboff = smp->c_eboff = 0;
166 smp->c_scoff = smp->c_eclen = 0;
169 * Lots of special cases for empty lines, but they only apply
170 * if we're displaying the first screen of the line.
186 empty: (void)gp->scr_addstr(sp,
187 KEY_NAME(sp, ch), KEY_LEN(sp, ch));
190 (void)gp->scr_clrtoeol(sp);
191 (void)gp->scr_move(sp, oldy, oldx);
196 * If we just wrote this or a previous line, we cached the starting
197 * and ending positions of that line. The way it works is we keep
198 * information about the lines displayed in the SMAP. If we're
199 * painting the screen in the forward direction, this saves us from
200 * reformatting the physical line for every line on the screen. This
201 * wins big on binary files with 10K lines.
203 * Test for the first screen of the line, then the current screen line,
204 * then the line behind us, then do the hard work. Note, it doesn't
205 * do us any good to have a line in front of us -- it would be really
206 * hard to try and figure out tabs in the reverse direction, i.e. how
207 * many spaces a tab takes up in the reverse direction depends on
208 * what characters preceded it.
210 * Test for the first screen of the line.
212 if (skip_cols == 0) {
213 smp->c_sboff = offset_in_line = 0;
214 smp->c_scoff = offset_in_char = 0;
215 p = &p[offset_in_line];
219 /* Test to see if we've seen this exact line before. */
221 offset_in_line = smp->c_sboff;
222 offset_in_char = smp->c_scoff;
223 p = &p[offset_in_line];
225 /* Set cols_per_screen to 2nd and later line length. */
226 if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen)
227 cols_per_screen = sp->cols;
231 /* Test to see if we saw an earlier part of this line before. */
233 SMAP_CACHE(tsmp = smp - 1) && tsmp->lno == smp->lno) {
234 if (tsmp->c_eclen != tsmp->c_ecsize) {
235 offset_in_line = tsmp->c_eboff;
236 offset_in_char = tsmp->c_eclen;
238 offset_in_line = tsmp->c_eboff + 1;
242 /* Put starting info for this line in the cache. */
243 smp->c_sboff = offset_in_line;
244 smp->c_scoff = offset_in_char;
245 p = &p[offset_in_line];
247 /* Set cols_per_screen to 2nd and later line length. */
248 if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen)
249 cols_per_screen = sp->cols;
257 /* Do it the hard way, for leftright scrolling screens. */
258 if (O_ISSET(sp, O_LEFTRIGHT)) {
259 for (; offset_in_line < len; ++offset_in_line) {
260 chlen = (ch = *(u_char *)p++) == '\t' && !list_tab ?
261 TAB_OFF(scno) : KEY_LEN(sp, ch);
262 if ((scno += chlen) >= skip_cols)
266 /* Set cols_per_screen to 2nd and later line length. */
267 cols_per_screen = sp->cols;
269 /* Put starting info for this line in the cache. */
270 if (scno != skip_cols) {
271 smp->c_sboff = offset_in_line;
273 offset_in_char = chlen - (scno - skip_cols);
276 smp->c_sboff = ++offset_in_line;
281 /* Do it the hard way, for historic line-folding screens. */
283 for (; offset_in_line < len; ++offset_in_line) {
284 chlen = (ch = *(u_char *)p++) == '\t' && !list_tab ?
285 TAB_OFF(scno) : KEY_LEN(sp, ch);
286 if ((scno += chlen) < cols_per_screen)
288 scno -= cols_per_screen;
290 /* Set cols_per_screen to 2nd and later line length. */
291 cols_per_screen = sp->cols;
294 * If crossed the last skipped screen boundary, start
295 * displaying the characters.
297 if (--skip_screens == 0)
301 /* Put starting info for this line in the cache. */
303 smp->c_sboff = offset_in_line;
304 smp->c_scoff = offset_in_char = chlen - scno;
307 smp->c_sboff = ++offset_in_line;
314 * Set the number of characters to skip before reaching the cursor
315 * character. Offset by 1 and use 0 as a flag value. Vs_line is
316 * called repeatedly with a valid pointer to a cursor position.
317 * Don't fill anything in unless it's the right line and the right
318 * character, and the right part of the character...
321 smp->lno != sp->lno || sp->cno < offset_in_line ||
322 offset_in_line + cols_per_screen < sp->cno) {
324 /* If the line is on the screen, quit. */
328 cno_cnt = (sp->cno - offset_in_line) + 1;
330 /* This is the loop that actually displays characters. */
331 ecbp = (cbp = cbuf) + sizeof(cbuf) - 1;
332 for (is_partial = 0, scno = 0;
333 offset_in_line < len; ++offset_in_line, offset_in_char = 0) {
334 if ((ch = *(u_char *)p++) == '\t' && !list_tab) {
335 scno += chlen = TAB_OFF(scno) - offset_in_char;
338 scno += chlen = KEY_LEN(sp, ch) - offset_in_char;
343 * Only display up to the right-hand column. Set a flag if
344 * the entire character wasn't displayed for use in setting
345 * the cursor. If reached the end of the line, set the cache
346 * info for the screen. Don't worry about there not being
347 * characters to display on the next screen, its lno/off won't
348 * match up in that case.
350 if (scno >= cols_per_screen) {
352 chlen -= scno - cols_per_screen;
353 smp->c_ecsize = smp->c_eclen = chlen;
354 scno = cols_per_screen;
356 smp->c_ecsize = chlen;
357 chlen -= scno - cols_per_screen;
358 smp->c_eclen = chlen;
360 if (scno > cols_per_screen)
363 smp->c_eboff = offset_in_line;
365 /* Terminate the loop. */
366 offset_in_line = len;
370 * If the caller wants the cursor value, and this was the
371 * cursor character, set the value. There are two ways to
372 * put the cursor on a character -- if it's normal display
373 * mode, it goes on the last column of the character. If
374 * it's input mode, it goes on the first. In normal mode,
375 * set the cursor only if the entire character was displayed.
378 --cno_cnt == 0 && (F_ISSET(sp, SC_TINPUT) || !is_partial)) {
380 if (F_ISSET(sp, SC_TINPUT))
384 if (O_ISSET(sp, O_NUMBER) &&
385 !F_ISSET(sp, SC_TINPUT_INFO) && skip_cols == 0)
386 *xp += O_NUMBER_LENGTH;
388 /* If the line is on the screen, quit. */
393 /* If the line is on the screen, don't display anything. */
399 (void)gp->scr_addstr(sp, cbuf, cbp - cbuf); \
403 * Display the character. We do tab expansion here because
404 * the screen interface doesn't have any way to set the tab
405 * length. Note, it's theoretically possible for chlen to
406 * be larger than cbuf, if the user set a impossibly large
416 if (cbp + chlen >= ecbp)
418 for (kp = KEY_NAME(sp, ch) + offset_in_char; chlen--;)
423 if (scno < cols_per_screen) {
424 /* If didn't paint the whole line, update the cache. */
425 smp->c_ecsize = smp->c_eclen = KEY_LEN(sp, ch);
426 smp->c_eboff = len - 1;
429 * If not the info/mode line, and O_LIST set, and at the
430 * end of the line, and the line ended on this screen,
436 chlen = KEY_LEN(sp, '$');
437 if (cbp + chlen >= ecbp)
439 for (kp = KEY_NAME(sp, '$'); chlen--;)
443 /* If still didn't paint the whole line, clear the rest. */
444 if (scno < cols_per_screen)
445 (void)gp->scr_clrtoeol(sp);
448 /* Flush any buffered characters. */
452 ret1: (void)gp->scr_move(sp, oldy, oldx);
458 * Repaint the numbers on all the lines.
460 * PUBLIC: int vs_number __P((SCR *));
469 size_t len, oldy, oldx;
476 /* No reason to do anything if we're in input mode on the info line. */
477 if (F_ISSET(sp, SC_TINPUT_INFO))
481 * Try and avoid getting the last line in the file, by getting the
482 * line after the last line in the screen -- if it exists, we know
483 * we have to to number all the lines in the screen. Get the one
484 * after the last instead of the last, so that the info line doesn't
485 * fool us. (The problem is that file_lline will lie, and tell us
486 * that the info line is the last line in the file.) If that test
487 * fails, we have to check each line for existence.
489 exist = db_exist(sp, TMAP->lno + 1);
491 (void)gp->scr_cursor(sp, &oldy, &oldx);
492 for (smp = HMAP; smp <= TMAP; ++smp) {
493 /* Numbers are only displayed for the first screen line. */
494 if (O_ISSET(sp, O_LEFTRIGHT)) {
502 * The first line of an empty file gets numbered, otherwise
503 * number any existing line.
505 if (smp->lno != 1 && !exist && !db_exist(sp, smp->lno))
508 (void)gp->scr_move(sp, smp - HMAP, 0);
509 len = snprintf(nbuf, sizeof(nbuf),
510 O_NUMBER_FMT, (u_long)smp->lno);
511 (void)gp->scr_addstr(sp, nbuf, len);
513 (void)gp->scr_move(sp, oldy, oldx);