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 13static const char sccsid[] = "$Id: vs_line.c,v 10.40 2012/02/13 19:22:25 zy Exp $"; 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 */ 40int 41vs_line(SCR *sp, SMAP *smp, size_t *yp, size_t *xp) 42{ 43 u_char *kp; 44 GS *gp; 45 SMAP *tsmp; 46 size_t chlen = 0, cno_cnt, cols_per_screen, len, nlen; 47 size_t offset_in_char, offset_in_line, oldx, oldy; 48 size_t scno, skip_cols, skip_screens; 49 int dne, is_cached, is_partial, is_tab, no_draw; 50 int list_tab, list_dollar; 51 CHAR_T *p; 52 CHAR_T *cbp, *ecbp, cbuf[128]; 53 ARG_CHAR_T ch = '\0'; 54 55#if defined(DEBUG) && 0 56 TRACE(sp, "vs_line: row %u: line: %u off: %u\n", 57 smp - HMAP, smp->lno, smp->off); 58#endif 59 /* 60 * If ex modifies the screen after ex output is already on the screen, 61 * don't touch it -- we'll get scrolling wrong, at best. 62 */ 63 no_draw = 0; 64 if (!F_ISSET(sp, SC_TINPUT_INFO) && VIP(sp)->totalcount > 1) 65 no_draw = 1; 66 if (F_ISSET(sp, SC_SCR_EXWROTE) && smp - HMAP != LASTLINE(sp)) 67 no_draw = 1; 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 || no_draw)) 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((char*)cbuf, 142 sizeof(cbuf), O_NUMBER_FMT, (u_long)smp->lno); 143 (void)gp->scr_addstr(sp, (char*)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 || no_draw) 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 = '$'; 186empty: (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 /* If we shortened this line in another screen, the cursor 196 * position may have fallen off. 197 */ 198 if (sp->lno == smp->lno && sp->cno >= len) 199 sp->cno = len - 1; 200 201 /* 202 * If we just wrote this or a previous line, we cached the starting 203 * and ending positions of that line. The way it works is we keep 204 * information about the lines displayed in the SMAP. If we're 205 * painting the screen in the forward direction, this saves us from 206 * reformatting the physical line for every line on the screen. This 207 * wins big on binary files with 10K lines. 208 * 209 * Test for the first screen of the line, then the current screen line, 210 * then the line behind us, then do the hard work. Note, it doesn't 211 * do us any good to have a line in front of us -- it would be really 212 * hard to try and figure out tabs in the reverse direction, i.e. how 213 * many spaces a tab takes up in the reverse direction depends on 214 * what characters preceded it. 215 * 216 * Test for the first screen of the line. 217 */ 218 if (skip_cols == 0) { 219 smp->c_sboff = offset_in_line = 0; 220 smp->c_scoff = offset_in_char = 0; 221 p = &p[offset_in_line]; 222 goto display; 223 } 224 225 /* Test to see if we've seen this exact line before. */ 226 if (is_cached) { 227 offset_in_line = smp->c_sboff; 228 offset_in_char = smp->c_scoff; 229 p = &p[offset_in_line]; 230 231 /* Set cols_per_screen to 2nd and later line length. */ 232 if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen) 233 cols_per_screen = sp->cols; 234 goto display; 235 } 236 237 /* Test to see if we saw an earlier part of this line before. */ 238 if (smp != HMAP && 239 SMAP_CACHE(tsmp = smp - 1) && tsmp->lno == smp->lno) { 240 if (tsmp->c_eclen != tsmp->c_ecsize) { 241 offset_in_line = tsmp->c_eboff; 242 offset_in_char = tsmp->c_eclen; 243 } else { 244 offset_in_line = tsmp->c_eboff + 1; 245 offset_in_char = 0; 246 } 247 248 /* Put starting info for this line in the cache. */ 249 smp->c_sboff = offset_in_line; 250 smp->c_scoff = offset_in_char; 251 p = &p[offset_in_line]; 252 253 /* Set cols_per_screen to 2nd and later line length. */ 254 if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen) 255 cols_per_screen = sp->cols; 256 goto display; 257 } 258 259 scno = 0; 260 offset_in_line = 0; 261 offset_in_char = 0; 262 263 /* Do it the hard way, for leftright scrolling screens. */ 264 if (O_ISSET(sp, O_LEFTRIGHT)) { 265 for (; offset_in_line < len; ++offset_in_line) { 266 chlen = (ch = *p++) == '\t' && !list_tab ? 267 TAB_OFF(scno) : KEY_COL(sp, ch); 268 if ((scno += chlen) >= skip_cols) 269 break; 270 } 271 272 /* Set cols_per_screen to 2nd and later line length. */ 273 cols_per_screen = sp->cols; 274 275 /* Put starting info for this line in the cache. */ 276 if (offset_in_line >= len) { 277 smp->c_sboff = offset_in_line; 278 smp->c_scoff = 255; 279 } else if (scno != skip_cols) { 280 smp->c_sboff = offset_in_line; 281 smp->c_scoff = 282 offset_in_char = chlen - (scno - skip_cols); 283 --p; 284 } else { 285 smp->c_sboff = ++offset_in_line; 286 smp->c_scoff = 0; 287 } 288 } 289 290 /* Do it the hard way, for historic line-folding screens. */ 291 else { 292 for (; offset_in_line < len; ++offset_in_line) { 293 chlen = (ch = *p++) == '\t' && !list_tab ? 294 TAB_OFF(scno) : KEY_COL(sp, ch); 295 if ((scno += chlen) < cols_per_screen) 296 continue; 297 scno -= cols_per_screen; 298 299 /* Set cols_per_screen to 2nd and later line length. */ 300 cols_per_screen = sp->cols; 301 302 /* 303 * If crossed the last skipped screen boundary, start 304 * displaying the characters. 305 */ 306 if (--skip_screens == 0) 307 break; 308 } 309 310 /* Put starting info for this line in the cache. */ 311 if (scno != 0) { 312 smp->c_sboff = offset_in_line; 313 smp->c_scoff = offset_in_char = chlen - scno; 314 --p; 315 } else { 316 smp->c_sboff = ++offset_in_line; 317 smp->c_scoff = 0; 318 } 319 } 320 321display: 322 /* 323 * Set the number of characters to skip before reaching the cursor 324 * character. Offset by 1 and use 0 as a flag value. Vs_line is 325 * called repeatedly with a valid pointer to a cursor position. 326 * Don't fill anything in unless it's the right line and the right 327 * character, and the right part of the character... 328 */ 329 if (yp == NULL || 330 smp->lno != sp->lno || sp->cno < offset_in_line || 331 offset_in_line + cols_per_screen < sp->cno) { 332 cno_cnt = 0; 333 /* If the line is on the screen, quit. */ 334 if (is_cached || no_draw) 335 goto ret1; 336 } else 337 cno_cnt = (sp->cno - offset_in_line) + 1; 338 339 /* This is the loop that actually displays characters. */ 340 ecbp = (cbp = cbuf) + SIZE(cbuf) - 1; 341 for (is_partial = 0, scno = 0; 342 offset_in_line < len; ++offset_in_line, offset_in_char = 0) { 343 if ((ch = *p++) == '\t' && !list_tab) { 344 scno += chlen = TAB_OFF(scno) - offset_in_char; 345 is_tab = 1; 346 } else { 347 scno += chlen = KEY_COL(sp, ch) - offset_in_char; 348 is_tab = 0; 349 } 350 351 /* 352 * Only display up to the right-hand column. Set a flag if 353 * the entire character wasn't displayed for use in setting 354 * the cursor. If reached the end of the line, set the cache 355 * info for the screen. Don't worry about there not being 356 * characters to display on the next screen, its lno/off won't 357 * match up in that case. 358 */ 359 if (scno >= cols_per_screen) { 360 if (is_tab == 1) { 361 chlen -= scno - cols_per_screen; 362 smp->c_ecsize = smp->c_eclen = chlen; 363 scno = cols_per_screen; 364 } else { 365 smp->c_ecsize = chlen; 366 chlen -= scno - cols_per_screen; 367 smp->c_eclen = chlen; 368 369 if (scno > cols_per_screen) 370 is_partial = 1; 371 } 372 smp->c_eboff = offset_in_line; 373 374 /* Terminate the loop. */ 375 offset_in_line = len; 376 } 377 378 /* 379 * If the caller wants the cursor value, and this was the 380 * cursor character, set the value. There are two ways to 381 * put the cursor on a character -- if it's normal display 382 * mode, it goes on the last column of the character. If 383 * it's input mode, it goes on the first. In normal mode, 384 * set the cursor only if the entire character was displayed. 385 */ 386 if (cno_cnt && 387 --cno_cnt == 0 && (F_ISSET(sp, SC_TINPUT) || !is_partial)) { 388 *yp = smp - HMAP; 389 if (F_ISSET(sp, SC_TINPUT)) 390 if (is_partial) 391 *xp = scno - smp->c_ecsize; 392 else 393 *xp = scno - chlen; 394 else 395 *xp = scno - 1; 396 if (O_ISSET(sp, O_NUMBER) && 397 !F_ISSET(sp, SC_TINPUT_INFO) && skip_cols == 0) 398 *xp += O_NUMBER_LENGTH; 399 400 /* If the line is on the screen, quit. */ 401 if (is_cached || no_draw) 402 goto ret1; 403 } 404 405 /* If the line is on the screen, don't display anything. */ 406 if (is_cached || no_draw) 407 continue; 408 409#define FLUSH { \ 410 *cbp = '\0'; \ 411 (void)gp->scr_waddstr(sp, cbuf, cbp - cbuf); \ 412 cbp = cbuf; \ 413} 414 /* 415 * Display the character. We do tab expansion here because 416 * the screen interface doesn't have any way to set the tab 417 * length. Note, it's theoretically possible for chlen to 418 * be larger than cbuf, if the user set a impossibly large 419 * tabstop. 420 */ 421 if (is_tab) 422 while (chlen--) { 423 if (cbp >= ecbp) 424 FLUSH; 425 *cbp++ = TABCH; 426 } 427 else { 428 if (cbp + chlen >= ecbp) 429 FLUSH; 430 431 /* don't display half a wide character */ 432 if (is_partial && CHAR_WIDTH(sp, ch) > 1) { 433 *cbp++ = ' '; 434 break; 435 } 436 437 if (KEY_NEEDSWIDE(sp, ch)) 438 *cbp++ = ch; 439 else 440 for (kp = (u_char *) 441 KEY_NAME(sp, ch) + offset_in_char; 442 chlen--;) 443 *cbp++ = *kp++; 444 } 445 } 446 447 if (scno < cols_per_screen) { 448 /* If didn't paint the whole line, update the cache. */ 449 smp->c_ecsize = smp->c_eclen = KEY_COL(sp, ch); 450 smp->c_eboff = len - 1; 451 452 /* 453 * If not the info/mode line, and O_LIST set, and at the 454 * end of the line, and the line ended on this screen, 455 * add a trailing $. 456 */ 457 if (list_dollar) { 458 ++scno; 459 460 chlen = KEY_LEN(sp, '$'); 461 if (cbp + chlen >= ecbp) 462 FLUSH; 463 for (kp = (u_char *) 464 KEY_NAME(sp, '$'); chlen--;) 465 *cbp++ = *kp++; 466 } 467 468 /* If still didn't paint the whole line, clear the rest. */ 469 if (scno < cols_per_screen) 470 (void)gp->scr_clrtoeol(sp); 471 } 472 473 /* Flush any buffered characters. */ 474 if (cbp > cbuf) 475 FLUSH; 476 477ret1: (void)gp->scr_move(sp, oldy, oldx); 478 return (0); 479} 480 481/* 482 * vs_number -- 483 * Repaint the numbers on all the lines. 484 * 485 * PUBLIC: int vs_number __P((SCR *)); 486 */ 487int 488vs_number(SCR *sp) 489{ 490 GS *gp; 491 SMAP *smp; 492 VI_PRIVATE *vip; 493 size_t len, oldy, oldx; 494 int exist; 495 char nbuf[10]; 496 497 gp = sp->gp; 498 vip = VIP(sp); 499 500 /* No reason to do anything if we're in input mode on the info line. */ 501 if (F_ISSET(sp, SC_TINPUT_INFO)) 502 return (0); 503 504 /* 505 * Try and avoid getting the last line in the file, by getting the 506 * line after the last line in the screen -- if it exists, we know 507 * we have to to number all the lines in the screen. Get the one 508 * after the last instead of the last, so that the info line doesn't 509 * fool us. (The problem is that file_lline will lie, and tell us 510 * that the info line is the last line in the file.) If that test 511 * fails, we have to check each line for existence. 512 */ 513 exist = db_exist(sp, TMAP->lno + 1); 514 515 (void)gp->scr_cursor(sp, &oldy, &oldx); 516 for (smp = HMAP; smp <= TMAP; ++smp) { 517 /* Numbers are only displayed for the first screen line. */ 518 if (O_ISSET(sp, O_LEFTRIGHT)) { 519 if (smp->coff != 0) 520 continue; 521 } else 522 if (smp->soff != 1) 523 continue; 524 525 /* 526 * The first line of an empty file gets numbered, otherwise 527 * number any existing line. 528 */ 529 if (smp->lno != 1 && !exist && !db_exist(sp, smp->lno)) 530 break; 531 532 (void)gp->scr_move(sp, smp - HMAP, 0); 533 len = snprintf(nbuf, sizeof(nbuf), O_NUMBER_FMT, (u_long)smp->lno); 534 (void)gp->scr_addstr(sp, nbuf, len); 535 } 536 (void)gp->scr_move(sp, oldy, oldx); 537 return (0); 538} 539