contrib/nvi/vi/vs_line.c

   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, sizeof(cbuf),
 142                                     O_NUMBER_FMT, (u_long)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),
 510                     O_NUMBER_FMT, (u_long)smp->lno);
 511                 (void)gp->scr_addstr(sp, nbuf, len);
 512         }
 513         (void)gp->scr_move(sp, oldy, oldx);
 514         return (0);
 515 }