contrib/nvi/vi/vs_relative.c

   1 /*-
   2  * Copyright (c) 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  * Copyright (c) 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 /*
  25  * vs_column --
  26  *      Return the logical column of the cursor in the line.
  27  *
  28  * PUBLIC: int vs_column(SCR *, size_t *);
  29  */
  30 int
  31 vs_column(SCR *sp, size_t *colp)
  32 {
  33         VI_PRIVATE *vip;
  34
  35         vip = VIP(sp);
  36
  37         *colp = (O_ISSET(sp, O_LEFTRIGHT) ?
  38             vip->sc_smap->coff : (vip->sc_smap->soff - 1) * sp->cols) +
  39             vip->sc_col - (O_ISSET(sp, O_NUMBER) ? O_NUMBER_LENGTH : 0);
  40         return (0);
  41 }
  42
  43 /*
  44  * vs_screens --
  45  *      Return the screens necessary to display the line, or if specified,
  46  *      the physical character column within the line, including space
  47  *      required for the O_NUMBER and O_LIST options.
  48  *
  49  * PUBLIC: size_t vs_screens(SCR *, recno_t, size_t *);
  50  */
  51 size_t
  52 vs_screens(SCR *sp, recno_t lno, size_t *cnop)
  53 {
  54         size_t cols, screens;
  55
  56         /* Left-right screens are simple, it's always 1. */
  57         if (O_ISSET(sp, O_LEFTRIGHT))
  58                 return (1);
  59
  60         /*
  61          * Check for a cached value.  We maintain a cache because, if the
  62          * line is large, this routine gets called repeatedly.  One other
  63          * hack, lots of time the cursor is on column one, which is an easy
  64          * one.
  65          */
  66         if (cnop == NULL) {
  67                 if (VIP(sp)->ss_lno == lno)
  68                         return (VIP(sp)->ss_screens);
  69         } else if (*cnop == 0)
  70                 return (1);
  71
  72         /* Figure out how many columns the line/column needs. */
  73         cols = vs_columns(sp, NULL, lno, cnop, NULL);
  74
  75         screens = (cols / sp->cols + (cols % sp->cols ? 1 : 0));
  76         if (screens == 0)
  77                 screens = 1;
  78
  79         /* Cache the value. */
  80         if (cnop == NULL) {
  81                 VIP(sp)->ss_lno = lno;
  82                 VIP(sp)->ss_screens = screens;
  83         }
  84         return (screens);
  85 }
  86
  87 /*
  88  * vs_columns --
  89  *      Return the screen columns necessary to display the line, or,
  90  *      if specified, the physical character column within the line.
  91  *
  92  * PUBLIC: size_t vs_columns(SCR *, CHAR_T *, recno_t, size_t *, size_t *);
  93  */
  94 size_t
  95 vs_columns(SCR *sp, CHAR_T *lp, recno_t lno, size_t *cnop, size_t *diffp)
  96 {
  97         size_t chlen, cno, curoff, last = 0, len, scno;
  98         int ch, leftright, listset;
  99         CHAR_T *p;
 100
 101         /*
 102          * Initialize the screen offset.
 103          */
 104         scno = 0;
 105
 106         /* Leading number if O_NUMBER option set. */
 107         if (O_ISSET(sp, O_NUMBER))
 108                 scno += O_NUMBER_LENGTH;
 109
 110         /* Need the line to go any further. */
 111         if (lp == NULL) {
 112                 (void)db_get(sp, lno, 0, &lp, &len);
 113                 if (len == 0)
 114                         goto done;
 115         }
 116
 117         /* Missing or empty lines are easy. */
 118         if (lp == NULL) {
 119 done:           if (diffp != NULL)              /* XXX */
 120                         *diffp = 0;
 121                 return scno;
 122         }
 123
 124         /* Store away the values of the list and leftright edit options. */
 125         listset = O_ISSET(sp, O_LIST);
 126         leftright = O_ISSET(sp, O_LEFTRIGHT);
 127
 128         /*
 129          * Initialize the pointer into the buffer and current offset.
 130          */
 131         p = lp;
 132         curoff = scno;
 133
 134         /* Macro to return the display length of any signal character. */
 135 #define CHLEN(val) (ch = *(UCHAR_T *)p++) == '\t' &&                    \
 136             !listset ? TAB_OFF(val) : KEY_COL(sp, ch);
 137
 138         /*
 139          * If folding screens (the historic vi screen format), past the end
 140          * of the current screen, and the character was a tab, reset the
 141          * current screen column to 0, and the total screen columns to the
 142          * last column of the screen.  Otherwise, display the rest of the
 143          * character in the next screen.
 144          */
 145 #define TAB_RESET do {                                                  \
 146         curoff += chlen;                                                \
 147         if (!leftright && curoff >= sp->cols) {                         \
 148                 if (ch == '\t') {                                       \
 149                         curoff = 0;                                     \
 150                         scno -= scno % sp->cols;                        \
 151                 } else                                                  \
 152                         curoff -= sp->cols;                             \
 153         }                                                               \
 154 } while (0)
 155         if (cnop == NULL)
 156                 while (len--) {
 157                         chlen = CHLEN(curoff);
 158                         last = scno;
 159                         scno += chlen;
 160                         TAB_RESET;
 161                 }
 162         else
 163                 for (cno = *cnop;; --cno) {
 164                         chlen = CHLEN(curoff);
 165                         last = scno;
 166                         scno += chlen;
 167                         TAB_RESET;
 168                         if (cno == 0)
 169                                 break;
 170                 }
 171
 172         /* Add the trailing '$' if the O_LIST option set. */
 173         if (listset && cnop == NULL)
 174                 scno += KEY_LEN(sp, '$');
 175
 176         /*
 177          * The text input screen code needs to know how much additional
 178          * room the last two characters required, so that it can handle
 179          * tab character displays correctly.
 180          */
 181         if (diffp != NULL)
 182                 *diffp = scno - last;
 183         return (scno);
 184 }
 185
 186 /*
 187  * vs_rcm --
 188  *      Return the physical column from the line that will display a
 189  *      character closest to the currently most attractive character
 190  *      position (which is stored as a screen column).
 191  *
 192  * PUBLIC: size_t vs_rcm(SCR *, recno_t, int);
 193  */
 194 size_t
 195 vs_rcm(SCR *sp, recno_t lno, int islast)
 196 {
 197         size_t len;
 198
 199         /* Last character is easy, and common. */
 200         if (islast) {
 201                 if (db_get(sp, lno, 0, NULL, &len) || len == 0)
 202                         return (0);
 203                 return (len - 1);
 204         }
 205
 206         /* First character is easy, and common. */
 207         if (sp->rcm == 0)
 208                 return (0);
 209
 210         return (vs_colpos(sp, lno, sp->rcm));
 211 }
 212
 213 /*
 214  * vs_colpos --
 215  *      Return the physical column from the line that will display a
 216  *      character closest to the specified screen column.
 217  *
 218  * PUBLIC: size_t vs_colpos(SCR *, recno_t, size_t);
 219  */
 220 size_t
 221 vs_colpos(SCR *sp, recno_t lno, size_t cno)
 222 {
 223         size_t chlen, curoff, len, llen, off, scno;
 224         int ch = 0, leftright, listset;
 225         CHAR_T *lp, *p;
 226
 227         /* Need the line to go any further. */
 228         (void)db_get(sp, lno, 0, &lp, &llen);
 229
 230         /* Missing or empty lines are easy. */
 231         if (lp == NULL || llen == 0)
 232                 return (0);
 233
 234         /* Store away the values of the list and leftright edit options. */
 235         listset = O_ISSET(sp, O_LIST);
 236         leftright = O_ISSET(sp, O_LEFTRIGHT);
 237
 238         /* Discard screen (logical) lines. */
 239         off = cno / sp->cols;
 240         cno %= sp->cols;
 241         for (scno = 0, p = lp, len = llen; off--;) {
 242                 for (; len && scno < sp->cols; --len)
 243                         scno += CHLEN(scno);
 244
 245                 /*
 246                  * If reached the end of the physical line, return the last
 247                  * physical character in the line.
 248                  */
 249                 if (len == 0)
 250                         return (llen - 1);
 251
 252                 /*
 253                  * If folding screens (the historic vi screen format), past
 254                  * the end of the current screen, and the character was a tab,
 255                  * reset the current screen column to 0.  Otherwise, the rest
 256                  * of the character is displayed in the next screen.
 257                  */
 258                 if (leftright && ch == '\t')
 259                         scno = 0;
 260                 else
 261                         scno -= sp->cols;
 262         }
 263
 264         /* Step through the line until reach the right character or EOL. */
 265         for (curoff = scno; len--;) {
 266                 chlen = CHLEN(curoff);
 267
 268                 /*
 269                  * If we've reached the specific character, there are three
 270                  * cases.
 271                  *
 272                  * 1: scno == cno, i.e. the current character ends at the
 273                  *    screen character we care about.
 274                  *      a: off < llen - 1, i.e. not the last character in
 275                  *         the line, return the offset of the next character.
 276                  *      b: else return the offset of the last character.
 277                  * 2: scno != cno, i.e. this character overruns the character
 278                  *    we care about, return the offset of this character.
 279                  */
 280                 if ((scno += chlen) >= cno) {
 281                         off = p - lp;
 282                         return (scno == cno ?
 283                             (off < llen - 1 ? off : llen - 1) : off - 1);
 284                 }
 285
 286                 TAB_RESET;
 287         }
 288
 289         /* No such character; return the start of the last character. */
 290         return (llen - 1);
 291 }