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 #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 && CHAR_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 }