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.15 1993/12/02 18:11:13 bostic Exp $ (Berkeley) $Date: 1993/12/02 18:11:13 $";
  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                     (smp->lno == 1 || p != NULL) && skip_screens == 0) {
 114                         cols_per_screen -= O_NUMBER_LENGTH;
 115                         (void)snprintf(nbuf,
 116                             sizeof(nbuf), O_NUMBER_FMT, smp->lno);
 117                         ADDSTR(nbuf);
 118                 }
 119         }
 120
 121         /*
 122          * Special case non-existent lines and the first line of an empty
 123          * file.  In both cases, the cursor position is 0, but corrected
 124          * for the O_NUMBER field if it was displayed.
 125          */
 126         if (p == NULL || len == 0) {
 127                 /* Fill in the cursor. */
 128                 if (yp != NULL && smp->lno == sp->lno) {
 129                         *yp = smp - HMAP;
 130                         *xp = sp->cols - cols_per_screen;
 131                 }
 132
 133                 /* If the line is on the screen, quit. */
 134                 if (is_cached)
 135                         goto ret;
 136
 137                 /* Set line cacheing information. */
 138                 smp->c_sboff = smp->c_eboff = 0;
 139                 smp->c_scoff = smp->c_eclen = 0;
 140
 141                 if (p == NULL) {
 142                         if (smp->lno != 1)
 143                                 ADDCH(listset && skip_screens == 0 ? '$' : '~');
 144                 } else if (listset && skip_screens == 0)
 145                         ADDCH('$');
 146
 147                 clrtoeol();
 148                 MOVEA(sp, oldy, oldx);
 149                 return (0);
 150         }
 151
 152         /*
 153          * If we wrote a line that's this or a previous one, we can do this
 154          * much more quickly -- we cached the starting and ending positions
 155          * of that line.  The way it works is we keep information about the
 156          * lines displayed in the SMAP.  If we're painting the screen in
 157          * the forward, this saves us from reformatting the physical line for
 158          * every line on the screen.  This wins big on binary files with 10K
 159          * lines.
 160          *
 161          * Test for the first screen of the line, then the current screen line,
 162          * then the line behind us, then do the hard work.  Note, it doesn't
 163          * do us any good to have a line in front of us -- it would be really
 164          * hard to try and figure out tabs in the reverse direction, i.e. how
 165          * many spaces a tab takes up in the reverse direction depends on
 166          * what characters preceded it.
 167          */
 168         if (smp->off == 1) {
 169                 smp->c_sboff = offset_in_line = 0;
 170                 smp->c_scoff = offset_in_char = 0;
 171                 p = &p[offset_in_line];
 172         } else if (is_cached) {
 173                 offset_in_line = smp->c_sboff;
 174                 offset_in_char = smp->c_scoff;
 175                 p = &p[offset_in_line];
 176         } else if (smp != HMAP &&
 177             SMAP_CACHE(tsmp = smp - 1) && tsmp->lno == smp->lno) {
 178                 if (tsmp->c_eclen != tsmp->c_ecsize) {
 179                         offset_in_line = tsmp->c_eboff;
 180                         offset_in_char = tsmp->c_eclen;
 181                 } else {
 182                         offset_in_line = tsmp->c_eboff + 1;
 183                         offset_in_char = 0;
 184                 }
 185
 186                 /* Put starting info for this line in the cache. */
 187                 smp->c_sboff = offset_in_line;
 188                 smp->c_scoff = offset_in_char;
 189                 p = &p[offset_in_line];
 190         } else {
 191                 offset_in_line = 0;
 192                 offset_in_char = 0;
 193
 194                 /* This is the loop that skips through screens. */
 195                 if (skip_screens == 0) {
 196                         smp->c_sboff = offset_in_line;
 197                         smp->c_scoff = offset_in_char;
 198                 } else for (scno = 0; offset_in_line < len; ++offset_in_line) {
 199                         scno += chlen =
 200                             (ch = *(u_char *)p++) == '\t' && !listset ?
 201                             TAB_OFF(sp, scno) : cname[ch].len;
 202                         if (scno < cols_per_screen)
 203                                 continue;
 204                         /*
 205                          * Reset cols_per_screen to second and subsequent line
 206                          * length.
 207                          */
 208                         scno -= cols_per_screen;
 209                         cols_per_screen = sp->cols;
 210
 211                         /*
 212                          * If crossed the last skipped screen boundary, start
 213                          * displaying the characters.
 214                          */
 215                         if (--skip_screens)
 216                                 continue;
 217
 218                         /* Put starting info for this line in the cache. */
 219                         if (scno) {
 220                                 smp->c_sboff = offset_in_line;
 221                                 smp->c_scoff = offset_in_char = chlen - scno;
 222                                 --p;
 223                         } else {
 224                                 smp->c_sboff = ++offset_in_line;
 225                                 smp->c_scoff = 0;
 226                         }
 227                         break;
 228                 }
 229         }
 230
 231         /*
 232          * Set the number of characters to skip before reaching the cursor
 233          * character.  Offset by 1 and use 0 as a flag value.  Svi_line is
 234          * called repeatedly with a valid pointer to a cursor position.
 235          * Don't fill anything in unless it's the right line and the right
 236          * character, and the right part of the character...
 237          */
 238         if (yp == NULL ||
 239             smp->lno != sp->lno || sp->cno < offset_in_line ||
 240             offset_in_line + cols_per_screen < sp->cno) {
 241                 cno_cnt = 0;
 242                 /* If the line is on the screen, quit. */
 243                 if (is_cached)
 244                         goto ret;
 245         } else
 246                 cno_cnt = (sp->cno - offset_in_line) + 1;
 247
 248         /* This is the loop that actually displays characters. */
 249         for (is_partial = 0, scno = 0;
 250             offset_in_line < len; ++offset_in_line, offset_in_char = 0) {
 251                 if ((ch = *(u_char *)p++) == '\t' && !listset) {
 252                         scno += chlen = TAB_OFF(sp, scno) - offset_in_char;
 253                         is_tab = 1;
 254                 } else {
 255                         scno += chlen = cname[ch].len - offset_in_char;
 256                         is_tab = 0;
 257                 }
 258
 259                 /*
 260                  * Only display up to the right-hand column.  Set a flag if
 261                  * the entire character wasn't displayed for use in setting
 262                  * the cursor.  If reached the end of the line, set the cache
 263                  * info for the screen.  Don't worry about there not being
 264                  * characters to display on the next screen, its lno/off won't
 265                  * match up in that case.
 266                  */
 267                 if (scno >= cols_per_screen) {
 268                         smp->c_ecsize = chlen;
 269                         chlen -= scno - cols_per_screen;
 270                         smp->c_eclen = chlen;
 271                         smp->c_eboff = offset_in_line;
 272                         if (scno > cols_per_screen)
 273                                 is_partial = 1;
 274
 275                         /* Terminate the loop. */
 276                         offset_in_line = len;
 277                 }
 278
 279                 /*
 280                  * If the caller wants the cursor value, and this was the
 281                  * cursor character, set the value.  There are two ways to
 282                  * put the cursor on a character -- if it's normal display
 283                  * mode, it goes on the last column of the character.  If
 284                  * it's input mode, it goes on the first.  In normal mode,
 285                  * set the cursor only if the entire character was displayed.
 286                  */
 287                 if (cno_cnt &&
 288                     --cno_cnt == 0 && (F_ISSET(sp, S_INPUT) || !is_partial)) {
 289                         *yp = smp - HMAP;
 290                         if (F_ISSET(sp, S_INPUT))
 291                                 *xp = scno - chlen;
 292                         else
 293                                 *xp = scno - 1;
 294                         if (O_ISSET(sp, O_NUMBER) &&
 295                             !is_infoline && smp->off == 1)
 296                                 *xp += O_NUMBER_LENGTH;
 297
 298                         /* If the line is on the screen, quit. */
 299                         if (is_cached)
 300                                 goto ret;
 301                 }
 302
 303                 /* If the line is on the screen, don't display anything. */
 304                 if (is_cached)
 305                         continue;
 306
 307                 /*
 308                  * Display the character.  If it's a tab and tabs aren't some
 309                  * ridiculous length, do it fast.  (We do tab expansion here
 310                  * because curses doesn't have a way to set the tab length.)
 311                  */
 312                 if (is_tab) {
 313                         if (chlen <= sizeof(TABSTR) - 1) {
 314                                 ADDNSTR(TABSTR, chlen);
 315                         } else
 316                                 while (chlen--)
 317                                         ADDCH(TABCH);
 318                 } else
 319                         ADDNSTR(cname[ch].name + offset_in_char, chlen);
 320         }
 321
 322         if (scno < cols_per_screen) {
 323                 /* If didn't paint the whole line, update the cache. */
 324                 smp->c_ecsize = smp->c_eclen = cname[ch].len;
 325                 smp->c_eboff = len - 1;
 326
 327                 /*
 328                  * If not the info/mode line, and O_LIST set, and at the
 329                  * end of the line, and the line ended on this screen,
 330                  * add a trailing $.
 331                  */
 332                 if (listset) {
 333                         ++scno;
 334                         ADDCH('$');
 335                 }
 336
 337                 /* If still didn't paint the whole line, clear the rest. */
 338                 if (scno < cols_per_screen)
 339                         clrtoeol();
 340         }
 341
 342 ret:    MOVEA(sp, oldy, oldx);
 343         return (0);
 344 }
 345
 346 /*
 347  * svi_number --
 348  *      Repaint the numbers on all the lines.
 349  */
 350 int
 351 svi_number(sp, ep)
 352         SCR *sp;
 353         EXF *ep;
 354 {
 355         SMAP *smp;
 356         recno_t lno;
 357         size_t oldy, oldx;
 358         char *p, nbuf[10];
 359
 360         /*
 361          * Try and avoid getting the last line in the file, by getting the
 362          * line after the last line in the screen -- if it exists, we know
 363          * we have to to number all the lines in the screen.  Get the one
 364          * after the last instead of the last, so that the info line doesn't
 365          * fool us.
 366          *
 367          * If that test fails, we have to check each line for existence.
 368          *
 369          * XXX
 370          * The problem is that file_lline will lie, and tell us that the
 371          * info line is the last line in the file.
 372          */
 373         if ((p = file_gline(sp, ep, TMAP->lno - 1, NULL)) != NULL)
 374                 lno = TMAP->lno + 1;
 375
 376         getyx(stdscr, oldy, oldx);
 377         for (smp = HMAP; smp <= TMAP; ++smp) {
 378                 if (smp->off != 1)
 379                         continue;
 380                 if (ISINFOLINE(sp, smp))
 381                         break;
 382                 if (smp->lno != 1)
 383                         if (p != NULL) {
 384                                 if (smp->lno > lno)
 385                                         break;
 386                         } else {
 387                                 if ((p =
 388                                     file_gline(sp, ep, smp->lno, NULL)) == NULL)
 389                                         break;
 390                                 p = NULL;
 391                         }
 392                 MOVE(sp, smp - HMAP, 0);
 393                 (void)snprintf(nbuf, sizeof(nbuf), O_NUMBER_FMT, smp->lno);
 394                 ADDSTR(nbuf);
 395         }
 396         MOVEA(sp, oldy, oldx);
 397         return (0);
 398 }