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