xref: /freebsd/contrib/nvi/vi/vs_line.c (revision bcd92649c9952c9c9e8845dbd34276a60dd16664)
1 /*-
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.
6  *
7  * See the LICENSE file for redistribution information.
8  */
9 
10 #include "config.h"
11 
12 #ifndef lint
13 static const char sccsid[] = "@(#)vs_line.c	10.19 (Berkeley) 9/26/96";
14 #endif /* not lint */
15 
16 #include <sys/types.h>
17 #include <sys/queue.h>
18 #include <sys/time.h>
19 
20 #include <bitstring.h>
21 #include <limits.h>
22 #include <stdio.h>
23 #include <string.h>
24 
25 #include "../common/common.h"
26 #include "vi.h"
27 
28 #ifdef VISIBLE_TAB_CHARS
29 #define	TABCH	'-'
30 #else
31 #define	TABCH	' '
32 #endif
33 
34 /*
35  * vs_line --
36  *	Update one line on the screen.
37  *
38  * PUBLIC: int vs_line __P((SCR *, SMAP *, size_t *, size_t *));
39  */
40 int
41 vs_line(sp, smp, yp, xp)
42 	SCR *sp;
43 	SMAP *smp;
44 	size_t *xp, *yp;
45 {
46 	CHAR_T *kp;
47 	GS *gp;
48 	SMAP *tsmp;
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];
55 
56 #if defined(DEBUG) && 0
57 	TRACE(sp, "vs_line: row %u: line: %u off: %u\n",
58 	    smp - HMAP, smp->lno, smp->off);
59 #endif
60 	/*
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.
63 	 */
64 	if (!F_ISSET(sp, SC_TINPUT_INFO) && VIP(sp)->totalcount > 1)
65 		return (0);
66 	if (F_ISSET(sp, SC_SCR_EXWROTE) && smp - HMAP != LASTLINE(sp))
67 		return (0);
68 
69 	/*
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.
74 	 */
75 	is_cached = SMAP_CACHE(smp);
76 	if (yp == NULL && is_cached)
77 		return (0);
78 
79 	/*
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.
83 	 *
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.
88 	 */
89 	gp = sp->gp;
90 	(void)gp->scr_cursor(sp, &oldy, &oldx);
91 	(void)gp->scr_move(sp, smp - HMAP, 0);
92 
93 	/* Get the line. */
94 	dne = db_get(sp, smp->lno, 0, &p, &len);
95 
96 	/*
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.
103 	 *
104 	 * Set the number of columns for this screen.
105 	 * Set the number of chars or screens to skip until a character is to
106 	 * be displayed.
107 	 */
108 	cols_per_screen = sp->cols;
109 	if (O_ISSET(sp, O_LEFTRIGHT)) {
110 		skip_screens = 0;
111 		skip_cols = smp->coff;
112 	} else {
113 		skip_screens = smp->soff - 1;
114 		skip_cols = skip_screens * cols_per_screen;
115 	}
116 
117 	list_tab = O_ISSET(sp, O_LIST);
118 	if (F_ISSET(sp, SC_TINPUT_INFO))
119 		list_dollar = 0;
120 	else {
121 		list_dollar = list_tab;
122 
123 		/*
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.
126 		 *
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
129 		 * the line number.
130 		 *
131 		 * !!!
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.
137 		 */
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,
142 				    sizeof(cbuf), O_NUMBER_FMT, smp->lno);
143 				(void)gp->scr_addstr(sp, cbuf, nlen);
144 			}
145 		}
146 	}
147 
148 	/*
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.
152 	 */
153 	if (dne || len == 0) {
154 		/* Fill in the cursor. */
155 		if (yp != NULL && smp->lno == sp->lno) {
156 			*yp = smp - HMAP;
157 			*xp = sp->cols - cols_per_screen;
158 		}
159 
160 		/* If the line is on the screen, quit. */
161 		if (is_cached)
162 			goto ret1;
163 
164 		/* Set line cache information. */
165 		smp->c_sboff = smp->c_eboff = 0;
166 		smp->c_scoff = smp->c_eclen = 0;
167 
168 		/*
169 		 * Lots of special cases for empty lines, but they only apply
170 		 * if we're displaying the first screen of the line.
171 		 */
172 		if (skip_cols == 0)
173 			if (dne) {
174 				if (smp->lno == 1) {
175 					if (list_dollar) {
176 						ch = '$';
177 						goto empty;
178 					}
179 				} else {
180 					ch = '~';
181 					goto empty;
182 				}
183 			} else
184 				if (list_dollar) {
185 					ch = '$';
186 empty:					(void)gp->scr_addstr(sp,
187 					    KEY_NAME(sp, ch), KEY_LEN(sp, ch));
188 				}
189 
190 		(void)gp->scr_clrtoeol(sp);
191 		(void)gp->scr_move(sp, oldy, oldx);
192 		return (0);
193 	}
194 
195 	/*
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.
202 	 *
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.
209 	 *
210 	 * Test for the first screen of the line.
211 	 */
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];
216 		goto display;
217 	}
218 
219 	/* Test to see if we've seen this exact line before. */
220 	if (is_cached) {
221 		offset_in_line = smp->c_sboff;
222 		offset_in_char = smp->c_scoff;
223 		p = &p[offset_in_line];
224 
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;
228 		goto display;
229 	}
230 
231 	/* Test to see if we saw an earlier part of this line before. */
232 	if (smp != HMAP &&
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;
237 		} else {
238 			offset_in_line = tsmp->c_eboff + 1;
239 			offset_in_char = 0;
240 		}
241 
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];
246 
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;
250 		goto display;
251 	}
252 
253 	scno = 0;
254 	offset_in_line = 0;
255 	offset_in_char = 0;
256 
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)
263 				break;
264 		}
265 
266 		/* Set cols_per_screen to 2nd and later line length. */
267 		cols_per_screen = sp->cols;
268 
269 		/* Put starting info for this line in the cache. */
270 		if (scno != skip_cols) {
271 			smp->c_sboff = offset_in_line;
272 			smp->c_scoff =
273 			    offset_in_char = chlen - (scno - skip_cols);
274 			--p;
275 		} else {
276 			smp->c_sboff = ++offset_in_line;
277 			smp->c_scoff = 0;
278 		}
279 	}
280 
281 	/* Do it the hard way, for historic line-folding screens. */
282 	else {
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)
287 				continue;
288 			scno -= cols_per_screen;
289 
290 			/* Set cols_per_screen to 2nd and later line length. */
291 			cols_per_screen = sp->cols;
292 
293 			/*
294 			 * If crossed the last skipped screen boundary, start
295 			 * displaying the characters.
296 			 */
297 			if (--skip_screens == 0)
298 				break;
299 		}
300 
301 		/* Put starting info for this line in the cache. */
302 		if (scno != 0) {
303 			smp->c_sboff = offset_in_line;
304 			smp->c_scoff = offset_in_char = chlen - scno;
305 			--p;
306 		} else {
307 			smp->c_sboff = ++offset_in_line;
308 			smp->c_scoff = 0;
309 		}
310 	}
311 
312 display:
313 	/*
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...
319 	 */
320 	if (yp == NULL ||
321 	    smp->lno != sp->lno || sp->cno < offset_in_line ||
322 	    offset_in_line + cols_per_screen < sp->cno) {
323 		cno_cnt = 0;
324 		/* If the line is on the screen, quit. */
325 		if (is_cached)
326 			goto ret1;
327 	} else
328 		cno_cnt = (sp->cno - offset_in_line) + 1;
329 
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;
336 			is_tab = 1;
337 		} else {
338 			scno += chlen = KEY_LEN(sp, ch) - offset_in_char;
339 			is_tab = 0;
340 		}
341 
342 		/*
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.
349 		 */
350 		if (scno >= cols_per_screen) {
351 			if (is_tab == 1) {
352 				chlen -= scno - cols_per_screen;
353 				smp->c_ecsize = smp->c_eclen = chlen;
354 				scno = cols_per_screen;
355 			} else {
356 				smp->c_ecsize = chlen;
357 				chlen -= scno - cols_per_screen;
358 				smp->c_eclen = chlen;
359 
360 				if (scno > cols_per_screen)
361 					is_partial = 1;
362 			}
363 			smp->c_eboff = offset_in_line;
364 
365 			/* Terminate the loop. */
366 			offset_in_line = len;
367 		}
368 
369 		/*
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.
376 		 */
377 		if (cno_cnt &&
378 		    --cno_cnt == 0 && (F_ISSET(sp, SC_TINPUT) || !is_partial)) {
379 			*yp = smp - HMAP;
380 			if (F_ISSET(sp, SC_TINPUT))
381 				*xp = scno - chlen;
382 			else
383 				*xp = scno - 1;
384 			if (O_ISSET(sp, O_NUMBER) &&
385 			    !F_ISSET(sp, SC_TINPUT_INFO) && skip_cols == 0)
386 				*xp += O_NUMBER_LENGTH;
387 
388 			/* If the line is on the screen, quit. */
389 			if (is_cached)
390 				goto ret1;
391 		}
392 
393 		/* If the line is on the screen, don't display anything. */
394 		if (is_cached)
395 			continue;
396 
397 #define	FLUSH {								\
398 	*cbp = '\0';							\
399 	(void)gp->scr_addstr(sp, cbuf, cbp - cbuf);			\
400 	cbp = cbuf;							\
401 }
402 		/*
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
407 		 * tabstop.
408 		 */
409 		if (is_tab)
410 			while (chlen--) {
411 				if (cbp >= ecbp)
412 					FLUSH;
413 				*cbp++ = TABCH;
414 			}
415 		else {
416 			if (cbp + chlen >= ecbp)
417 				FLUSH;
418 			for (kp = KEY_NAME(sp, ch) + offset_in_char; chlen--;)
419 				*cbp++ = *kp++;
420 		}
421 	}
422 
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;
427 
428 		/*
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,
431 		 * add a trailing $.
432 		 */
433 		if (list_dollar) {
434 			++scno;
435 
436 			chlen = KEY_LEN(sp, '$');
437 			if (cbp + chlen >= ecbp)
438 				FLUSH;
439 			for (kp = KEY_NAME(sp, '$'); chlen--;)
440 				*cbp++ = *kp++;
441 		}
442 
443 		/* If still didn't paint the whole line, clear the rest. */
444 		if (scno < cols_per_screen)
445 			(void)gp->scr_clrtoeol(sp);
446 	}
447 
448 	/* Flush any buffered characters. */
449 	if (cbp > cbuf)
450 		FLUSH;
451 
452 ret1:	(void)gp->scr_move(sp, oldy, oldx);
453 	return (0);
454 }
455 
456 /*
457  * vs_number --
458  *	Repaint the numbers on all the lines.
459  *
460  * PUBLIC: int vs_number __P((SCR *));
461  */
462 int
463 vs_number(sp)
464 	SCR *sp;
465 {
466 	GS *gp;
467 	SMAP *smp;
468 	VI_PRIVATE *vip;
469 	size_t len, oldy, oldx;
470 	int exist;
471 	char nbuf[10];
472 
473 	gp = sp->gp;
474 	vip = VIP(sp);
475 
476 	/* No reason to do anything if we're in input mode on the info line. */
477 	if (F_ISSET(sp, SC_TINPUT_INFO))
478 		return (0);
479 
480 	/*
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.
488 	 */
489 	exist = db_exist(sp, TMAP->lno + 1);
490 
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)) {
495 			if (smp->coff != 0)
496 				continue;
497 		} else
498 			if (smp->soff != 1)
499 				continue;
500 
501 		/*
502 		 * The first line of an empty file gets numbered, otherwise
503 		 * number any existing line.
504 		 */
505 		if (smp->lno != 1 && !exist && !db_exist(sp, smp->lno))
506 			break;
507 
508 		(void)gp->scr_move(sp, smp - HMAP, 0);
509 		len = snprintf(nbuf, sizeof(nbuf), O_NUMBER_FMT, smp->lno);
510 		(void)gp->scr_addstr(sp, nbuf, len);
511 	}
512 	(void)gp->scr_move(sp, oldy, oldx);
513 	return (0);
514 }
515