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 } 292