1 /* $NetBSD: vs_line.c,v 1.3 2014/01/26 21:43:45 christos Exp $ */
2 /*-
3 * Copyright (c) 1993, 1994
4 * The Regents of the University of California. All rights reserved.
5 * Copyright (c) 1992, 1993, 1994, 1995, 1996
6 * Keith Bostic. All rights reserved.
7 *
8 * See the LICENSE file for redistribution information.
9 */
10
11 #include "config.h"
12
13 #include <sys/cdefs.h>
14 #if 0
15 #ifndef lint
16 static const char sccsid[] = "Id: vs_line.c,v 10.38 2002/01/19 21:59:07 skimo Exp (Berkeley) Date: 2002/01/19 21:59:07 ";
17 #endif /* not lint */
18 #else
19 __RCSID("$NetBSD: vs_line.c,v 1.3 2014/01/26 21:43:45 christos Exp $");
20 #endif
21
22 #include <sys/types.h>
23 #include <sys/queue.h>
24 #include <sys/time.h>
25
26 #include <bitstring.h>
27 #include <limits.h>
28 #include <stdio.h>
29 #include <string.h>
30
31 #include "../common/common.h"
32 #include "vi.h"
33
34 #ifdef VISIBLE_TAB_CHARS
35 #define TABCH '-'
36 #else
37 #define TABCH ' '
38 #endif
39
40 /*
41 * vs_line --
42 * Update one line on the screen.
43 *
44 * PUBLIC: int vs_line __P((SCR *, SMAP *, size_t *, size_t *));
45 */
46 int
vs_line(SCR * sp,SMAP * smp,size_t * yp,size_t * xp)47 vs_line(SCR *sp, SMAP *smp, size_t *yp, size_t *xp)
48 {
49 unsigned char *kp;
50 GS *gp;
51 SMAP *tsmp;
52 size_t chlen = 0, cno_cnt, cols_per_screen, len, nlen;
53 size_t offset_in_char, offset_in_line, oldx, oldy;
54 size_t scno, skip_cols, skip_screens;
55 int dne, is_cached, is_partial, is_tab, no_draw;
56 int list_tab, list_dollar;
57 CHAR_T *p;
58 CHAR_T *cbp, *ecbp, cbuf[128];
59 ARG_CHAR_T ch = L('\0');
60
61 #if defined(DEBUG) && 0
62 vtrace(sp, "vs_line: row %u: line: %u off: %u\n",
63 smp - HMAP, smp->lno, smp->off);
64 #endif
65 /*
66 * If ex modifies the screen after ex output is already on the screen,
67 * don't touch it -- we'll get scrolling wrong, at best.
68 */
69 no_draw = 0;
70 if (!F_ISSET(sp, SC_TINPUT_INFO) && VIP(sp)->totalcount > 1)
71 no_draw = 1;
72 if (F_ISSET(sp, SC_SCR_EXWROTE) && (size_t)(smp - HMAP) != LASTLINE(sp))
73 no_draw = 1;
74
75 /*
76 * Assume that, if the cache entry for the line is filled in, the
77 * line is already on the screen, and all we need to do is return
78 * the cursor position. If the calling routine doesn't need the
79 * cursor position, we can just return.
80 */
81 is_cached = SMAP_CACHE(smp);
82 if (yp == NULL && (is_cached || no_draw))
83 return (0);
84
85 /*
86 * A nasty side effect of this routine is that it returns the screen
87 * position for the "current" character. Not pretty, but this is the
88 * only routine that really knows what's out there.
89 *
90 * Move to the line. This routine can be called by vs_sm_position(),
91 * which uses it to fill in the cache entry so it can figure out what
92 * the real contents of the screen are. Because of this, we have to
93 * return to whereever we started from.
94 */
95 gp = sp->gp;
96 (void)gp->scr_cursor(sp, &oldy, &oldx);
97 (void)gp->scr_move(sp, smp - HMAP, 0);
98
99 /* Get the line. */
100 dne = db_get(sp, smp->lno, 0, &p, &len);
101
102 /*
103 * Special case if we're printing the info/mode line. Skip printing
104 * the leading number, as well as other minor setup. The only time
105 * this code paints the mode line is when the user is entering text
106 * for a ":" command, so we can put the code here instead of dealing
107 * with the empty line logic below. This is a kludge, but it's pretty
108 * much confined to this module.
109 *
110 * Set the number of columns for this screen.
111 * Set the number of chars or screens to skip until a character is to
112 * be displayed.
113 */
114 cols_per_screen = sp->cols;
115 if (O_ISSET(sp, O_LEFTRIGHT)) {
116 skip_screens = 0;
117 skip_cols = smp->coff;
118 } else {
119 skip_screens = smp->soff - 1;
120 skip_cols = skip_screens * cols_per_screen;
121 }
122
123 list_tab = O_ISSET(sp, O_LIST);
124 if (F_ISSET(sp, SC_TINPUT_INFO))
125 list_dollar = 0;
126 else {
127 list_dollar = list_tab;
128
129 /*
130 * If O_NUMBER is set, the line doesn't exist and it's line
131 * number 1, i.e., an empty file, display the line number.
132 *
133 * If O_NUMBER is set, the line exists and the first character
134 * on the screen is the first character in the line, display
135 * the line number.
136 *
137 * !!!
138 * If O_NUMBER set, decrement the number of columns in the
139 * first screen. DO NOT CHANGE THIS -- IT'S RIGHT! The
140 * rest of the code expects this to reflect the number of
141 * columns in the first screen, regardless of the number of
142 * columns we're going to skip.
143 */
144 if (O_ISSET(sp, O_NUMBER)) {
145 cols_per_screen -= O_NUMBER_LENGTH;
146 if ((!dne || smp->lno == 1) && skip_cols == 0) {
147 nlen = snprintf((char*)cbuf,
148 sizeof(cbuf), O_NUMBER_FMT,
149 (unsigned long)smp->lno);
150 (void)gp->scr_addstr(sp, (char*)cbuf, nlen);
151 }
152 }
153 }
154
155 /*
156 * Special case non-existent lines and the first line of an empty
157 * file. In both cases, the cursor position is 0, but corrected
158 * as necessary for the O_NUMBER field, if it was displayed.
159 */
160 if (dne || len == 0) {
161 /* Fill in the cursor. */
162 if (yp != NULL && smp->lno == sp->lno) {
163 *yp = smp - HMAP;
164 *xp = sp->cols - cols_per_screen;
165 }
166
167 /* If the line is on the screen, quit. */
168 if (is_cached || no_draw)
169 goto ret1;
170
171 /* Set line cache information. */
172 smp->c_sboff = smp->c_eboff = 0;
173 smp->c_scoff = smp->c_eclen = 0;
174
175 /*
176 * Lots of special cases for empty lines, but they only apply
177 * if we're displaying the first screen of the line.
178 */
179 if (skip_cols == 0) {
180 if (dne) {
181 if (smp->lno == 1) {
182 if (list_dollar) {
183 ch = L('$');
184 goto empty;
185 }
186 } else {
187 ch = L('~');
188 goto empty;
189 }
190 } else
191 if (list_dollar) {
192 ch = L('$');
193 empty: (void)gp->scr_addstr(sp,
194 (const char *)KEY_NAME(sp, ch),
195 KEY_LEN(sp, ch));
196 }
197 }
198
199 (void)gp->scr_clrtoeol(sp);
200 (void)gp->scr_move(sp, oldy, oldx);
201 return (0);
202 }
203
204 /* If we shortened this line in another screen, the cursor
205 * position may have fallen off.
206 */
207 if (sp->lno == smp->lno && sp->cno >= len)
208 sp->cno = len - 1;
209
210 /*
211 * If we just wrote this or a previous line, we cached the starting
212 * and ending positions of that line. The way it works is we keep
213 * information about the lines displayed in the SMAP. If we're
214 * painting the screen in the forward direction, this saves us from
215 * reformatting the physical line for every line on the screen. This
216 * wins big on binary files with 10K lines.
217 *
218 * Test for the first screen of the line, then the current screen line,
219 * then the line behind us, then do the hard work. Note, it doesn't
220 * do us any good to have a line in front of us -- it would be really
221 * hard to try and figure out tabs in the reverse direction, i.e. how
222 * many spaces a tab takes up in the reverse direction depends on
223 * what characters preceded it.
224 *
225 * Test for the first screen of the line.
226 */
227 if (skip_cols == 0) {
228 smp->c_sboff = offset_in_line = 0;
229 smp->c_scoff = offset_in_char = 0;
230 p = &p[offset_in_line];
231 goto display;
232 }
233
234 /* Test to see if we've seen this exact line before. */
235 if (is_cached) {
236 offset_in_line = smp->c_sboff;
237 offset_in_char = smp->c_scoff;
238 p = &p[offset_in_line];
239
240 /* Set cols_per_screen to 2nd and later line length. */
241 if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen)
242 cols_per_screen = sp->cols;
243 goto display;
244 }
245
246 /* Test to see if we saw an earlier part of this line before. */
247 if (smp != HMAP &&
248 SMAP_CACHE(tsmp = smp - 1) && tsmp->lno == smp->lno) {
249 if (tsmp->c_eclen != tsmp->c_ecsize) {
250 offset_in_line = tsmp->c_eboff;
251 offset_in_char = tsmp->c_eclen;
252 } else {
253 offset_in_line = tsmp->c_eboff + 1;
254 offset_in_char = 0;
255 }
256
257 /* Put starting info for this line in the cache. */
258 smp->c_sboff = offset_in_line;
259 smp->c_scoff = offset_in_char;
260 p = &p[offset_in_line];
261
262 /* Set cols_per_screen to 2nd and later line length. */
263 if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen)
264 cols_per_screen = sp->cols;
265 goto display;
266 }
267
268 scno = 0;
269 offset_in_line = 0;
270 offset_in_char = 0;
271
272 /* Do it the hard way, for leftright scrolling screens. */
273 if (O_ISSET(sp, O_LEFTRIGHT)) {
274 for (; offset_in_line < len; ++offset_in_line) {
275 chlen = (ch = (UCHAR_T)*p++) == L('\t') && !list_tab ?
276 TAB_OFF(scno) : KEY_COL(sp, ch);
277 if ((scno += chlen) >= skip_cols)
278 break;
279 }
280
281 /* Set cols_per_screen to 2nd and later line length. */
282 cols_per_screen = sp->cols;
283
284 /* Put starting info for this line in the cache. */
285 if (offset_in_line >= len) {
286 smp->c_sboff = offset_in_line;
287 smp->c_scoff = 255;
288 } else if (scno != skip_cols) {
289 smp->c_sboff = offset_in_line;
290 smp->c_scoff =
291 offset_in_char = chlen - (scno - skip_cols);
292 --p;
293 } else {
294 smp->c_sboff = ++offset_in_line;
295 smp->c_scoff = 0;
296 }
297 }
298
299 /* Do it the hard way, for historic line-folding screens. */
300 else {
301 for (; offset_in_line < len; ++offset_in_line) {
302 chlen = (ch = (UCHAR_T)*p++) == L('\t') && !list_tab ?
303 TAB_OFF(scno) : KEY_COL(sp, ch);
304 if ((scno += chlen) < cols_per_screen)
305 continue;
306 scno -= cols_per_screen;
307
308 /* Set cols_per_screen to 2nd and later line length. */
309 cols_per_screen = sp->cols;
310
311 /*
312 * If crossed the last skipped screen boundary, start
313 * displaying the characters.
314 */
315 if (--skip_screens == 0)
316 break;
317 }
318
319 /* Put starting info for this line in the cache. */
320 if (scno != 0) {
321 smp->c_sboff = offset_in_line;
322 smp->c_scoff = offset_in_char = chlen - scno;
323 --p;
324 } else {
325 smp->c_sboff = ++offset_in_line;
326 smp->c_scoff = 0;
327 }
328 }
329
330 display:
331 /*
332 * Set the number of characters to skip before reaching the cursor
333 * character. Offset by 1 and use 0 as a flag value. Vs_line is
334 * called repeatedly with a valid pointer to a cursor position.
335 * Don't fill anything in unless it's the right line and the right
336 * character, and the right part of the character...
337 */
338 if (yp == NULL ||
339 smp->lno != sp->lno || sp->cno < offset_in_line ||
340 offset_in_line + cols_per_screen < sp->cno) {
341 cno_cnt = 0;
342 /* If the line is on the screen, quit. */
343 if (is_cached || no_draw)
344 goto ret1;
345 } else
346 cno_cnt = (sp->cno - offset_in_line) + 1;
347
348 /* This is the loop that actually displays characters. */
349 ecbp = (cbp = cbuf) + sizeof(cbuf)/sizeof(CHAR_T) - 1;
350 for (is_partial = 0, scno = 0;
351 offset_in_line < len; ++offset_in_line, offset_in_char = 0) {
352 if ((ch = (UCHAR_T)*p++) == L('\t') && !list_tab) {
353 scno += chlen = TAB_OFF(scno) - offset_in_char;
354 is_tab = 1;
355 } else {
356 scno += chlen = KEY_COL(sp, ch) - offset_in_char;
357 is_tab = 0;
358 }
359
360 /*
361 * Only display up to the right-hand column. Set a flag if
362 * the entire character wasn't displayed for use in setting
363 * the cursor. If reached the end of the line, set the cache
364 * info for the screen. Don't worry about there not being
365 * characters to display on the next screen, its lno/off won't
366 * match up in that case.
367 */
368 if (scno >= cols_per_screen) {
369 if (is_tab == 1) {
370 chlen -= scno - cols_per_screen;
371 smp->c_ecsize = smp->c_eclen = chlen;
372 scno = cols_per_screen;
373 } else {
374 smp->c_ecsize = chlen;
375 chlen -= scno - cols_per_screen;
376 smp->c_eclen = chlen;
377
378 if (scno > cols_per_screen)
379 is_partial = 1;
380 }
381 smp->c_eboff = offset_in_line;
382
383 /* Terminate the loop. */
384 offset_in_line = len;
385 }
386
387 /*
388 * If the caller wants the cursor value, and this was the
389 * cursor character, set the value. There are two ways to
390 * put the cursor on a character -- if it's normal display
391 * mode, it goes on the last column of the character. If
392 * it's input mode, it goes on the first. In normal mode,
393 * set the cursor only if the entire character was displayed.
394 */
395 if (cno_cnt &&
396 --cno_cnt == 0 && (F_ISSET(sp, SC_TINPUT) || !is_partial)) {
397 *yp = smp - HMAP;
398 if (F_ISSET(sp, SC_TINPUT))
399 if (is_partial)
400 *xp = scno - smp->c_ecsize;
401 else
402 *xp = scno - chlen;
403 else
404 *xp = scno - 1;
405 if (O_ISSET(sp, O_NUMBER) &&
406 !F_ISSET(sp, SC_TINPUT_INFO) && skip_cols == 0)
407 *xp += O_NUMBER_LENGTH;
408
409 /* If the line is on the screen, quit. */
410 if (is_cached || no_draw)
411 goto ret1;
412 }
413
414 /* If the line is on the screen, don't display anything. */
415 if (is_cached || no_draw)
416 continue;
417
418 #define FLUSH { \
419 *cbp = '\0'; \
420 (void)gp->scr_waddstr(sp, cbuf, cbp - cbuf); \
421 cbp = cbuf; \
422 }
423 /*
424 * Display the character. We do tab expansion here because
425 * the screen interface doesn't have any way to set the tab
426 * length. Note, it's theoretically possible for chlen to
427 * be larger than cbuf, if the user set a impossibly large
428 * tabstop.
429 */
430 if (is_tab)
431 while (chlen--) {
432 if (cbp >= ecbp)
433 FLUSH;
434 *cbp++ = TABCH;
435 }
436 else {
437 if (cbp + chlen >= ecbp)
438 FLUSH;
439
440 /* don't display half a wide character */
441 if (is_partial && CHAR_WIDTH(sp, ch) > 1) {
442 *cbp++ = ' ';
443 break;
444 }
445
446 /* XXXX this needs some rethinking */
447 if (INTISWIDE(ch)) {
448 /* Put a space before non-spacing char. */
449 if (CHAR_WIDTH(sp, ch) <= 0)
450 *cbp++ = L(' ');
451 *cbp++ = ch;
452 } else
453 for (kp = KEY_NAME(sp, ch) + offset_in_char;
454 chlen--;)
455 *cbp++ = (u_char)*kp++;
456 }
457 }
458
459 if (scno < cols_per_screen) {
460 /* If didn't paint the whole line, update the cache. */
461 smp->c_ecsize = smp->c_eclen = KEY_LEN(sp, ch);
462 smp->c_eboff = len - 1;
463
464 /*
465 * If not the info/mode line, and O_LIST set, and at the
466 * end of the line, and the line ended on this screen,
467 * add a trailing $.
468 */
469 if (list_dollar) {
470 ++scno;
471
472 chlen = KEY_LEN(sp, L('$'));
473 if (cbp + chlen >= ecbp)
474 FLUSH;
475 for (kp = KEY_NAME(sp, L('$')); chlen--;)
476 *cbp++ = *kp++;
477 }
478
479 /* If still didn't paint the whole line, clear the rest. */
480 if (scno < cols_per_screen)
481 (void)gp->scr_clrtoeol(sp);
482 }
483
484 /* Flush any buffered characters. */
485 if (cbp > cbuf)
486 FLUSH;
487
488 ret1: (void)gp->scr_move(sp, oldy, oldx);
489 return (0);
490 }
491
492 /*
493 * vs_number --
494 * Repaint the numbers on all the lines.
495 *
496 * PUBLIC: int vs_number __P((SCR *));
497 */
498 int
vs_number(SCR * sp)499 vs_number(SCR *sp)
500 {
501 GS *gp;
502 SMAP *smp;
503 size_t len, oldy, oldx;
504 int exist;
505 char nbuf[10];
506
507 gp = sp->gp;
508
509 /* No reason to do anything if we're in input mode on the info line. */
510 if (F_ISSET(sp, SC_TINPUT_INFO))
511 return (0);
512
513 /*
514 * Try and avoid getting the last line in the file, by getting the
515 * line after the last line in the screen -- if it exists, we know
516 * we have to to number all the lines in the screen. Get the one
517 * after the last instead of the last, so that the info line doesn't
518 * fool us. (The problem is that file_lline will lie, and tell us
519 * that the info line is the last line in the file.) If that test
520 * fails, we have to check each line for existence.
521 */
522 exist = db_exist(sp, TMAP->lno + 1);
523
524 (void)gp->scr_cursor(sp, &oldy, &oldx);
525 for (smp = HMAP; smp <= TMAP; ++smp) {
526 /* Numbers are only displayed for the first screen line. */
527 if (O_ISSET(sp, O_LEFTRIGHT)) {
528 if (smp->coff != 0)
529 continue;
530 } else
531 if (smp->soff != 1)
532 continue;
533
534 /*
535 * The first line of an empty file gets numbered, otherwise
536 * number any existing line.
537 */
538 if (smp->lno != 1 && !exist && !db_exist(sp, smp->lno))
539 break;
540
541 (void)gp->scr_move(sp, smp - HMAP, 0);
542 len = snprintf(nbuf, sizeof(nbuf), O_NUMBER_FMT,
543 (unsigned long)smp->lno);
544 (void)gp->scr_addstr(sp, nbuf, len);
545 }
546 (void)gp->scr_move(sp, oldy, oldx);
547 return (0);
548 }
549