vi/vs_line.c

   1 /*-
   2  * Copyright (c) 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * %sccs.include.redist.c%
   6  */
   7
   8 #ifndef lint
   9 static char sccsid[] = "$Id: vs_line.c,v 8.18 1994/01/22 17:26:54 bostic Exp $ (Berkeley) $Date: 1994/01/22 17:26:54 $";
  10 #endif /* not lint */
  11
  12 #include <sys/types.h>
  13
  14 #include <curses.h>
  15 #include <string.h>
  16
  17 #include "vi.h"
  18 #include "svi_screen.h"
  19
  20 #if defined(DEBUG) && 0
  21 #define TABCH   '-'
  22 #define TABSTR  "--------------------"
  23 #else
  24 #define TABSTR  "                    "
  25 #define TABCH   ' '
  26 #endif
  27
  28 /*
  29  * svi_line --
  30  *      Update one line on the screen.
  31  */
  32 int
  33 svi_line(sp, ep, smp, yp, xp)
  34         SCR *sp;
  35         EXF *ep;
  36         SMAP *smp;
  37         size_t *xp, *yp;
  38 {
  39         CHNAME const *cname;
  40         SMAP *tsmp;
  41         size_t chlen, cols_per_screen, cno_cnt, len, scno, skip_screens;
  42         size_t offset_in_char, offset_in_line;
  43         size_t oldy, oldx;
  44         int ch, is_cached, is_infoline, is_partial, is_tab, listset;
  45         char *p, nbuf[10];
  46
  47 #if defined(DEBUG) && 0
  48         TRACE(sp, "svi_line: row %u: line: %u off: %u\n",
  49             smp - HMAP, smp->lno, smp->off);
  50 #endif
  51
  52         /*
  53          * Assume that, if the cache entry for the line is filled in, the
  54          * line is already on the screen, and all we need to do is return
  55          * the cursor position.  If the calling routine doesn't need the
  56          * cursor position, we can just return.
  57          */
  58         is_cached = SMAP_CACHE(smp);
  59         if (yp == NULL && is_cached)
  60                 return (0);
  61
  62         /*
  63          * A nasty side effect of this routine is that it returns the screen
  64          * position for the "current" character.  Not pretty, but this is the
  65          * only routine that really knows what's out there.
  66          *
  67          * Move to the line.  This routine can be called by svi_sm_position(),
  68          * which uses it to fill in the cache entry so it can figure out what
  69          * the real contents of the screen are.  Because of this, we have to
  70          * return to whereever we started from.
  71          */
  72         getyx(stdscr, oldy, oldx);
  73         MOVE(sp, smp - HMAP, 0);
  74
  75         /* Get the character map. */
  76         cname = sp->gp->cname;
  77
  78         /* Get a copy of the line. */
  79         p = file_gline(sp, ep, smp->lno, &len);
  80
  81         /*
  82          * Special case if we're printing the info/mode line.  Skip printing
  83          * the leading number, as well as other minor setup.  If painting the
  84          * line between two screens, it's always in reverse video.  The only
  85          * time this code paints the mode line is when the user is entering
  86          * text for a ":" command, so we can put the code here instead of
  87          * dealing with the empty line logic below.  This is a kludge, but it's
  88          * pretty much confined to this module.
  89          *
  90          * Set the number of screens to skip until a character is displayed.
  91          * Left-right screens are special, because we don't bother building
  92          * a buffer to be skipped over.
  93          *
  94          * Set the number of columns for this screen.
  95          */
  96         cols_per_screen = sp->cols;
  97         if (is_infoline = ISINFOLINE(sp, smp)) {
  98                 listset = 0;
  99                 if (O_ISSET(sp, O_LEFTRIGHT))
 100                         skip_screens = 0;
 101                 else
 102                         skip_screens = smp->off - 1;
 103         } else {
 104                 listset = O_ISSET(sp, O_LIST);
 105                 skip_screens = smp->off - 1;
 106
 107                 /*
 108                  * If O_NUMBER is set and it's line number 1 or the line exists
 109                  * and this is the first screen of a folding line or any left-
 110                  * right line, display the line number.
 111                  */
 112                 if (O_ISSET(sp, O_NUMBER)) {
 113                         cols_per_screen -= O_NUMBER_LENGTH;
 114                         if ((smp->lno == 1 || p != NULL) && skip_screens == 0) {
 115                                 (void)snprintf(nbuf,
 116                                     sizeof(nbuf), O_NUMBER_FMT, smp->lno);
 117                                 ADDSTR(nbuf);
 118                         }
 119                 }
 120         }
 121
 122         /*
 123          * Special case non-existent lines and the first line of an empty
 124          * file.  In both cases, the cursor position is 0, but corrected
 125          * for the O_NUMBER field if it was displayed.
 126          */
 127         if (p == NULL || len == 0) {
 128                 /* Fill in the cursor. */
 129                 if (yp != NULL && smp->lno == sp->lno) {
 130                         *yp = smp - HMAP;
 131                         *xp = sp->cols - cols_per_screen;
 132                 }
 133
 134                 /* If the line is on the screen, quit. */
 135                 if (is_cached)
 136                         goto ret;
 137
 138                 /* Set line cacheing information. */
 139                 smp->c_sboff = smp->c_eboff = 0;
 140                 smp->c_scoff = smp->c_eclen = 0;
 141
 142                 if (p == NULL) {
 143                         if (smp->lno != 1)
 144                                 ADDCH(listset && skip_screens == 0 ? '$' : '~');
 145                 } else if (listset && skip_screens == 0)
 146                         ADDCH('$');
 147
 148                 clrtoeol();
 149                 MOVEA(sp, oldy, oldx);
 150                 return (0);
 151         }
 152
 153         /*
 154          * If we wrote a line that's this or a previous one, we can do this
 155          * much more quickly -- we cached the starting and ending positions
 156          * of that line.  The way it works is we keep information about the
 157          * lines displayed in the SMAP.  If we're painting the screen in
 158          * the forward, this saves us from reformatting the physical line for
 159          * every line on the screen.  This wins big on binary files with 10K
 160          * lines.
 161          *
 162          * Test for the first screen of the line, then the current screen line,
 163          * then the line behind us, then do the hard work.  Note, it doesn't
 164          * do us any good to have a line in front of us -- it would be really
 165          * hard to try and figure out tabs in the reverse direction, i.e. how
 166          * many spaces a tab takes up in the reverse direction depends on
 167          * what characters preceded it.
 168          */
 169         if (smp->off == 1) {
 170                 smp->c_sboff = offset_in_line = 0;
 171                 smp->c_scoff = offset_in_char = 0;
 172                 p = &p[offset_in_line];
 173         } else if (is_cached) {
 174                 offset_in_line = smp->c_sboff;
 175                 offset_in_char = smp->c_scoff;
 176                 p = &p[offset_in_line];
 177                 if (skip_screens != 0)
 178                         cols_per_screen = sp->cols;
 179         } else if (smp != HMAP &&
 180             SMAP_CACHE(tsmp = smp - 1) && tsmp->lno == smp->lno) {
 181                 if (tsmp->c_eclen != tsmp->c_ecsize) {
 182                         offset_in_line = tsmp->c_eboff;
 183                         offset_in_char = tsmp->c_eclen;
 184                 } else {
 185                         offset_in_line = tsmp->c_eboff + 1;
 186                         offset_in_char = 0;
 187                 }
 188
 189                 /* Put starting info for this line in the cache. */
 190                 smp->c_sboff = offset_in_line;
 191                 smp->c_scoff = offset_in_char;
 192                 p = &p[offset_in_line];
 193                 if (skip_screens != 0)
 194                         cols_per_screen = sp->cols;
 195         } else {
 196                 offset_in_line = 0;
 197                 offset_in_char = 0;
 198
 199                 /* This is the loop that skips through screens. */
 200                 if (skip_screens == 0) {
 201                         smp->c_sboff = offset_in_line;
 202                         smp->c_scoff = offset_in_char;
 203                 } else for (scno = 0; offset_in_line < len; ++offset_in_line) {
 204                         scno += chlen =
 205                             (ch = *(u_char *)p++) == '\t' && !listset ?
 206                             TAB_OFF(sp, scno) : cname[ch].len;
 207                         if (scno < cols_per_screen)
 208                                 continue;
 209                         /*
 210                          * Reset cols_per_screen to second and subsequent line
 211                          * length.
 212                          */
 213                         scno -= cols_per_screen;
 214                         cols_per_screen = sp->cols;
 215
 216                         /*
 217                          * If crossed the last skipped screen boundary, start
 218                          * displaying the characters.
 219                          */
 220                         if (--skip_screens)
 221                                 continue;
 222
 223                         /* Put starting info for this line in the cache. */
 224                         if (scno) {
 225                                 smp->c_sboff = offset_in_line;
 226                                 smp->c_scoff = offset_in_char = chlen - scno;
 227                                 --p;
 228                         } else {
 229                                 smp->c_sboff = ++offset_in_line;
 230                                 smp->c_scoff = 0;
 231                         }
 232                         break;
 233                 }
 234         }
 235
 236         /*
 237          * Set the number of characters to skip before reaching the cursor
 238          * character.  Offset by 1 and use 0 as a flag value.  Svi_line is
 239          * called repeatedly with a valid pointer to a cursor position.
 240          * Don't fill anything in unless it's the right line and the right
 241          * character, and the right part of the character...
 242          */
 243         if (yp == NULL ||
 244             smp->lno != sp->lno || sp->cno < offset_in_line ||
 245             offset_in_line + cols_per_screen < sp->cno) {
 246                 cno_cnt = 0;
 247                 /* If the line is on the screen, quit. */
 248                 if (is_cached)
 249                         goto ret;
 250         } else
 251                 cno_cnt = (sp->cno - offset_in_line) + 1;
 252
 253         /* This is the loop that actually displays characters. */
 254         for (is_partial = 0, scno = 0;
 255             offset_in_line < len; ++offset_in_line, offset_in_char = 0) {
 256                 if ((ch = *(u_char *)p++) == '\t' && !listset) {
 257                         scno += chlen = TAB_OFF(sp, scno) - offset_in_char;
 258                         is_tab = 1;
 259                 } else {
 260                         scno += chlen = cname[ch].len - offset_in_char;
 261                         is_tab = 0;
 262                 }
 263
 264                 /*
 265                  * Only display up to the right-hand column.  Set a flag if
 266                  * the entire character wasn't displayed for use in setting
 267                  * the cursor.  If reached the end of the line, set the cache
 268                  * info for the screen.  Don't worry about there not being
 269                  * characters to display on the next screen, its lno/off won't
 270                  * match up in that case.
 271                  */
 272                 if (scno >= cols_per_screen) {
 273                         smp->c_ecsize = chlen;
 274                         chlen -= scno - cols_per_screen;
 275                         smp->c_eclen = chlen;
 276                         smp->c_eboff = offset_in_line;
 277                         if (scno > cols_per_screen)
 278                                 is_partial = 1;
 279
 280                         /* Terminate the loop. */
 281                         offset_in_line = len;
 282                 }
 283
 284                 /*
 285                  * If the caller wants the cursor value, and this was the
 286                  * cursor character, set the value.  There are two ways to
 287                  * put the cursor on a character -- if it's normal display
 288                  * mode, it goes on the last column of the character.  If
 289                  * it's input mode, it goes on the first.  In normal mode,
 290                  * set the cursor only if the entire character was displayed.
 291                  */
 292                 if (cno_cnt &&
 293                     --cno_cnt == 0 && (F_ISSET(sp, S_INPUT) || !is_partial)) {
 294                         *yp = smp - HMAP;
 295                         if (F_ISSET(sp, S_INPUT))
 296                                 *xp = scno - chlen;
 297                         else
 298                                 *xp = scno - 1;
 299                         if (O_ISSET(sp, O_NUMBER) &&
 300                             !is_infoline && smp->off == 1)
 301                                 *xp += O_NUMBER_LENGTH;
 302
 303                         /* If the line is on the screen, quit. */
 304                         if (is_cached)
 305                                 goto ret;
 306                 }
 307
 308                 /* If the line is on the screen, don't display anything. */
 309                 if (is_cached)
 310                         continue;
 311
 312                 /*
 313                  * Display the character.  If it's a tab and tabs aren't some
 314                  * ridiculous length, do it fast.  (We do tab expansion here
 315                  * because curses doesn't have a way to set the tab length.)
 316                  */
 317                 if (is_tab) {
 318                         if (chlen <= sizeof(TABSTR) - 1) {
 319                                 ADDNSTR(TABSTR, chlen);
 320                         } else
 321                                 while (chlen--)
 322                                         ADDCH(TABCH);
 323                 } else
 324                         ADDNSTR(cname[ch].name + offset_in_char, chlen);
 325         }
 326
 327         if (scno < cols_per_screen) {
 328                 /* If didn't paint the whole line, update the cache. */
 329                 smp->c_ecsize = smp->c_eclen = cname[ch].len;
 330                 smp->c_eboff = len - 1;
 331
 332                 /*
 333                  * If not the info/mode line, and O_LIST set, and at the
 334                  * end of the line, and the line ended on this screen,
 335                  * add a trailing $.
 336                  */
 337                 if (listset) {
 338                         ++scno;
 339                         ADDCH('$');
 340                 }
 341
 342                 /* If still didn't paint the whole line, clear the rest. */
 343                 if (scno < cols_per_screen)
 344                         clrtoeol();
 345         }
 346
 347 ret:    MOVEA(sp, oldy, oldx);
 348         return (0);
 349 }
 350
 351 /*
 352  * svi_number --
 353  *      Repaint the numbers on all the lines.
 354  */
 355 int
 356 svi_number(sp, ep)
 357         SCR *sp;
 358         EXF *ep;
 359 {
 360         SMAP *smp;
 361         recno_t lno;
 362         size_t oldy, oldx;
 363         char *lp, *p, nbuf[10];
 364
 365         /*
 366          * Try and avoid getting the last line in the file, by getting the
 367          * line after the last line in the screen -- if it exists, we know
 368          * we have to to number all the lines in the screen.  Get the one
 369          * after the last instead of the last, so that the info line doesn't
 370          * fool us.
 371          *
 372          * If that test fails, we have to check each line for existence.
 373          *
 374          * XXX
 375          * The problem is that file_lline will lie, and tell us that the
 376          * info line is the last line in the file.
 377          */
 378         lp = file_gline(sp, ep, TMAP->lno + 1, NULL);
 379
 380         getyx(stdscr, oldy, oldx);
 381         for (smp = HMAP; smp <= TMAP; ++smp) {
 382                 if (smp->off != 1)
 383                         continue;
 384                 if (ISINFOLINE(sp, smp))
 385                         break;
 386                 if (smp->lno != 1 && lp == NULL &&
 387                     (p = file_gline(sp, ep, smp->lno, NULL)) == NULL)
 388                         break;
 389                 MOVE(sp, smp - HMAP, 0);
 390                 (void)snprintf(nbuf, sizeof(nbuf), O_NUMBER_FMT, smp->lno);
 391                 ADDSTR(nbuf);
 392         }
 393         MOVEA(sp, oldy, oldx);
 394         return (0);
 395 }