blob: 92567bf7bce72e3c1de9b723672c3850c724d29c [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10#include "vim.h"
11
Bram Moolenaar13505972019-01-24 15:04:48 +010012#if defined(HAVE_WCHAR_H)
Bram Moolenaarc667da52019-11-30 20:52:27 +010013# include <wchar.h> // for towupper() and towlower()
Bram Moolenaar071d4272004-06-13 20:20:40 +000014#endif
15
Bram Moolenaar7f9969c2022-07-25 18:13:54 +010016static int win_nolbr_chartabsize(chartabsize_T *cts, int *headp);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +010017static unsigned nr2hex(unsigned c);
Bram Moolenaar071d4272004-06-13 20:20:40 +000018
19static int chartab_initialized = FALSE;
20
Bram Moolenaarc667da52019-11-30 20:52:27 +010021// b_chartab[] is an array of 32 bytes, each bit representing one of the
22// characters 0-255.
Bram Moolenaar071d4272004-06-13 20:20:40 +000023#define SET_CHARTAB(buf, c) (buf)->b_chartab[(unsigned)(c) >> 3] |= (1 << ((c) & 0x7))
24#define RESET_CHARTAB(buf, c) (buf)->b_chartab[(unsigned)(c) >> 3] &= ~(1 << ((c) & 0x7))
25#define GET_CHARTAB(buf, c) ((buf)->b_chartab[(unsigned)(c) >> 3] & (1 << ((c) & 0x7)))
26
Bram Moolenaarc667da52019-11-30 20:52:27 +010027// table used below, see init_chartab() for an explanation
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +010028static char_u g_chartab[256];
29
Bram Moolenaar071d4272004-06-13 20:20:40 +000030/*
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +010031 * Flags for g_chartab[].
32 */
Bram Moolenaarc667da52019-11-30 20:52:27 +010033#define CT_CELL_MASK 0x07 // mask: nr of display cells (1, 2 or 4)
34#define CT_PRINT_CHAR 0x10 // flag: set for printable chars
35#define CT_ID_CHAR 0x20 // flag: set for ID chars
36#define CT_FNAME_CHAR 0x40 // flag: set for file name chars
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +010037
Bram Moolenaar5843f5f2019-08-20 20:13:45 +020038static int in_win_border(win_T *wp, colnr_T vcol);
39
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +010040/*
41 * Fill g_chartab[]. Also fills curbuf->b_chartab[] with flags for keyword
Bram Moolenaar071d4272004-06-13 20:20:40 +000042 * characters for current buffer.
43 *
44 * Depends on the option settings 'iskeyword', 'isident', 'isfname',
45 * 'isprint' and 'encoding'.
46 *
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +010047 * The index in g_chartab[] depends on 'encoding':
Bram Moolenaar071d4272004-06-13 20:20:40 +000048 * - For non-multi-byte index with the byte (same as the character).
49 * - For DBCS index with the first byte.
50 * - For UTF-8 index with the character (when first byte is up to 0x80 it is
51 * the same as the character, if the first byte is 0x80 and above it depends
52 * on further bytes).
53 *
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +010054 * The contents of g_chartab[]:
Bram Moolenaar071d4272004-06-13 20:20:40 +000055 * - The lower two bits, masked by CT_CELL_MASK, give the number of display
56 * cells the character occupies (1 or 2). Not valid for UTF-8 above 0x80.
57 * - CT_PRINT_CHAR bit is set when the character is printable (no need to
58 * translate the character before displaying it). Note that only DBCS
59 * characters can have 2 display cells and still be printable.
60 * - CT_FNAME_CHAR bit is set when the character can be in a file name.
61 * - CT_ID_CHAR bit is set when the character can be in an identifier.
62 *
63 * Return FAIL if 'iskeyword', 'isident', 'isfname' or 'isprint' option has an
64 * error, OK otherwise.
65 */
66 int
Bram Moolenaar7454a062016-01-30 15:14:10 +010067init_chartab(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +000068{
69 return buf_init_chartab(curbuf, TRUE);
70}
71
72 int
Bram Moolenaar7454a062016-01-30 15:14:10 +010073buf_init_chartab(
74 buf_T *buf,
Bram Moolenaarc667da52019-11-30 20:52:27 +010075 int global) // FALSE: only set buf->b_chartab[]
Bram Moolenaar071d4272004-06-13 20:20:40 +000076{
77 int c;
78 int c2;
79 char_u *p;
80 int i;
81 int tilde;
82 int do_isalpha;
83
84 if (global)
85 {
86 /*
87 * Set the default size for printable characters:
88 * From <Space> to '~' is 1 (printable), others are 2 (not printable).
89 * This also inits all 'isident' and 'isfname' flags to FALSE.
Bram Moolenaar071d4272004-06-13 20:20:40 +000090 */
91 c = 0;
92 while (c < ' ')
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +010093 g_chartab[c++] = (dy_flags & DY_UHEX) ? 4 : 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +000094 while (c <= '~')
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +010095 g_chartab[c++] = 1 + CT_PRINT_CHAR;
Bram Moolenaar071d4272004-06-13 20:20:40 +000096 while (c < 256)
97 {
Bram Moolenaarc667da52019-11-30 20:52:27 +010098 // UTF-8: bytes 0xa0 - 0xff are printable (latin1)
Bram Moolenaar071d4272004-06-13 20:20:40 +000099 if (enc_utf8 && c >= 0xa0)
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100100 g_chartab[c++] = CT_PRINT_CHAR + 1;
Bram Moolenaarc667da52019-11-30 20:52:27 +0100101 // euc-jp characters starting with 0x8e are single width
Bram Moolenaar071d4272004-06-13 20:20:40 +0000102 else if (enc_dbcs == DBCS_JPNU && c == 0x8e)
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100103 g_chartab[c++] = CT_PRINT_CHAR + 1;
Bram Moolenaarc667da52019-11-30 20:52:27 +0100104 // other double-byte chars can be printable AND double-width
Bram Moolenaar071d4272004-06-13 20:20:40 +0000105 else if (enc_dbcs != 0 && MB_BYTE2LEN(c) == 2)
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100106 g_chartab[c++] = CT_PRINT_CHAR + 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000107 else
Bram Moolenaarc667da52019-11-30 20:52:27 +0100108 // the rest is unprintable by default
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100109 g_chartab[c++] = (dy_flags & DY_UHEX) ? 4 : 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000110 }
111
Bram Moolenaarc667da52019-11-30 20:52:27 +0100112 // Assume that every multi-byte char is a filename character.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000113 for (c = 1; c < 256; ++c)
114 if ((enc_dbcs != 0 && MB_BYTE2LEN(c) > 1)
115 || (enc_dbcs == DBCS_JPNU && c == 0x8e)
116 || (enc_utf8 && c >= 0xa0))
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100117 g_chartab[c] |= CT_FNAME_CHAR;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000118 }
119
120 /*
121 * Init word char flags all to FALSE
122 */
Bram Moolenaara80faa82020-04-12 19:37:17 +0200123 CLEAR_FIELD(buf->b_chartab);
Bram Moolenaar6bb68362005-03-22 23:03:44 +0000124 if (enc_dbcs != 0)
125 for (c = 0; c < 256; ++c)
126 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100127 // double-byte characters are probably word characters
Bram Moolenaar6bb68362005-03-22 23:03:44 +0000128 if (MB_BYTE2LEN(c) == 2)
129 SET_CHARTAB(buf, c);
130 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000131
Bram Moolenaar071d4272004-06-13 20:20:40 +0000132 /*
133 * In lisp mode the '-' character is included in keywords.
134 */
135 if (buf->b_p_lisp)
136 SET_CHARTAB(buf, '-');
Bram Moolenaar071d4272004-06-13 20:20:40 +0000137
Bram Moolenaarc667da52019-11-30 20:52:27 +0100138 // Walk through the 'isident', 'iskeyword', 'isfname' and 'isprint'
139 // options Each option is a list of characters, character numbers or
140 // ranges, separated by commas, e.g.: "200-210,x,#-178,-"
Bram Moolenaar071d4272004-06-13 20:20:40 +0000141 for (i = global ? 0 : 3; i <= 3; ++i)
142 {
143 if (i == 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100144 p = p_isi; // first round: 'isident'
Bram Moolenaar071d4272004-06-13 20:20:40 +0000145 else if (i == 1)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100146 p = p_isp; // second round: 'isprint'
Bram Moolenaar071d4272004-06-13 20:20:40 +0000147 else if (i == 2)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100148 p = p_isf; // third round: 'isfname'
149 else // i == 3
150 p = buf->b_p_isk; // fourth round: 'iskeyword'
Bram Moolenaar071d4272004-06-13 20:20:40 +0000151
152 while (*p)
153 {
154 tilde = FALSE;
155 do_isalpha = FALSE;
156 if (*p == '^' && p[1] != NUL)
157 {
158 tilde = TRUE;
159 ++p;
160 }
161 if (VIM_ISDIGIT(*p))
162 c = getdigits(&p);
Dominique Pelle4781d6f2021-05-18 21:46:31 +0200163 else if (has_mbyte)
Bram Moolenaar183bb3e2009-09-11 12:02:34 +0000164 c = mb_ptr2char_adv(&p);
165 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000166 c = *p++;
167 c2 = -1;
168 if (*p == '-' && p[1] != NUL)
169 {
170 ++p;
171 if (VIM_ISDIGIT(*p))
172 c2 = getdigits(&p);
Dominique Pelle4781d6f2021-05-18 21:46:31 +0200173 else if (has_mbyte)
Bram Moolenaar2ac5e602009-11-03 15:04:20 +0000174 c2 = mb_ptr2char_adv(&p);
175 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000176 c2 = *p++;
177 }
Bram Moolenaar2ac5e602009-11-03 15:04:20 +0000178 if (c <= 0 || c >= 256 || (c2 < c && c2 != -1) || c2 >= 256
Bram Moolenaar071d4272004-06-13 20:20:40 +0000179 || !(*p == NUL || *p == ','))
180 return FAIL;
181
Bram Moolenaarc667da52019-11-30 20:52:27 +0100182 if (c2 == -1) // not a range
Bram Moolenaar071d4272004-06-13 20:20:40 +0000183 {
184 /*
185 * A single '@' (not "@-@"):
186 * Decide on letters being ID/printable/keyword chars with
187 * standard function isalpha(). This takes care of locale for
188 * single-byte characters).
189 */
190 if (c == '@')
191 {
192 do_isalpha = TRUE;
193 c = 1;
194 c2 = 255;
195 }
196 else
197 c2 = c;
198 }
199 while (c <= c2)
200 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100201 // Use the MB_ functions here, because isalpha() doesn't
202 // work properly when 'encoding' is "latin1" and the locale is
203 // "C".
Bram Moolenaar14184a32019-02-16 15:10:30 +0100204 if (!do_isalpha || MB_ISLOWER(c) || MB_ISUPPER(c))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000205 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100206 if (i == 0) // (re)set ID flag
Bram Moolenaar071d4272004-06-13 20:20:40 +0000207 {
208 if (tilde)
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100209 g_chartab[c] &= ~CT_ID_CHAR;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000210 else
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100211 g_chartab[c] |= CT_ID_CHAR;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000212 }
Bram Moolenaarc667da52019-11-30 20:52:27 +0100213 else if (i == 1) // (re)set printable
Bram Moolenaar071d4272004-06-13 20:20:40 +0000214 {
Bram Moolenaar424bcae2022-01-31 14:59:41 +0000215 if ((c < ' ' || c > '~'
Bram Moolenaar13505972019-01-24 15:04:48 +0100216 // For double-byte we keep the cell width, so
217 // that we can detect it from the first byte.
218 ) && !(enc_dbcs && MB_BYTE2LEN(c) == 2))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000219 {
220 if (tilde)
221 {
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100222 g_chartab[c] = (g_chartab[c] & ~CT_CELL_MASK)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000223 + ((dy_flags & DY_UHEX) ? 4 : 2);
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100224 g_chartab[c] &= ~CT_PRINT_CHAR;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000225 }
226 else
227 {
Bram Moolenaarbc49c5f2022-08-04 13:01:48 +0100228 g_chartab[c] = (g_chartab[c] & ~CT_CELL_MASK)
229 + 1;
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100230 g_chartab[c] |= CT_PRINT_CHAR;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000231 }
232 }
233 }
Bram Moolenaarc667da52019-11-30 20:52:27 +0100234 else if (i == 2) // (re)set fname flag
Bram Moolenaar071d4272004-06-13 20:20:40 +0000235 {
236 if (tilde)
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100237 g_chartab[c] &= ~CT_FNAME_CHAR;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000238 else
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100239 g_chartab[c] |= CT_FNAME_CHAR;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000240 }
Bram Moolenaarc667da52019-11-30 20:52:27 +0100241 else // i == 3 (re)set keyword flag
Bram Moolenaar071d4272004-06-13 20:20:40 +0000242 {
243 if (tilde)
244 RESET_CHARTAB(buf, c);
245 else
246 SET_CHARTAB(buf, c);
247 }
248 }
249 ++c;
250 }
Bram Moolenaar309379f2013-02-06 16:26:26 +0100251
252 c = *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000253 p = skip_to_option_part(p);
Bram Moolenaar309379f2013-02-06 16:26:26 +0100254 if (c == ',' && *p == NUL)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100255 // Trailing comma is not allowed.
Bram Moolenaar309379f2013-02-06 16:26:26 +0100256 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000257 }
258 }
259 chartab_initialized = TRUE;
260 return OK;
261}
262
263/*
264 * Translate any special characters in buf[bufsize] in-place.
265 * The result is a string with only printable characters, but if there is not
266 * enough room, not all characters will be translated.
267 */
268 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100269trans_characters(
270 char_u *buf,
271 int bufsize)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000272{
Bram Moolenaarc667da52019-11-30 20:52:27 +0100273 int len; // length of string needing translation
274 int room; // room in buffer after string
275 char_u *trs; // translated character
276 int trs_len; // length of trs[]
Bram Moolenaar071d4272004-06-13 20:20:40 +0000277
278 len = (int)STRLEN(buf);
279 room = bufsize - len;
280 while (*buf != 0)
281 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100282 // Assume a multi-byte character doesn't need translation.
Bram Moolenaar0fa313a2005-08-10 21:07:57 +0000283 if (has_mbyte && (trs_len = (*mb_ptr2len)(buf)) > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000284 len -= trs_len;
285 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000286 {
287 trs = transchar_byte(*buf);
288 trs_len = (int)STRLEN(trs);
289 if (trs_len > 1)
290 {
291 room -= trs_len - 1;
292 if (room <= 0)
293 return;
294 mch_memmove(buf + trs_len, buf + 1, (size_t)len);
295 }
296 mch_memmove(buf, trs, (size_t)trs_len);
297 --len;
298 }
299 buf += trs_len;
300 }
301}
302
Bram Moolenaar071d4272004-06-13 20:20:40 +0000303/*
304 * Translate a string into allocated memory, replacing special chars with
305 * printable chars. Returns NULL when out of memory.
306 */
307 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100308transstr(char_u *s)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000309{
310 char_u *res;
311 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000312 int l, len, c;
313 char_u hexbuf[11];
Bram Moolenaar071d4272004-06-13 20:20:40 +0000314
Bram Moolenaar071d4272004-06-13 20:20:40 +0000315 if (has_mbyte)
316 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100317 // Compute the length of the result, taking account of unprintable
318 // multi-byte characters.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000319 len = 0;
320 p = s;
321 while (*p != NUL)
322 {
Bram Moolenaar0fa313a2005-08-10 21:07:57 +0000323 if ((l = (*mb_ptr2len)(p)) > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000324 {
325 c = (*mb_ptr2char)(p);
326 p += l;
327 if (vim_isprintc(c))
328 len += l;
329 else
330 {
331 transchar_hex(hexbuf, c);
Bram Moolenaara93fa7e2006-04-17 22:14:47 +0000332 len += (int)STRLEN(hexbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000333 }
334 }
335 else
336 {
337 l = byte2cells(*p++);
338 if (l > 0)
339 len += l;
340 else
Bram Moolenaarc667da52019-11-30 20:52:27 +0100341 len += 4; // illegal byte sequence
Bram Moolenaar071d4272004-06-13 20:20:40 +0000342 }
343 }
Bram Moolenaar964b3742019-05-24 18:54:09 +0200344 res = alloc(len + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000345 }
346 else
Bram Moolenaar964b3742019-05-24 18:54:09 +0200347 res = alloc(vim_strsize(s) + 1);
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +0000348
349 if (res == NULL)
350 return NULL;
351
352 *res = NUL;
353 p = s;
354 while (*p != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000355 {
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +0000356 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000357 {
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +0000358 c = (*mb_ptr2char)(p);
359 if (vim_isprintc(c))
360 STRNCAT(res, p, l); // append printable multi-byte char
Bram Moolenaar071d4272004-06-13 20:20:40 +0000361 else
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +0000362 transchar_hex(res + STRLEN(res), c);
363 p += l;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000364 }
Yegappan Lakshmanan1cfb14a2023-01-09 19:04:23 +0000365 else
366 STRCAT(res, transchar_byte(*p++));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000367 }
368 return res;
369}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000370
Bram Moolenaar071d4272004-06-13 20:20:40 +0000371/*
Bram Moolenaar217ad922005-03-20 22:37:15 +0000372 * Convert the string "str[orglen]" to do ignore-case comparing. Uses the
373 * current locale.
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000374 * When "buf" is NULL returns an allocated string (NULL for out-of-memory).
375 * Otherwise puts the result in "buf[buflen]".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000376 */
377 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100378str_foldcase(
379 char_u *str,
380 int orglen,
381 char_u *buf,
382 int buflen)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000383{
384 garray_T ga;
385 int i;
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000386 int len = orglen;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000387
388#define GA_CHAR(i) ((char_u *)ga.ga_data)[i]
kylo252ae6f1d82022-02-16 19:24:07 +0000389#define GA_PTR(i) ((char_u *)ga.ga_data + (i))
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000390#define STR_CHAR(i) (buf == NULL ? GA_CHAR(i) : buf[i])
kylo252ae6f1d82022-02-16 19:24:07 +0000391#define STR_PTR(i) (buf == NULL ? GA_PTR(i) : buf + (i))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000392
Bram Moolenaarc667da52019-11-30 20:52:27 +0100393 // Copy "str" into "buf" or allocated memory, unmodified.
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000394 if (buf == NULL)
395 {
396 ga_init2(&ga, 1, 10);
397 if (ga_grow(&ga, len + 1) == FAIL)
398 return NULL;
399 mch_memmove(ga.ga_data, str, (size_t)len);
400 ga.ga_len = len;
401 }
402 else
403 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100404 if (len >= buflen) // Ugly!
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000405 len = buflen - 1;
406 mch_memmove(buf, str, (size_t)len);
407 }
408 if (buf == NULL)
409 GA_CHAR(len) = NUL;
410 else
411 buf[len] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000412
Bram Moolenaarc667da52019-11-30 20:52:27 +0100413 // Make each character lower case.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000414 i = 0;
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000415 while (STR_CHAR(i) != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000416 {
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000417 if (enc_utf8 || (has_mbyte && MB_BYTE2LEN(STR_CHAR(i)) > 1))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000418 {
419 if (enc_utf8)
420 {
Bram Moolenaarb9839212008-06-28 11:03:50 +0000421 int c = utf_ptr2char(STR_PTR(i));
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100422 int olen = utf_ptr2len(STR_PTR(i));
Bram Moolenaarb9839212008-06-28 11:03:50 +0000423 int lc = utf_tolower(c);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000424
Bram Moolenaarc667da52019-11-30 20:52:27 +0100425 // Only replace the character when it is not an invalid
426 // sequence (ASCII character or more than one byte) and
427 // utf_tolower() doesn't return the original character.
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100428 if ((c < 0x80 || olen > 1) && c != lc)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000429 {
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100430 int nlen = utf_char2len(lc);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000431
Bram Moolenaarc667da52019-11-30 20:52:27 +0100432 // If the byte length changes need to shift the following
433 // characters forward or backward.
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100434 if (olen != nlen)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000435 {
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100436 if (nlen > olen)
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000437 {
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100438 if (buf == NULL
439 ? ga_grow(&ga, nlen - olen + 1) == FAIL
440 : len + nlen - olen >= buflen)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000441 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100442 // out of memory, keep old char
Bram Moolenaar071d4272004-06-13 20:20:40 +0000443 lc = c;
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100444 nlen = olen;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000445 }
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000446 }
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100447 if (olen != nlen)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000448 {
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000449 if (buf == NULL)
450 {
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100451 STRMOVE(GA_PTR(i) + nlen, GA_PTR(i) + olen);
452 ga.ga_len += nlen - olen;
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000453 }
454 else
455 {
Bram Moolenaar70b2a562012-01-10 22:26:17 +0100456 STRMOVE(buf + i + nlen, buf + i + olen);
457 len += nlen - olen;
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000458 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000459 }
460 }
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000461 (void)utf_char2bytes(lc, STR_PTR(i));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000462 }
463 }
Bram Moolenaarc667da52019-11-30 20:52:27 +0100464 // skip to next multi-byte char
Bram Moolenaar0fa313a2005-08-10 21:07:57 +0000465 i += (*mb_ptr2len)(STR_PTR(i));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000466 }
467 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000468 {
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000469 if (buf == NULL)
470 GA_CHAR(i) = TOLOWER_LOC(GA_CHAR(i));
471 else
472 buf[i] = TOLOWER_LOC(buf[i]);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000473 ++i;
474 }
475 }
476
Bram Moolenaar6ebb1142005-01-25 21:58:26 +0000477 if (buf == NULL)
478 return (char_u *)ga.ga_data;
479 return buf;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000480}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000481
482/*
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100483 * Catch 22: g_chartab[] can't be initialized before the options are
Bram Moolenaar071d4272004-06-13 20:20:40 +0000484 * initialized, and initializing options may cause transchar() to be called!
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100485 * When chartab_initialized == FALSE don't use g_chartab[].
Bram Moolenaar071d4272004-06-13 20:20:40 +0000486 * Does NOT work for multi-byte characters, c must be <= 255.
487 * Also doesn't work for the first byte of a multi-byte, "c" must be a
488 * character!
489 */
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200490static char_u transchar_charbuf[7];
Bram Moolenaar071d4272004-06-13 20:20:40 +0000491
492 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100493transchar(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000494{
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200495 return transchar_buf(curbuf, c);
496}
497
498 char_u *
499transchar_buf(buf_T *buf, int c)
500{
Bram Moolenaar071d4272004-06-13 20:20:40 +0000501 int i;
502
503 i = 0;
Bram Moolenaarc667da52019-11-30 20:52:27 +0100504 if (IS_SPECIAL(c)) // special key code, display as ~@ char
Bram Moolenaar071d4272004-06-13 20:20:40 +0000505 {
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200506 transchar_charbuf[0] = '~';
507 transchar_charbuf[1] = '@';
Bram Moolenaar071d4272004-06-13 20:20:40 +0000508 i = 2;
509 c = K_SECOND(c);
510 }
511
Bram Moolenaar424bcae2022-01-31 14:59:41 +0000512 if ((!chartab_initialized && ((c >= ' ' && c <= '~')))
513 || (c < 256 && vim_isprintc_strict(c)))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000514 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100515 // printable character
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200516 transchar_charbuf[i] = c;
517 transchar_charbuf[i + 1] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000518 }
519 else
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200520 transchar_nonprint(buf, transchar_charbuf + i, c);
521 return transchar_charbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000522}
523
Bram Moolenaar071d4272004-06-13 20:20:40 +0000524/*
525 * Like transchar(), but called with a byte instead of a character. Checks
cero19881d87e112023-02-16 15:03:12 +0000526 * for an illegal UTF-8 byte. Uses 'fileformat' of the current buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000527 */
528 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +0100529transchar_byte(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000530{
cero19881d87e112023-02-16 15:03:12 +0000531 return transchar_byte_buf(curbuf, c);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000532}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000533
534/*
cero19881d87e112023-02-16 15:03:12 +0000535 * Like transchar_buf(), but called with a byte instead of a character. Checks
536 * for an illegal UTF-8 byte. Uses 'fileformat' of "buf", unless it is NULL.
537 */
538 char_u *
539transchar_byte_buf(buf_T *buf, int c)
540{
541 if (enc_utf8 && c >= 0x80)
542 {
543 transchar_nonprint(buf, transchar_charbuf, c);
544 return transchar_charbuf;
545 }
546 return transchar_buf(buf, c);
547}
548/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000549 * Convert non-printable character to two or more printable characters in
Bram Moolenaara9a6b032023-02-05 18:00:42 +0000550 * "charbuf[]". "charbuf" needs to be able to hold five bytes.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000551 * Does NOT work for multi-byte characters, c must be <= 255.
552 */
553 void
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200554transchar_nonprint(buf_T *buf, char_u *charbuf, int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000555{
556 if (c == NL)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100557 c = NUL; // we use newline in place of a NUL
cero19881d87e112023-02-16 15:03:12 +0000558 else if (buf != NULL && c == CAR && get_fileformat(buf) == EOL_MAC)
Bram Moolenaarc667da52019-11-30 20:52:27 +0100559 c = NL; // we use CR in place of NL in this case
Bram Moolenaar071d4272004-06-13 20:20:40 +0000560
Bram Moolenaarc667da52019-11-30 20:52:27 +0100561 if (dy_flags & DY_UHEX) // 'display' has "uhex"
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200562 transchar_hex(charbuf, c);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000563
Bram Moolenaarc667da52019-11-30 20:52:27 +0100564 else if (c <= 0x7f) // 0x00 - 0x1f and 0x7f
Bram Moolenaar071d4272004-06-13 20:20:40 +0000565 {
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200566 charbuf[0] = '^';
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200567 charbuf[1] = c ^ 0x40; // DEL displayed as ^?
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200568 charbuf[2] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000569 }
=?UTF-8?q?Dundar=20G=C3=B6c?=f01a6532022-03-09 13:00:54 +0000570 else if (enc_utf8)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000571 {
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200572 transchar_hex(charbuf, c);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000573 }
Bram Moolenaarc667da52019-11-30 20:52:27 +0100574 else if (c >= ' ' + 0x80 && c <= '~' + 0x80) // 0xa0 - 0xfe
Bram Moolenaar071d4272004-06-13 20:20:40 +0000575 {
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200576 charbuf[0] = '|';
577 charbuf[1] = c - 0x80;
578 charbuf[2] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000579 }
Bram Moolenaarc667da52019-11-30 20:52:27 +0100580 else // 0x80 - 0x9f and 0xff
Bram Moolenaar071d4272004-06-13 20:20:40 +0000581 {
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200582 charbuf[0] = '~';
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200583 charbuf[1] = (c - 0x80) ^ 0x40; // 0xff displayed as ~?
Bram Moolenaar32ee6272020-06-10 14:16:49 +0200584 charbuf[2] = NUL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000585 }
586}
587
588 void
Bram Moolenaar7454a062016-01-30 15:14:10 +0100589transchar_hex(char_u *buf, int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000590{
591 int i = 0;
592
593 buf[0] = '<';
Bram Moolenaar071d4272004-06-13 20:20:40 +0000594 if (c > 255)
595 {
596 buf[++i] = nr2hex((unsigned)c >> 12);
597 buf[++i] = nr2hex((unsigned)c >> 8);
598 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000599 buf[++i] = nr2hex((unsigned)c >> 4);
Bram Moolenaar0ab2a882009-05-13 10:51:08 +0000600 buf[++i] = nr2hex((unsigned)c);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000601 buf[++i] = '>';
602 buf[++i] = NUL;
603}
604
605/*
606 * Convert the lower 4 bits of byte "c" to its hex character.
607 * Lower case letters are used to avoid the confusion of <F1> being 0xf1 or
608 * function key 1.
609 */
Bram Moolenaar0ab2a882009-05-13 10:51:08 +0000610 static unsigned
Bram Moolenaar7454a062016-01-30 15:14:10 +0100611nr2hex(unsigned c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000612{
613 if ((c & 0xf) <= 9)
614 return (c & 0xf) + '0';
615 return (c & 0xf) - 10 + 'a';
616}
617
618/*
619 * Return number of display cells occupied by byte "b".
620 * Caller must make sure 0 <= b <= 255.
621 * For multi-byte mode "b" must be the first byte of a character.
622 * A TAB is counted as two cells: "^I".
623 * For UTF-8 mode this will return 0 for bytes >= 0x80, because the number of
624 * cells depends on further bytes.
625 */
626 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100627byte2cells(int b)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000628{
Bram Moolenaar071d4272004-06-13 20:20:40 +0000629 if (enc_utf8 && b >= 0x80)
630 return 0;
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100631 return (g_chartab[b] & CT_CELL_MASK);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000632}
633
634/*
635 * Return number of display cells occupied by character "c".
636 * "c" can be a special key (negative number) in which case 3 or 4 is returned.
637 * A TAB is counted as two cells: "^I" or four: "<09>".
638 */
639 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100640char2cells(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000641{
642 if (IS_SPECIAL(c))
643 return char2cells(K_SECOND(c)) + 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000644 if (c >= 0x80)
645 {
Bram Moolenaarc667da52019-11-30 20:52:27 +0100646 // UTF-8: above 0x80 need to check the value
Bram Moolenaar071d4272004-06-13 20:20:40 +0000647 if (enc_utf8)
648 return utf_char2cells(c);
Bram Moolenaarc667da52019-11-30 20:52:27 +0100649 // DBCS: double-byte means double-width, except for euc-jp with first
650 // byte 0x8e
Bram Moolenaar071d4272004-06-13 20:20:40 +0000651 if (enc_dbcs != 0 && c >= 0x100)
652 {
653 if (enc_dbcs == DBCS_JPNU && ((unsigned)c >> 8) == 0x8e)
654 return 1;
655 return 2;
656 }
657 }
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100658 return (g_chartab[c & 0xff] & CT_CELL_MASK);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000659}
660
661/*
662 * Return number of display cells occupied by character at "*p".
663 * A TAB is counted as two cells: "^I" or four: "<09>".
664 */
665 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100666ptr2cells(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000667{
Bram Moolenaar398649e2022-08-04 15:03:48 +0100668 if (!has_mbyte)
669 return byte2cells(*p);
670
Bram Moolenaarc667da52019-11-30 20:52:27 +0100671 // For UTF-8 we need to look at more bytes if the first byte is >= 0x80.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000672 if (enc_utf8 && *p >= 0x80)
673 return utf_ptr2cells(p);
Bram Moolenaarc667da52019-11-30 20:52:27 +0100674 // For DBCS we can tell the cell count from the first byte.
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100675 return (g_chartab[*p] & CT_CELL_MASK);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000676}
677
678/*
Bram Moolenaar06af6022012-01-26 13:40:08 +0100679 * Return the number of character cells string "s" will take on the screen,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000680 * counting TABs as two characters: "^I".
681 */
682 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100683vim_strsize(char_u *s)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000684{
685 return vim_strnsize(s, (int)MAXCOL);
686}
687
688/*
Bram Moolenaar06af6022012-01-26 13:40:08 +0100689 * Return the number of character cells string "s[len]" will take on the
690 * screen, counting TABs as two characters: "^I".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000691 */
692 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100693vim_strnsize(char_u *s, int len)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000694{
695 int size = 0;
696
697 while (*s != NUL && --len >= 0)
Bram Moolenaar398649e2022-08-04 15:03:48 +0100698 {
699 int l = (*mb_ptr2len)(s);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000700
Bram Moolenaar398649e2022-08-04 15:03:48 +0100701 size += ptr2cells(s);
702 s += l;
703 len -= l - 1;
704 }
Bram Moolenaar13505972019-01-24 15:04:48 +0100705
Bram Moolenaar071d4272004-06-13 20:20:40 +0000706 return size;
707}
708
709/*
710 * Return the number of characters 'c' will take on the screen, taking
711 * into account the size of a tab.
712 * Use a define to make it fast, this is used very often!!!
713 * Also see getvcol() below.
714 */
715
Bram Moolenaar04958cb2018-06-23 19:23:02 +0200716#ifdef FEAT_VARTABS
717# define RET_WIN_BUF_CHARTABSIZE(wp, buf, p, col) \
kylo252ae6f1d82022-02-16 19:24:07 +0000718 if (*(p) == TAB && (!(wp)->w_p_list || (wp)->w_lcs_chars.tab1)) \
Bram Moolenaar04958cb2018-06-23 19:23:02 +0200719 { \
720 return tabstop_padding(col, (buf)->b_p_ts, (buf)->b_p_vts_array); \
721 } \
722 else \
723 return ptr2cells(p);
724#else
725# define RET_WIN_BUF_CHARTABSIZE(wp, buf, p, col) \
Bram Moolenaareed9d462021-02-15 20:38:25 +0100726 if (*(p) == TAB && (!(wp)->w_p_list || wp->w_lcs_chars.tab1)) \
Bram Moolenaar071d4272004-06-13 20:20:40 +0000727 { \
728 int ts; \
729 ts = (buf)->b_p_ts; \
730 return (int)(ts - (col % ts)); \
731 } \
732 else \
733 return ptr2cells(p);
Bram Moolenaar04958cb2018-06-23 19:23:02 +0200734#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000735
Bram Moolenaar071d4272004-06-13 20:20:40 +0000736 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100737chartabsize(char_u *p, colnr_T col)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000738{
739 RET_WIN_BUF_CHARTABSIZE(curwin, curbuf, p, col)
740}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000741
742#ifdef FEAT_LINEBREAK
743 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100744win_chartabsize(win_T *wp, char_u *p, colnr_T col)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000745{
746 RET_WIN_BUF_CHARTABSIZE(wp, wp->w_buffer, p, col)
747}
748#endif
749
750/*
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100751 * Return the number of characters the string "s" will take on the screen,
Bram Moolenaardc536092010-07-18 15:45:49 +0200752 * taking into account the size of a tab.
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100753 * Does not handle text properties, since "s" is not a buffer line.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000754 */
755 int
Bram Moolenaarc9121f72022-10-14 20:09:04 +0100756linetabsize_str(char_u *s)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000757{
Bram Moolenaardc536092010-07-18 15:45:49 +0200758 return linetabsize_col(0, s);
759}
760
761/*
Bram Moolenaarc9121f72022-10-14 20:09:04 +0100762 * Like linetabsize_str(), but "s" starts at column "startcol".
Bram Moolenaardc536092010-07-18 15:45:49 +0200763 */
764 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100765linetabsize_col(int startcol, char_u *s)
Bram Moolenaardc536092010-07-18 15:45:49 +0200766{
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100767 chartabsize_T cts;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000768
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100769 init_chartabsize_arg(&cts, curwin, 0, startcol, s, s);
770 while (*cts.cts_ptr != NUL)
771 cts.cts_vcol += lbr_chartabsize_adv(&cts);
Bram Moolenaar49a90792022-08-09 18:25:23 +0100772#ifdef FEAT_PROP_POPUP
773 if (cts.cts_has_prop_with_text && cts.cts_ptr == cts.cts_line)
774 {
775 // check for virtual text in an empty line
776 (void)lbr_chartabsize_adv(&cts);
777 cts.cts_vcol += cts.cts_cur_text_width;
778 }
779#endif
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100780 clear_chartabsize_arg(&cts);
781 return (int)cts.cts_vcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000782}
783
784/*
Bram Moolenaarc9121f72022-10-14 20:09:04 +0100785 * Like linetabsize_str(), but for a given window instead of the current one.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000786 */
787 int
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100788win_linetabsize(win_T *wp, linenr_T lnum, char_u *line, colnr_T len)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000789{
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100790 chartabsize_T cts;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000791
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100792 init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
Bram Moolenaar49a90792022-08-09 18:25:23 +0100793 win_linetabsize_cts(&cts, len);
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100794 clear_chartabsize_arg(&cts);
795 return (int)cts.cts_vcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000796}
797
Bram Moolenaarc9121f72022-10-14 20:09:04 +0100798/*
799 * Return the number of cells line "lnum" of window "wp" will take on the
800 * screen, taking into account the size of a tab and text properties.
801 */
802 int
803linetabsize(win_T *wp, linenr_T lnum)
804{
805 return win_linetabsize(wp, lnum,
806 ml_get_buf(wp->w_buffer, lnum, FALSE), (colnr_T)MAXCOL);
807}
808
Bram Moolenaar49a90792022-08-09 18:25:23 +0100809 void
810win_linetabsize_cts(chartabsize_T *cts, colnr_T len)
811{
812#ifdef FEAT_PROP_POPUP
813 cts->cts_with_trailing = len == MAXCOL;
814#endif
815 for ( ; *cts->cts_ptr != NUL && (len == MAXCOL || cts->cts_ptr < cts->cts_line + len);
816 MB_PTR_ADV(cts->cts_ptr))
817 cts->cts_vcol += win_lbr_chartabsize(cts, NULL);
818#ifdef FEAT_PROP_POPUP
819 // check for a virtual text on an empty line
820 if (cts->cts_has_prop_with_text && *cts->cts_ptr == NUL
821 && cts->cts_ptr == cts->cts_line)
822 {
823 (void)win_lbr_chartabsize(cts, NULL);
824 cts->cts_vcol += cts->cts_cur_text_width;
Bram Moolenaar55a27d82023-02-12 18:03:57 +0000825
826 // when properties are above or below the empty line must also be
827 // counted
828 if (cts->cts_prop_lines > 0)
829 ++cts->cts_vcol;
Bram Moolenaar49a90792022-08-09 18:25:23 +0100830 }
831#endif
832}
833
Bram Moolenaar071d4272004-06-13 20:20:40 +0000834/*
Bram Moolenaar81695252004-12-29 20:58:21 +0000835 * Return TRUE if 'c' is a normal identifier character:
836 * Letters and characters from the 'isident' option.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000837 */
838 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100839vim_isIDc(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000840{
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100841 return (c > 0 && c < 0x100 && (g_chartab[c] & CT_ID_CHAR));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000842}
843
844/*
Bram Moolenaare3d1f4c2021-04-06 20:21:59 +0200845 * Like vim_isIDc() but not using the 'isident' option: letters, numbers and
846 * underscore.
847 */
848 int
849vim_isNormalIDc(int c)
850{
851 return ASCII_ISALNUM(c) || c == '_';
852}
853
854/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000855 * return TRUE if 'c' is a keyword character: Letters and characters from
Bram Moolenaarcaa55b62017-01-10 13:51:09 +0100856 * 'iskeyword' option for the current buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000857 * For multi-byte characters mb_get_class() is used (builtin rules).
858 */
859 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100860vim_iswordc(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000861{
Bram Moolenaar9d182dd2013-01-23 15:53:15 +0100862 return vim_iswordc_buf(c, curbuf);
863}
864
865 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100866vim_iswordc_buf(int c, buf_T *buf)
Bram Moolenaar9d182dd2013-01-23 15:53:15 +0100867{
Bram Moolenaar071d4272004-06-13 20:20:40 +0000868 if (c >= 0x100)
869 {
870 if (enc_dbcs != 0)
Bram Moolenaar0ab2a882009-05-13 10:51:08 +0000871 return dbcs_class((unsigned)c >> 8, (unsigned)(c & 0xff)) >= 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000872 if (enc_utf8)
Bram Moolenaar4019cf92017-01-28 16:39:34 +0100873 return utf_class_buf(c, buf) >= 2;
Bram Moolenaar4019cf92017-01-28 16:39:34 +0100874 return FALSE;
875 }
876 return (c > 0 && GET_CHARTAB(buf, c) != 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000877}
878
879/*
880 * Just like vim_iswordc() but uses a pointer to the (multi-byte) character.
881 */
882 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100883vim_iswordp(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000884{
Bram Moolenaar4019cf92017-01-28 16:39:34 +0100885 return vim_iswordp_buf(p, curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000886}
887
Bram Moolenaar071d4272004-06-13 20:20:40 +0000888 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100889vim_iswordp_buf(char_u *p, buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000890{
Bram Moolenaar4019cf92017-01-28 16:39:34 +0100891 int c = *p;
892
Bram Moolenaar4019cf92017-01-28 16:39:34 +0100893 if (has_mbyte && MB_BYTE2LEN(c) > 1)
894 c = (*mb_ptr2char)(p);
Bram Moolenaar4019cf92017-01-28 16:39:34 +0100895 return vim_iswordc_buf(c, buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000896}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000897
898/*
Bram Moolenaarbc49c5f2022-08-04 13:01:48 +0100899 * Return TRUE if 'c' is a valid file-name character as specified with the
900 * 'isfname' option.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000901 * Assume characters above 0x100 are valid (multi-byte).
Bram Moolenaarbc49c5f2022-08-04 13:01:48 +0100902 * To be used for commands like "gf".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000903 */
904 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100905vim_isfilec(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000906{
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100907 return (c >= 0x100 || (c > 0 && (g_chartab[c] & CT_FNAME_CHAR)));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000908}
909
Dominique Pellee764d1b2023-03-12 21:20:59 +0000910#if defined(FEAT_SPELL) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000911/*
Bram Moolenaarbc49c5f2022-08-04 13:01:48 +0100912 * Return TRUE if 'c' is a valid file-name character, including characters left
913 * out of 'isfname' to make "gf" work, such as comma, space, '@', etc.
914 */
915 int
916vim_is_fname_char(int c)
917{
918 return vim_isfilec(c) || c == ',' || c == ' ' || c == '@';
919}
Dominique Pellee764d1b2023-03-12 21:20:59 +0000920#endif
Bram Moolenaarbc49c5f2022-08-04 13:01:48 +0100921
922/*
Bram Moolenaardd87969c2007-08-21 13:07:12 +0000923 * return TRUE if 'c' is a valid file-name character or a wildcard character
924 * Assume characters above 0x100 are valid (multi-byte).
925 * Explicitly interpret ']' as a wildcard character as mch_has_wildcard("]")
926 * returns false.
927 */
928 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100929vim_isfilec_or_wc(int c)
Bram Moolenaardd87969c2007-08-21 13:07:12 +0000930{
931 char_u buf[2];
932
933 buf[0] = (char_u)c;
934 buf[1] = NUL;
935 return vim_isfilec(c) || c == ']' || mch_has_wildcard(buf);
936}
937
938/*
Bram Moolenaar3317d5e2017-04-08 19:12:06 +0200939 * Return TRUE if 'c' is a printable character.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000940 * Assume characters above 0x100 are printable (multi-byte), except for
941 * Unicode.
942 */
943 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100944vim_isprintc(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000945{
Bram Moolenaar071d4272004-06-13 20:20:40 +0000946 if (enc_utf8 && c >= 0x100)
947 return utf_printable(c);
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100948 return (c >= 0x100 || (c > 0 && (g_chartab[c] & CT_PRINT_CHAR)));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000949}
950
951/*
952 * Strict version of vim_isprintc(c), don't return TRUE if "c" is the head
953 * byte of a double-byte character.
954 */
955 int
Bram Moolenaar7454a062016-01-30 15:14:10 +0100956vim_isprintc_strict(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000957{
Bram Moolenaar071d4272004-06-13 20:20:40 +0000958 if (enc_dbcs != 0 && c < 0x100 && MB_BYTE2LEN(c) > 1)
959 return FALSE;
960 if (enc_utf8 && c >= 0x100)
961 return utf_printable(c);
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +0100962 return (c >= 0x100 || (c > 0 && (g_chartab[c] & CT_PRINT_CHAR)));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000963}
964
965/*
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100966 * Prepare the structure passed to chartabsize functions.
967 * "line" is the start of the line, "ptr" is the first relevant character.
968 * When "lnum" is zero do not use text properties that insert text.
969 */
970 void
971init_chartabsize_arg(
972 chartabsize_T *cts,
973 win_T *wp,
Bram Moolenaare5a420f2022-09-07 21:46:56 +0100974 linenr_T lnum UNUSED,
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100975 colnr_T col,
976 char_u *line,
977 char_u *ptr)
978{
Bram Moolenaar3f79b612022-08-01 12:06:40 +0100979 CLEAR_POINTER(cts);
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100980 cts->cts_win = wp;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100981 cts->cts_vcol = col;
982 cts->cts_line = line;
983 cts->cts_ptr = ptr;
984#ifdef FEAT_PROP_POPUP
Bram Moolenaar702bd6c2022-09-14 16:09:57 +0100985 if (lnum > 0 && !ignore_text_props)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100986 {
Bram Moolenaarf396ce82022-08-23 18:39:37 +0100987 char_u *prop_start;
988 int count;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100989
Bram Moolenaarf396ce82022-08-23 18:39:37 +0100990 count = get_text_props(wp->w_buffer, lnum, &prop_start, FALSE);
991 cts->cts_text_prop_count = count;
992 if (count > 0)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100993 {
994 // Make a copy of the properties, so that they are properly
Bram Moolenaarf396ce82022-08-23 18:39:37 +0100995 // aligned. Make it twice as long for the sorting below.
996 cts->cts_text_props = ALLOC_MULT(textprop_T, count * 2);
Bram Moolenaar7f9969c2022-07-25 18:13:54 +0100997 if (cts->cts_text_props == NULL)
998 cts->cts_text_prop_count = 0;
999 else
1000 {
Bram Moolenaarf396ce82022-08-23 18:39:37 +01001001 int i;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001002
Bram Moolenaarf396ce82022-08-23 18:39:37 +01001003 mch_memmove(cts->cts_text_props + count, prop_start,
1004 count * sizeof(textprop_T));
1005 for (i = 0; i < count; ++i)
Bram Moolenaar89469d12022-12-02 20:46:26 +00001006 {
1007 textprop_T *tp = cts->cts_text_props + i + count;
1008 if (tp->tp_id < 0
1009 && text_prop_type_valid(wp->w_buffer, tp))
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001010 {
1011 cts->cts_has_prop_with_text = TRUE;
1012 break;
1013 }
Bram Moolenaar89469d12022-12-02 20:46:26 +00001014 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001015 if (!cts->cts_has_prop_with_text)
1016 {
1017 // won't use the text properties, free them
Bram Moolenaar3f79b612022-08-01 12:06:40 +01001018 VIM_CLEAR(cts->cts_text_props);
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001019 cts->cts_text_prop_count = 0;
1020 }
Bram Moolenaarf396ce82022-08-23 18:39:37 +01001021 else
1022 {
1023 int *text_prop_idxs;
1024
1025 // Need to sort the array to get any truncation right.
1026 // Do the sorting in the second part of the array, then
1027 // move the sorted props to the first part of the array.
1028 text_prop_idxs = ALLOC_MULT(int, count);
1029 if (text_prop_idxs != NULL)
1030 {
1031 for (i = 0; i < count; ++i)
1032 text_prop_idxs[i] = i + count;
1033 sort_text_props(curbuf, cts->cts_text_props,
1034 text_prop_idxs, count);
1035 // Here we want the reverse order.
1036 for (i = 0; i < count; ++i)
1037 cts->cts_text_props[count - i - 1] =
1038 cts->cts_text_props[text_prop_idxs[i]];
1039 vim_free(text_prop_idxs);
1040 }
1041 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001042 }
1043 }
1044 }
1045#endif
1046}
1047
1048/*
1049 * Free any allocated item in "cts".
1050 */
1051 void
Bram Moolenaarfe3fb6e2022-07-25 18:35:15 +01001052clear_chartabsize_arg(chartabsize_T *cts UNUSED)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001053{
Bram Moolenaarfe3fb6e2022-07-25 18:35:15 +01001054#ifdef FEAT_PROP_POPUP
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001055 if (cts->cts_text_prop_count > 0)
Bram Moolenaar34a1f772022-07-26 11:20:48 +01001056 {
Bram Moolenaar3f79b612022-08-01 12:06:40 +01001057 VIM_CLEAR(cts->cts_text_props);
1058 cts->cts_text_prop_count = 0;
Bram Moolenaar34a1f772022-07-26 11:20:48 +01001059 }
Bram Moolenaarfe3fb6e2022-07-25 18:35:15 +01001060#endif
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001061}
1062
1063/*
1064 * Like chartabsize(), but also check for line breaks on the screen and text
1065 * properties that insert text.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001066 */
1067 int
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001068lbr_chartabsize(chartabsize_T *cts)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001069{
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001070#if defined(FEAT_LINEBREAK) || defined(FEAT_PROP_POPUP)
1071 if (1
1072# ifdef FEAT_LINEBREAK
1073 && !curwin->w_p_lbr && *get_showbreak_value(curwin) == NUL
1074 && !curwin->w_p_bri
1075# endif
1076# ifdef FEAT_PROP_POPUP
1077 && !cts->cts_has_prop_with_text
1078#endif
1079 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00001080 {
1081#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001082 if (curwin->w_p_wrap)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001083 return win_nolbr_chartabsize(cts, NULL);
1084 RET_WIN_BUF_CHARTABSIZE(curwin, curbuf, cts->cts_ptr, cts->cts_vcol)
1085#if defined(FEAT_LINEBREAK) || defined(FEAT_PROP_POPUP)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001086 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001087 return win_lbr_chartabsize(cts, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001088#endif
1089}
1090
1091/*
1092 * Call lbr_chartabsize() and advance the pointer.
1093 */
1094 int
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001095lbr_chartabsize_adv(chartabsize_T *cts)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001096{
1097 int retval;
1098
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001099 retval = lbr_chartabsize(cts);
1100 MB_PTR_ADV(cts->cts_ptr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001101 return retval;
1102}
1103
1104/*
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001105 * Return the screen size of the character indicated by "cts".
1106 * "cts->cts_cur_text_width" is set to the extra size for a text property that
1107 * inserts text.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001108 * This function is used very often, keep it fast!!!!
1109 *
1110 * If "headp" not NULL, set *headp to the size of what we for 'showbreak'
1111 * string at start of line. Warning: *headp is only set if it's a non-zero
1112 * value, init to 0 before calling.
1113 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001114 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001115win_lbr_chartabsize(
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001116 chartabsize_T *cts,
1117 int *headp UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001118{
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001119 win_T *wp = cts->cts_win;
Martin Tournoijba43e762022-10-13 22:12:15 +01001120#if defined(FEAT_PROP_POPUP) || defined(FEAT_LINEBREAK)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001121 char_u *line = cts->cts_line; // start of the line
Bram Moolenaarfe3fb6e2022-07-25 18:35:15 +01001122#endif
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001123 char_u *s = cts->cts_ptr;
1124 colnr_T vcol = cts->cts_vcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001125#ifdef FEAT_LINEBREAK
1126 int c;
1127 int size;
1128 colnr_T col2;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001129 colnr_T col_adj = 0; // vcol + screen size of tab
Bram Moolenaar071d4272004-06-13 20:20:40 +00001130 colnr_T colmax;
1131 int added;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001132 int mb_added = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001133 int numberextra;
1134 char_u *ps;
1135 int tab_corr = (*s == TAB);
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001136 int n;
Bram Moolenaaree857022019-11-09 23:26:40 +01001137 char_u *sbr;
Bram Moolenaarcba69522022-08-06 21:03:53 +01001138 int no_sbr = FALSE;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001139#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001140
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001141#if defined(FEAT_PROP_POPUP)
1142 cts->cts_cur_text_width = 0;
Bram Moolenaar04e0ed12022-09-10 20:00:56 +01001143 cts->cts_first_char = 0;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001144#endif
1145
1146#if defined(FEAT_LINEBREAK) || defined(FEAT_PROP_POPUP)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001147 /*
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001148 * No 'linebreak', 'showbreak', 'breakindent' and text properties that
1149 * insert text: return quickly.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001150 */
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001151 if (1
1152# ifdef FEAT_LINEBREAK
1153 && !wp->w_p_lbr && !wp->w_p_bri && *get_showbreak_value(wp) == NUL
1154# endif
1155# ifdef FEAT_PROP_POPUP
1156 && !cts->cts_has_prop_with_text
1157# endif
1158 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00001159#endif
1160 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001161 if (wp->w_p_wrap)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001162 return win_nolbr_chartabsize(cts, headp);
1163 RET_WIN_BUF_CHARTABSIZE(wp, wp->w_buffer, s, vcol)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001164 }
1165
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001166#if defined(FEAT_LINEBREAK) || defined(FEAT_PROP_POPUP)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001167 /*
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001168 * First get the normal size, without 'linebreak' or text properties
Bram Moolenaar071d4272004-06-13 20:20:40 +00001169 */
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001170 size = win_chartabsize(wp, s, vcol);
Bram Moolenaar9d9a20e2023-02-11 13:49:01 +00001171 if (*s == NUL)
1172 size = 0; // NUL is not displayed
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001173
1174# ifdef FEAT_PROP_POPUP
Bram Moolenaar49a90792022-08-09 18:25:23 +01001175 if (cts->cts_has_prop_with_text)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001176 {
Bram Moolenaare428fa02022-08-09 16:55:41 +01001177 int tab_size = size;
Bram Moolenaar49a90792022-08-09 18:25:23 +01001178 int charlen = *s == NUL ? 1 : mb_ptr2len(s);
Bram Moolenaar2f83cc42022-08-05 11:45:17 +01001179 int i;
1180 int col = (int)(s - line);
1181 garray_T *gap = &wp->w_buffer->b_textprop_text;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001182
Bram Moolenaarf396ce82022-08-23 18:39:37 +01001183 // The "$" for 'list' mode will go between the EOL and
1184 // the text prop, account for that.
1185 if (wp->w_p_list && wp->w_lcs_chars.eol != NUL)
1186 ++vcol;
1187
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001188 for (i = 0; i < cts->cts_text_prop_count; ++i)
1189 {
Bram Moolenaarc8bf59e2022-08-28 16:39:22 +01001190 textprop_T *tp = cts->cts_text_props + i;
1191 int col_off = win_col_off(wp);
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001192
Bram Moolenaar2f83cc42022-08-05 11:45:17 +01001193 // Watch out for the text being deleted. "cts_text_props" is a
1194 // copy, the text prop may actually have been removed from the line.
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001195 if (tp->tp_id < 0
Bram Moolenaar25463612022-08-08 11:07:47 +01001196 && ((tp->tp_col - 1 >= col
Bram Moolenaare428fa02022-08-09 16:55:41 +01001197 && tp->tp_col - 1 < col + charlen)
Bram Moolenaar04e0ed12022-09-10 20:00:56 +01001198 || (tp->tp_col == MAXCOL
1199 && ((tp->tp_flags & TP_FLAG_ALIGN_ABOVE)
1200 ? col == 0
Bram Moolenaarea62cee2023-02-19 18:36:41 +00001201 : (s[0] == NUL || s[charlen] == NUL)
Bram Moolenaar04e0ed12022-09-10 20:00:56 +01001202 && cts->cts_with_trailing)))
Bram Moolenaar4ce1f992022-12-19 13:31:06 +00001203 && -tp->tp_id - 1 < gap->ga_len)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001204 {
Bram Moolenaar2f83cc42022-08-05 11:45:17 +01001205 char_u *p = ((char_u **)gap->ga_data)[-tp->tp_id - 1];
Bram Moolenaarb7963df2022-07-31 17:12:43 +01001206
Bram Moolenaar2f83cc42022-08-05 11:45:17 +01001207 if (p != NULL)
Bram Moolenaarb7963df2022-07-31 17:12:43 +01001208 {
Bram Moolenaarf396ce82022-08-23 18:39:37 +01001209 int cells;
Bram Moolenaar398649e2022-08-04 15:03:48 +01001210
Bram Moolenaar2f83cc42022-08-05 11:45:17 +01001211 if (tp->tp_col == MAXCOL)
1212 {
Bram Moolenaarf396ce82022-08-23 18:39:37 +01001213 int n_extra = (int)STRLEN(p);
Bram Moolenaar2f83cc42022-08-05 11:45:17 +01001214
Bram Moolenaarf167c7b2022-10-09 21:53:58 +01001215 cells = text_prop_position(wp, tp, vcol,
Bram Moolenaarc8bf59e2022-08-28 16:39:22 +01001216 (vcol + size) % (wp->w_width - col_off) + col_off,
Bram Moolenaar56a40fe2022-12-06 14:17:57 +00001217 &n_extra, &p, NULL, NULL, FALSE);
Bram Moolenaarcba69522022-08-06 21:03:53 +01001218#ifdef FEAT_LINEBREAK
1219 no_sbr = TRUE; // don't use 'showbreak' now
1220#endif
Bram Moolenaar2f83cc42022-08-05 11:45:17 +01001221 }
Bram Moolenaarf396ce82022-08-23 18:39:37 +01001222 else
1223 cells = vim_strsize(p);
Bram Moolenaar2f83cc42022-08-05 11:45:17 +01001224 cts->cts_cur_text_width += cells;
Bram Moolenaar04e0ed12022-09-10 20:00:56 +01001225 if (tp->tp_flags & TP_FLAG_ALIGN_ABOVE)
1226 cts->cts_first_char += cells;
Bram Moolenaar28c9f892022-08-14 13:28:55 +01001227 cts->cts_start_incl = tp->tp_flags & TP_FLAG_START_INCL;
Bram Moolenaar2f83cc42022-08-05 11:45:17 +01001228 size += cells;
Bram Moolenaare428fa02022-08-09 16:55:41 +01001229 if (*s == TAB)
1230 {
1231 // tab size changes because of the inserted text
1232 size -= tab_size;
1233 tab_size = win_chartabsize(wp, s, vcol + size);
1234 size += tab_size;
1235 }
Bram Moolenaar55a27d82023-02-12 18:03:57 +00001236 if (tp->tp_col == MAXCOL && (tp->tp_flags
1237 & (TP_FLAG_ALIGN_ABOVE | TP_FLAG_ALIGN_BELOW)))
1238 // count extra line for property above/below
1239 ++cts->cts_prop_lines;
Bram Moolenaarb7963df2022-07-31 17:12:43 +01001240 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001241 }
Bram Moolenaar50e75fe2022-08-05 20:25:50 +01001242 if (tp->tp_col != MAXCOL && tp->tp_col - 1 > col)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001243 break;
1244 }
Bram Moolenaarf396ce82022-08-23 18:39:37 +01001245 if (wp->w_p_list && wp->w_lcs_chars.eol != NUL)
1246 --vcol;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001247 }
1248# endif
1249
1250# ifdef FEAT_LINEBREAK
Bram Moolenaar071d4272004-06-13 20:20:40 +00001251 c = *s;
Bram Moolenaaree739b42014-07-02 19:37:42 +02001252 if (tab_corr)
1253 col_adj = size - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001254
1255 /*
1256 * If 'linebreak' set check at a blank before a non-blank if the line
1257 * needs a break here
1258 */
1259 if (wp->w_p_lbr
Bram Moolenaar91acfff2017-03-12 19:22:36 +01001260 && VIM_ISBREAK(c)
Bram Moolenaar977d0372017-03-12 21:31:58 +01001261 && !VIM_ISBREAK((int)s[1])
Bram Moolenaar071d4272004-06-13 20:20:40 +00001262 && wp->w_p_wrap
Bram Moolenaar4033c552017-09-16 20:54:51 +02001263 && wp->w_width != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001264 {
1265 /*
1266 * Count all characters from first non-blank after a blank up to next
1267 * non-blank after a blank.
1268 */
1269 numberextra = win_col_off(wp);
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001270 col2 = vcol;
Bram Moolenaar02631462017-09-22 15:20:32 +02001271 colmax = (colnr_T)(wp->w_width - numberextra - col_adj);
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001272 if (vcol >= colmax)
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001273 {
Bram Moolenaaree739b42014-07-02 19:37:42 +02001274 colmax += col_adj;
1275 n = colmax + win_col_off2(wp);
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001276 if (n > 0)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001277 colmax += (((vcol - colmax) / n) + 1) * n - col_adj;
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00001278 }
1279
Bram Moolenaar071d4272004-06-13 20:20:40 +00001280 for (;;)
1281 {
1282 ps = s;
Bram Moolenaar91acfff2017-03-12 19:22:36 +01001283 MB_PTR_ADV(s);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001284 c = *s;
1285 if (!(c != NUL
Bram Moolenaar91acfff2017-03-12 19:22:36 +01001286 && (VIM_ISBREAK(c)
1287 || (!VIM_ISBREAK(c)
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001288 && (col2 == vcol || !VIM_ISBREAK((int)*ps))))))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001289 break;
1290
1291 col2 += win_chartabsize(wp, s, col2);
Bram Moolenaarc667da52019-11-30 20:52:27 +01001292 if (col2 >= colmax) // doesn't fit
Bram Moolenaar071d4272004-06-13 20:20:40 +00001293 {
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001294 size = colmax - vcol + col_adj;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001295 break;
1296 }
1297 }
1298 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001299 else if (has_mbyte && size == 2 && MB_BYTE2LEN(*s) > 1
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001300 && wp->w_p_wrap && in_win_border(wp, vcol))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001301 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001302 ++size; // Count the ">" in the last column.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001303 mb_added = 1;
1304 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001305
1306 /*
Bram Moolenaar597a4222014-06-25 14:39:50 +02001307 * May have to add something for 'breakindent' and/or 'showbreak'
1308 * string at start of line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001309 * Set *headp to the size of what we add.
Bram Moolenaar21efafe2022-03-03 20:04:03 +00001310 * Do not use 'showbreak' at the NUL after the text.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001311 */
1312 added = 0;
Bram Moolenaarcba69522022-08-06 21:03:53 +01001313 sbr = (c == NUL || no_sbr) ? empty_option : get_showbreak_value(wp);
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001314 if ((*sbr != NUL || wp->w_p_bri) && wp->w_p_wrap && vcol != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001315 {
Bram Moolenaard574ea22015-01-14 19:35:14 +01001316 colnr_T sbrlen = 0;
1317 int numberwidth = win_col_off(wp);
1318
1319 numberextra = numberwidth;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001320 vcol += numberextra + mb_added;
Bram Moolenaar4c7fd4d2022-09-17 17:15:33 +01001321#ifdef FEAT_PROP_POPUP
1322 vcol -= wp->w_virtcol_first_char;
1323#endif
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001324 if (vcol >= (colnr_T)wp->w_width)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001325 {
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001326 vcol -= wp->w_width;
Bram Moolenaar02631462017-09-22 15:20:32 +02001327 numberextra = wp->w_width - (numberextra - win_col_off2(wp));
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001328 if (vcol >= numberextra && numberextra > 0)
1329 vcol %= numberextra;
Bram Moolenaaree857022019-11-09 23:26:40 +01001330 if (*sbr != NUL)
Bram Moolenaar1c852102014-10-15 21:26:40 +02001331 {
Bram Moolenaaree857022019-11-09 23:26:40 +01001332 sbrlen = (colnr_T)MB_CHARLEN(sbr);
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001333 if (vcol >= sbrlen)
1334 vcol -= sbrlen;
Bram Moolenaar1c852102014-10-15 21:26:40 +02001335 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001336 if (vcol >= numberextra && numberextra > 0)
1337 vcol = vcol % numberextra;
1338 else if (vcol > 0 && numberextra > 0)
1339 vcol += numberwidth - win_col_off2(wp);
Bram Moolenaard574ea22015-01-14 19:35:14 +01001340
1341 numberwidth -= win_col_off2(wp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001342 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001343 if (vcol == 0 || vcol + size + sbrlen > (colnr_T)wp->w_width)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001344 {
Bram Moolenaar597a4222014-06-25 14:39:50 +02001345 added = 0;
Bram Moolenaaree857022019-11-09 23:26:40 +01001346 if (*sbr != NUL)
Bram Moolenaard574ea22015-01-14 19:35:14 +01001347 {
Bram Moolenaar02631462017-09-22 15:20:32 +02001348 if (size + sbrlen + numberwidth > (colnr_T)wp->w_width)
Bram Moolenaard574ea22015-01-14 19:35:14 +01001349 {
Bram Moolenaar7833dab2019-05-27 22:01:40 +02001350 // calculate effective window width
Bram Moolenaar02631462017-09-22 15:20:32 +02001351 int width = (colnr_T)wp->w_width - sbrlen - numberwidth;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001352 int prev_width = vcol
1353 ? ((colnr_T)wp->w_width - (sbrlen + vcol)) : 0;
Bram Moolenaar7833dab2019-05-27 22:01:40 +02001354
1355 if (width <= 0)
1356 width = (colnr_T)1;
Bram Moolenaaree857022019-11-09 23:26:40 +01001357 added += ((size - prev_width) / width) * vim_strsize(sbr);
Bram Moolenaard574ea22015-01-14 19:35:14 +01001358 if ((size - prev_width) % width)
Bram Moolenaar7833dab2019-05-27 22:01:40 +02001359 // wrapped, add another length of 'sbr'
Bram Moolenaaree857022019-11-09 23:26:40 +01001360 added += vim_strsize(sbr);
Bram Moolenaard574ea22015-01-14 19:35:14 +01001361 }
1362 else
Bram Moolenaaree857022019-11-09 23:26:40 +01001363 added += vim_strsize(sbr);
Bram Moolenaard574ea22015-01-14 19:35:14 +01001364 }
Bram Moolenaar597a4222014-06-25 14:39:50 +02001365 if (wp->w_p_bri)
1366 added += get_breakindent_win(wp, line);
1367
Bram Moolenaar95765082014-08-24 21:19:25 +02001368 size += added;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001369 if (vcol != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001370 added = 0;
1371 }
1372 }
1373 if (headp != NULL)
1374 *headp = added + mb_added;
1375 return size;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001376# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001377#endif
1378}
1379
Bram Moolenaar071d4272004-06-13 20:20:40 +00001380/*
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001381 * Like win_lbr_chartabsize(), except that we know 'linebreak' is off, 'wrap'
1382 * is on and there are no properties that insert text. This means we need to
1383 * check for a double-byte character that doesn't fit at the end of the screen
1384 * line.
1385 * Only uses "cts_win", "cts_ptr" and "cts_vcol" from "cts".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001386 */
1387 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001388win_nolbr_chartabsize(
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001389 chartabsize_T *cts,
1390 int *headp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001391{
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001392 win_T *wp = cts->cts_win;
1393 char_u *s = cts->cts_ptr;
1394 colnr_T col = cts->cts_vcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001395 int n;
1396
Bram Moolenaareed9d462021-02-15 20:38:25 +01001397 if (*s == TAB && (!wp->w_p_list || wp->w_lcs_chars.tab1))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001398 {
Bram Moolenaar04958cb2018-06-23 19:23:02 +02001399# ifdef FEAT_VARTABS
1400 return tabstop_padding(col, wp->w_buffer->b_p_ts,
1401 wp->w_buffer->b_p_vts_array);
1402# else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001403 n = wp->w_buffer->b_p_ts;
1404 return (int)(n - (col % n));
Bram Moolenaar04958cb2018-06-23 19:23:02 +02001405# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001406 }
1407 n = ptr2cells(s);
Bram Moolenaarc667da52019-11-30 20:52:27 +01001408 // Add one cell for a double-width character in the last column of the
1409 // window, displayed with a ">".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001410 if (n == 2 && MB_BYTE2LEN(*s) > 1 && in_win_border(wp, col))
1411 {
1412 if (headp != NULL)
1413 *headp = 1;
1414 return 3;
1415 }
1416 return n;
1417}
1418
1419/*
1420 * Return TRUE if virtual column "vcol" is in the rightmost column of window
1421 * "wp".
1422 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +02001423 static int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001424in_win_border(win_T *wp, colnr_T vcol)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001425{
Bram Moolenaarc667da52019-11-30 20:52:27 +01001426 int width1; // width of first line (after line number)
1427 int width2; // width of further lines
Bram Moolenaar071d4272004-06-13 20:20:40 +00001428
Bram Moolenaarc667da52019-11-30 20:52:27 +01001429 if (wp->w_width == 0) // there is no border
Bram Moolenaar071d4272004-06-13 20:20:40 +00001430 return FALSE;
Bram Moolenaar02631462017-09-22 15:20:32 +02001431 width1 = wp->w_width - win_col_off(wp);
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001432 if ((int)vcol < width1 - 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001433 return FALSE;
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001434 if ((int)vcol == width1 - 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001435 return TRUE;
1436 width2 = width1 + win_col_off2(wp);
Bram Moolenaar8701cd62009-10-07 14:20:30 +00001437 if (width2 <= 0)
1438 return FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001439 return ((vcol - width1) % width2 == width2 - 1);
1440}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001441
1442/*
1443 * Get virtual column number of pos.
1444 * start: on the first position of this character (TAB, ctrl)
1445 * cursor: where the cursor is on this character (first char, except for TAB)
1446 * end: on the last position of this character (TAB, ctrl)
1447 *
1448 * This is used very often, keep it fast!
1449 */
1450 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001451getvcol(
1452 win_T *wp,
1453 pos_T *pos,
1454 colnr_T *start,
1455 colnr_T *cursor,
1456 colnr_T *end)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001457{
1458 colnr_T vcol;
Bram Moolenaarc667da52019-11-30 20:52:27 +01001459 char_u *ptr; // points to current char
1460 char_u *posptr; // points to char at pos->col
1461 char_u *line; // start of the line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001462 int incr;
1463 int head;
Bram Moolenaar04958cb2018-06-23 19:23:02 +02001464#ifdef FEAT_VARTABS
1465 int *vts = wp->w_buffer->b_p_vts_array;
1466#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001467 int ts = wp->w_buffer->b_p_ts;
1468 int c;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001469 chartabsize_T cts;
Bram Moolenaar49a90792022-08-09 18:25:23 +01001470#ifdef FEAT_PROP_POPUP
1471 int on_NUL = FALSE;
1472#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001473
1474 vcol = 0;
Bram Moolenaar597a4222014-06-25 14:39:50 +02001475 line = ptr = ml_get_buf(wp->w_buffer, pos->lnum, FALSE);
Bram Moolenaar37d619f2010-03-10 14:46:26 +01001476 if (pos->col == MAXCOL)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001477 posptr = NULL; // continue until the NUL
Bram Moolenaar37d619f2010-03-10 14:46:26 +01001478 else
Bram Moolenaar0c0590d2017-01-28 13:48:10 +01001479 {
Bram Moolenaar94f31922021-12-30 15:29:18 +00001480 colnr_T i;
1481
1482 // In a few cases the position can be beyond the end of the line.
1483 for (i = 0; i < pos->col; ++i)
1484 if (ptr[i] == NUL)
1485 {
1486 pos->col = i;
1487 break;
1488 }
Bram Moolenaar37d619f2010-03-10 14:46:26 +01001489 posptr = ptr + pos->col;
Bram Moolenaar0c0590d2017-01-28 13:48:10 +01001490 if (has_mbyte)
Bram Moolenaarc667da52019-11-30 20:52:27 +01001491 // always start on the first byte
Bram Moolenaar0c0590d2017-01-28 13:48:10 +01001492 posptr -= (*mb_head_off)(line, posptr);
Bram Moolenaar0c0590d2017-01-28 13:48:10 +01001493 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001494
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001495 init_chartabsize_arg(&cts, wp, pos->lnum, 0, line, line);
1496
Bram Moolenaar071d4272004-06-13 20:20:40 +00001497 /*
1498 * This function is used very often, do some speed optimizations.
Bram Moolenaar597a4222014-06-25 14:39:50 +02001499 * When 'list', 'linebreak', 'showbreak' and 'breakindent' are not set
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001500 * and there are no text properties with "text" use a simple loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001501 * Also use this when 'list' is set but tabs take their normal size.
1502 */
Bram Moolenaareed9d462021-02-15 20:38:25 +01001503 if ((!wp->w_p_list || wp->w_lcs_chars.tab1 != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001504#ifdef FEAT_LINEBREAK
Bram Moolenaaree857022019-11-09 23:26:40 +01001505 && !wp->w_p_lbr && *get_showbreak_value(wp) == NUL && !wp->w_p_bri
Bram Moolenaar071d4272004-06-13 20:20:40 +00001506#endif
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001507#ifdef FEAT_PROP_POPUP
1508 && !cts.cts_has_prop_with_text
1509#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001510 )
1511 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001512 for (;;)
1513 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001514 head = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001515 c = *ptr;
Bram Moolenaarc667da52019-11-30 20:52:27 +01001516 // make sure we don't go past the end of the line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001517 if (c == NUL)
1518 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001519 incr = 1; // NUL at end of line only takes one column
Bram Moolenaar071d4272004-06-13 20:20:40 +00001520 break;
1521 }
Bram Moolenaarc667da52019-11-30 20:52:27 +01001522 // A tab gets expanded, depending on the current column
Bram Moolenaar071d4272004-06-13 20:20:40 +00001523 if (c == TAB)
Bram Moolenaar04958cb2018-06-23 19:23:02 +02001524#ifdef FEAT_VARTABS
1525 incr = tabstop_padding(vcol, ts, vts);
1526#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001527 incr = ts - (vcol % ts);
Bram Moolenaar04958cb2018-06-23 19:23:02 +02001528#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001529 else
1530 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001531 if (has_mbyte)
1532 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001533 // For utf-8, if the byte is >= 0x80, need to look at
1534 // further bytes to find the cell width.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001535 if (enc_utf8 && c >= 0x80)
1536 incr = utf_ptr2cells(ptr);
1537 else
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +01001538 incr = g_chartab[c] & CT_CELL_MASK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001539
Bram Moolenaarc667da52019-11-30 20:52:27 +01001540 // If a double-cell char doesn't fit at the end of a line
1541 // it wraps to the next line, it's like this char is three
1542 // cells wide.
Bram Moolenaar9c33a7c2008-02-20 13:59:32 +00001543 if (incr == 2 && wp->w_p_wrap && MB_BYTE2LEN(*ptr) > 1
1544 && in_win_border(wp, vcol))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001545 {
1546 ++incr;
1547 head = 1;
1548 }
1549 }
1550 else
Bram Moolenaar88e8f9f2016-01-20 22:48:02 +01001551 incr = g_chartab[c] & CT_CELL_MASK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001552 }
1553
Bram Moolenaarc667da52019-11-30 20:52:27 +01001554 if (posptr != NULL && ptr >= posptr) // character at pos->col
Bram Moolenaar071d4272004-06-13 20:20:40 +00001555 break;
1556
1557 vcol += incr;
Bram Moolenaar91acfff2017-03-12 19:22:36 +01001558 MB_PTR_ADV(ptr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001559 }
1560 }
1561 else
1562 {
1563 for (;;)
1564 {
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001565 // A tab gets expanded, depending on the current column.
1566 // Other things also take up space.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001567 head = 0;
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001568 incr = win_lbr_chartabsize(&cts, &head);
Bram Moolenaarc667da52019-11-30 20:52:27 +01001569 // make sure we don't go past the end of the line
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001570 if (*cts.cts_ptr == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001571 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001572 incr = 1; // NUL at end of line only takes one column
Bram Moolenaar49a90792022-08-09 18:25:23 +01001573#ifdef FEAT_PROP_POPUP
1574 if (cts.cts_cur_text_width > 0)
1575 incr = cts.cts_cur_text_width;
1576 on_NUL = TRUE;
1577#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001578 break;
1579 }
Bram Moolenaar04e0ed12022-09-10 20:00:56 +01001580#ifdef FEAT_PROP_POPUP
1581 if (cursor == &wp->w_virtcol && cts.cts_ptr == cts.cts_line)
1582 // do not count the virtual text above for w_curswant
1583 wp->w_virtcol_first_char = cts.cts_first_char;
1584#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001585
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001586 if (posptr != NULL && cts.cts_ptr >= posptr)
1587 // character at pos->col
Bram Moolenaar071d4272004-06-13 20:20:40 +00001588 break;
1589
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001590 cts.cts_vcol += incr;
1591 MB_PTR_ADV(cts.cts_ptr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001592 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001593 vcol = cts.cts_vcol;
1594 ptr = cts.cts_ptr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001595 }
Bram Moolenaar7f9969c2022-07-25 18:13:54 +01001596 clear_chartabsize_arg(&cts);
1597
Bram Moolenaar071d4272004-06-13 20:20:40 +00001598 if (start != NULL)
1599 *start = vcol + head;
1600 if (end != NULL)
1601 *end = vcol + incr - 1;
1602 if (cursor != NULL)
1603 {
1604 if (*ptr == TAB
Bram Moolenaar24959102022-05-07 20:01:16 +01001605 && (State & MODE_NORMAL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001606 && !wp->w_p_list
1607 && !virtual_active()
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01001608 && !(VIsual_active
1609 && (*p_sel == 'e' || LTOREQ_POS(*pos, VIsual)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001610 )
Bram Moolenaarc667da52019-11-30 20:52:27 +01001611 *cursor = vcol + incr - 1; // cursor at end
Bram Moolenaar071d4272004-06-13 20:20:40 +00001612 else
Bram Moolenaare428fa02022-08-09 16:55:41 +01001613 {
1614#ifdef FEAT_PROP_POPUP
Bram Moolenaar28c9f892022-08-14 13:28:55 +01001615 // in Insert mode, if "start_incl" is true the text gets inserted
1616 // after the virtual text, thus add its width
1617 if (((State & MODE_INSERT) == 0 || cts.cts_start_incl) && !on_NUL)
Bram Moolenaar49a90792022-08-09 18:25:23 +01001618 // cursor is after inserted text, unless on the NUL
Bram Moolenaare428fa02022-08-09 16:55:41 +01001619 vcol += cts.cts_cur_text_width;
Bram Moolenaar88b79cb2022-09-10 22:32:14 +01001620 else
1621 // insertion also happens after the "above" virtual text
1622 vcol += cts.cts_first_char;
Bram Moolenaare428fa02022-08-09 16:55:41 +01001623#endif
Bram Moolenaarc667da52019-11-30 20:52:27 +01001624 *cursor = vcol + head; // cursor at start
Bram Moolenaare428fa02022-08-09 16:55:41 +01001625 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001626 }
1627}
1628
1629/*
1630 * Get virtual cursor column in the current window, pretending 'list' is off.
1631 */
1632 colnr_T
Bram Moolenaar7454a062016-01-30 15:14:10 +01001633getvcol_nolist(pos_T *posp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001634{
1635 int list_save = curwin->w_p_list;
1636 colnr_T vcol;
1637
1638 curwin->w_p_list = FALSE;
Bram Moolenaardb0eede2018-04-25 22:38:17 +02001639 if (posp->coladd)
1640 getvvcol(curwin, posp, NULL, &vcol, NULL);
1641 else
Bram Moolenaardb0eede2018-04-25 22:38:17 +02001642 getvcol(curwin, posp, NULL, &vcol, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001643 curwin->w_p_list = list_save;
1644 return vcol;
1645}
1646
Bram Moolenaar071d4272004-06-13 20:20:40 +00001647/*
1648 * Get virtual column in virtual mode.
1649 */
1650 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001651getvvcol(
1652 win_T *wp,
1653 pos_T *pos,
1654 colnr_T *start,
1655 colnr_T *cursor,
1656 colnr_T *end)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001657{
1658 colnr_T col;
1659 colnr_T coladd;
1660 colnr_T endadd;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001661 char_u *ptr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001662
1663 if (virtual_active())
1664 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01001665 // For virtual mode, only want one value
Bram Moolenaar071d4272004-06-13 20:20:40 +00001666 getvcol(wp, pos, &col, NULL, NULL);
1667
1668 coladd = pos->coladd;
1669 endadd = 0;
Bram Moolenaarc667da52019-11-30 20:52:27 +01001670 // Cannot put the cursor on part of a wide character.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001671 ptr = ml_get_buf(wp->w_buffer, pos->lnum, FALSE);
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001672 if (pos->col < (colnr_T)STRLEN(ptr))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001673 {
1674 int c = (*mb_ptr2char)(ptr + pos->col);
1675
1676 if (c != TAB && vim_isprintc(c))
1677 {
Bram Moolenaar0ab2a882009-05-13 10:51:08 +00001678 endadd = (colnr_T)(char2cells(c) - 1);
Bram Moolenaarc667da52019-11-30 20:52:27 +01001679 if (coladd > endadd) // past end of line
Bram Moolenaara5792f52005-11-23 21:25:05 +00001680 endadd = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001681 else
1682 coladd = 0;
1683 }
1684 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001685 col += coladd;
1686 if (start != NULL)
1687 *start = col;
1688 if (cursor != NULL)
1689 *cursor = col;
1690 if (end != NULL)
1691 *end = col + endadd;
1692 }
1693 else
1694 getvcol(wp, pos, start, cursor, end);
1695}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001696
Bram Moolenaar071d4272004-06-13 20:20:40 +00001697/*
1698 * Get the leftmost and rightmost virtual column of pos1 and pos2.
1699 * Used for Visual block mode.
1700 */
1701 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01001702getvcols(
1703 win_T *wp,
1704 pos_T *pos1,
1705 pos_T *pos2,
1706 colnr_T *left,
1707 colnr_T *right)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001708{
1709 colnr_T from1, from2, to1, to2;
1710
Bram Moolenaarb5aedf32017-03-12 18:23:53 +01001711 if (LT_POSP(pos1, pos2))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001712 {
1713 getvvcol(wp, pos1, &from1, NULL, &to1);
1714 getvvcol(wp, pos2, &from2, NULL, &to2);
1715 }
1716 else
1717 {
1718 getvvcol(wp, pos2, &from1, NULL, &to1);
1719 getvvcol(wp, pos1, &from2, NULL, &to2);
1720 }
1721 if (from2 < from1)
1722 *left = from2;
1723 else
1724 *left = from1;
1725 if (to2 > to1)
1726 {
1727 if (*p_sel == 'e' && from2 - 1 >= to1)
1728 *right = from2 - 1;
1729 else
1730 *right = to2;
1731 }
1732 else
1733 *right = to1;
1734}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001735
1736/*
Bram Moolenaarce7eada2021-12-15 15:41:44 +00001737 * Skip over ' ' and '\t'.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001738 */
1739 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001740skipwhite(char_u *q)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001741{
Bram Moolenaar1387a602008-07-24 19:31:11 +00001742 char_u *p = q;
1743
Bram Moolenaarce7eada2021-12-15 15:41:44 +00001744 while (VIM_ISWHITE(*p))
1745 ++p;
1746 return p;
1747}
1748
Dominique Pelle748b3082022-01-08 12:41:16 +00001749#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaarce7eada2021-12-15 15:41:44 +00001750/*
1751 * skip over ' ', '\t' and '\n'.
1752 */
1753 char_u *
1754skipwhite_and_nl(char_u *q)
1755{
1756 char_u *p = q;
1757
1758 while (VIM_ISWHITE(*p) || *p == NL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001759 ++p;
1760 return p;
1761}
Dominique Pelle748b3082022-01-08 12:41:16 +00001762#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001763
1764/*
Bram Moolenaare2e69e42017-09-02 20:30:35 +02001765 * getwhitecols: return the number of whitespace
1766 * columns (bytes) at the start of a given line
1767 */
1768 int
Yegappan Lakshmanana23a11b2023-02-21 14:27:41 +00001769getwhitecols_curline(void)
Bram Moolenaare2e69e42017-09-02 20:30:35 +02001770{
1771 return getwhitecols(ml_get_curline());
1772}
1773
1774 int
1775getwhitecols(char_u *p)
1776{
1777 return skipwhite(p) - p;
1778}
1779
1780/*
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001781 * skip over digits
Bram Moolenaar071d4272004-06-13 20:20:40 +00001782 */
1783 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001784skipdigits(char_u *q)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001785{
Bram Moolenaar1387a602008-07-24 19:31:11 +00001786 char_u *p = q;
1787
Bram Moolenaarc667da52019-11-30 20:52:27 +01001788 while (VIM_ISDIGIT(*p)) // skip to next non-digit
Bram Moolenaar071d4272004-06-13 20:20:40 +00001789 ++p;
1790 return p;
1791}
1792
Bram Moolenaarc4956c82006-03-12 21:58:43 +00001793#if defined(FEAT_SYN_HL) || defined(FEAT_SPELL) || defined(PROTO)
Bram Moolenaar75c50c42005-06-04 22:06:24 +00001794/*
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01001795 * skip over binary digits
1796 */
1797 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001798skipbin(char_u *q)
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01001799{
1800 char_u *p = q;
1801
Bram Moolenaarc667da52019-11-30 20:52:27 +01001802 while (vim_isbdigit(*p)) // skip to next non-digit
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01001803 ++p;
1804 return p;
1805}
1806
1807/*
Bram Moolenaar75c50c42005-06-04 22:06:24 +00001808 * skip over digits and hex characters
1809 */
1810 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001811skiphex(char_u *q)
Bram Moolenaar75c50c42005-06-04 22:06:24 +00001812{
Bram Moolenaar1387a602008-07-24 19:31:11 +00001813 char_u *p = q;
1814
Bram Moolenaarc667da52019-11-30 20:52:27 +01001815 while (vim_isxdigit(*p)) // skip to next non-digit
Bram Moolenaar75c50c42005-06-04 22:06:24 +00001816 ++p;
1817 return p;
1818}
1819#endif
1820
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001821/*
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01001822 * skip to bin digit (or NUL after the string)
1823 */
1824 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001825skiptobin(char_u *q)
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01001826{
1827 char_u *p = q;
1828
Bram Moolenaarc667da52019-11-30 20:52:27 +01001829 while (*p != NUL && !vim_isbdigit(*p)) // skip to next digit
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01001830 ++p;
1831 return p;
1832}
1833
1834/*
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001835 * skip to digit (or NUL after the string)
1836 */
1837 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001838skiptodigit(char_u *q)
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001839{
Bram Moolenaar1387a602008-07-24 19:31:11 +00001840 char_u *p = q;
1841
Bram Moolenaarc667da52019-11-30 20:52:27 +01001842 while (*p != NUL && !VIM_ISDIGIT(*p)) // skip to next digit
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001843 ++p;
1844 return p;
1845}
1846
1847/*
1848 * skip to hex character (or NUL after the string)
1849 */
1850 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01001851skiptohex(char_u *q)
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001852{
Bram Moolenaar1387a602008-07-24 19:31:11 +00001853 char_u *p = q;
1854
Bram Moolenaarc667da52019-11-30 20:52:27 +01001855 while (*p != NUL && !vim_isxdigit(*p)) // skip to next digit
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001856 ++p;
1857 return p;
1858}
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00001859
Bram Moolenaar071d4272004-06-13 20:20:40 +00001860/*
1861 * Variant of isdigit() that can handle characters > 0x100.
1862 * We don't use isdigit() here, because on some systems it also considers
1863 * superscript 1 to be a digit.
1864 * Use the VIM_ISDIGIT() macro for simple arguments.
1865 */
1866 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001867vim_isdigit(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001868{
1869 return (c >= '0' && c <= '9');
1870}
1871
1872/*
1873 * Variant of isxdigit() that can handle characters > 0x100.
1874 * We don't use isxdigit() here, because on some systems it also considers
1875 * superscript 1 to be a digit.
1876 */
1877 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001878vim_isxdigit(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001879{
1880 return (c >= '0' && c <= '9')
1881 || (c >= 'a' && c <= 'f')
1882 || (c >= 'A' && c <= 'F');
1883}
1884
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01001885/*
1886 * Corollary of vim_isdigit and vim_isxdigit() that can handle
1887 * characters > 0x100.
1888 */
1889 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001890vim_isbdigit(int c)
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01001891{
1892 return (c == '0' || c == '1');
1893}
1894
Bram Moolenaarc37b6552021-01-07 19:36:30 +01001895 static int
1896vim_isodigit(int c)
1897{
1898 return (c >= '0' && c <= '7');
1899}
1900
Bram Moolenaar78622822005-08-23 21:00:13 +00001901/*
1902 * Vim's own character class functions. These exist because many library
1903 * islower()/toupper() etc. do not work properly: they crash when used with
1904 * invalid values or can't handle latin1 when the locale is C.
1905 * Speed is most important here.
1906 */
1907#define LATIN1LOWER 'l'
1908#define LATIN1UPPER 'U'
1909
Bram Moolenaar6e7c7f32005-08-24 22:16:11 +00001910static char_u latin1flags[257] = " UUUUUUUUUUUUUUUUUUUUUUUUUU llllllllllllllllllllllllll UUUUUUUUUUUUUUUUUUUUUUU UUUUUUUllllllllllllllllllllllll llllllll";
Bram Moolenaar936347b2012-05-25 11:56:22 +02001911static char_u latin1upper[257] = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xf7\xd8\xd9\xda\xdb\xdc\xdd\xde\xff";
1912static char_u latin1lower[257] = " !\"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xd7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff";
Bram Moolenaar78622822005-08-23 21:00:13 +00001913
1914 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001915vim_islower(int c)
Bram Moolenaar78622822005-08-23 21:00:13 +00001916{
1917 if (c <= '@')
1918 return FALSE;
1919 if (c >= 0x80)
1920 {
1921 if (enc_utf8)
1922 return utf_islower(c);
1923 if (c >= 0x100)
1924 {
1925#ifdef HAVE_ISWLOWER
1926 if (has_mbyte)
1927 return iswlower(c);
1928#endif
Bram Moolenaarc667da52019-11-30 20:52:27 +01001929 // islower() can't handle these chars and may crash
Bram Moolenaar78622822005-08-23 21:00:13 +00001930 return FALSE;
1931 }
1932 if (enc_latin1like)
1933 return (latin1flags[c] & LATIN1LOWER) == LATIN1LOWER;
1934 }
1935 return islower(c);
1936}
1937
1938 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001939vim_isupper(int c)
Bram Moolenaar78622822005-08-23 21:00:13 +00001940{
1941 if (c <= '@')
1942 return FALSE;
1943 if (c >= 0x80)
1944 {
1945 if (enc_utf8)
1946 return utf_isupper(c);
1947 if (c >= 0x100)
1948 {
1949#ifdef HAVE_ISWUPPER
1950 if (has_mbyte)
1951 return iswupper(c);
1952#endif
Bram Moolenaarc667da52019-11-30 20:52:27 +01001953 // islower() can't handle these chars and may crash
Bram Moolenaar78622822005-08-23 21:00:13 +00001954 return FALSE;
1955 }
1956 if (enc_latin1like)
1957 return (latin1flags[c] & LATIN1UPPER) == LATIN1UPPER;
1958 }
1959 return isupper(c);
1960}
1961
1962 int
Bram Moolenaar5921aeb2022-02-19 11:20:12 +00001963vim_isalpha(int c)
1964{
1965 return vim_islower(c) || vim_isupper(c);
1966}
1967
1968 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001969vim_toupper(int c)
Bram Moolenaar78622822005-08-23 21:00:13 +00001970{
1971 if (c <= '@')
1972 return c;
Bram Moolenaar3317d5e2017-04-08 19:12:06 +02001973 if (c >= 0x80 || !(cmp_flags & CMP_KEEPASCII))
Bram Moolenaar78622822005-08-23 21:00:13 +00001974 {
1975 if (enc_utf8)
1976 return utf_toupper(c);
1977 if (c >= 0x100)
1978 {
1979#ifdef HAVE_TOWUPPER
1980 if (has_mbyte)
1981 return towupper(c);
1982#endif
Bram Moolenaarc667da52019-11-30 20:52:27 +01001983 // toupper() can't handle these chars and may crash
Bram Moolenaar78622822005-08-23 21:00:13 +00001984 return c;
1985 }
1986 if (enc_latin1like)
1987 return latin1upper[c];
1988 }
Bram Moolenaar1cc48202017-04-09 13:41:59 +02001989 if (c < 0x80 && (cmp_flags & CMP_KEEPASCII))
1990 return TOUPPER_ASC(c);
Bram Moolenaar78622822005-08-23 21:00:13 +00001991 return TOUPPER_LOC(c);
1992}
1993
1994 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01001995vim_tolower(int c)
Bram Moolenaar78622822005-08-23 21:00:13 +00001996{
1997 if (c <= '@')
1998 return c;
Bram Moolenaar3317d5e2017-04-08 19:12:06 +02001999 if (c >= 0x80 || !(cmp_flags & CMP_KEEPASCII))
Bram Moolenaar78622822005-08-23 21:00:13 +00002000 {
2001 if (enc_utf8)
2002 return utf_tolower(c);
2003 if (c >= 0x100)
2004 {
2005#ifdef HAVE_TOWLOWER
2006 if (has_mbyte)
2007 return towlower(c);
2008#endif
Bram Moolenaarc667da52019-11-30 20:52:27 +01002009 // tolower() can't handle these chars and may crash
Bram Moolenaar78622822005-08-23 21:00:13 +00002010 return c;
2011 }
2012 if (enc_latin1like)
2013 return latin1lower[c];
2014 }
Bram Moolenaar1cc48202017-04-09 13:41:59 +02002015 if (c < 0x80 && (cmp_flags & CMP_KEEPASCII))
2016 return TOLOWER_ASC(c);
Bram Moolenaar78622822005-08-23 21:00:13 +00002017 return TOLOWER_LOC(c);
2018}
Bram Moolenaar78622822005-08-23 21:00:13 +00002019
Bram Moolenaar071d4272004-06-13 20:20:40 +00002020/*
2021 * skiptowhite: skip over text until ' ' or '\t' or NUL.
2022 */
2023 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002024skiptowhite(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002025{
2026 while (*p != ' ' && *p != '\t' && *p != NUL)
2027 ++p;
2028 return p;
2029}
2030
Bram Moolenaar071d4272004-06-13 20:20:40 +00002031/*
2032 * skiptowhite_esc: Like skiptowhite(), but also skip escaped chars
2033 */
2034 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002035skiptowhite_esc(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002036{
2037 while (*p != ' ' && *p != '\t' && *p != NUL)
2038 {
2039 if ((*p == '\\' || *p == Ctrl_V) && *(p + 1) != NUL)
2040 ++p;
2041 ++p;
2042 }
2043 return p;
2044}
Bram Moolenaar071d4272004-06-13 20:20:40 +00002045
2046/*
Bram Moolenaaraf377e32021-11-29 12:12:43 +00002047 * Get a number from a string and skip over it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002048 * Note: the argument is a pointer to a char_u pointer!
2049 */
2050 long
Bram Moolenaar7454a062016-01-30 15:14:10 +01002051getdigits(char_u **pp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002052{
2053 char_u *p;
2054 long retval;
2055
2056 p = *pp;
2057 retval = atol((char *)p);
Bram Moolenaarc667da52019-11-30 20:52:27 +01002058 if (*p == '-') // skip negative sign
Bram Moolenaar071d4272004-06-13 20:20:40 +00002059 ++p;
Bram Moolenaarc667da52019-11-30 20:52:27 +01002060 p = skipdigits(p); // skip to next non-digit
Bram Moolenaar071d4272004-06-13 20:20:40 +00002061 *pp = p;
2062 return retval;
2063}
2064
2065/*
Bram Moolenaaraf377e32021-11-29 12:12:43 +00002066 * Like getdigits() but allow for embedded single quotes.
2067 */
2068 long
2069getdigits_quoted(char_u **pp)
2070{
2071 char_u *p = *pp;
2072 long retval = 0;
2073
2074 if (*p == '-')
2075 ++p;
2076 while (VIM_ISDIGIT(*p))
2077 {
2078 if (retval >= LONG_MAX / 10 - 10)
2079 retval = LONG_MAX;
2080 else
2081 retval = retval * 10 - '0' + *p;
2082 ++p;
2083 if (in_vim9script() && *p == '\'' && VIM_ISDIGIT(p[1]))
2084 ++p;
2085 }
2086 if (**pp == '-')
2087 {
2088 if (retval == LONG_MAX)
2089 retval = LONG_MIN;
2090 else
2091 retval = -retval;
2092 }
2093 *pp = p;
2094 return retval;
2095}
2096
2097/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00002098 * Return TRUE if "lbuf" is empty or only contains blanks.
2099 */
2100 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002101vim_isblankline(char_u *lbuf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002102{
2103 char_u *p;
2104
2105 p = skipwhite(lbuf);
2106 return (*p == NUL || *p == '\r' || *p == '\n');
2107}
2108
2109/*
2110 * Convert a string into a long and/or unsigned long, taking care of
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002111 * hexadecimal, octal, and binary numbers. Accepts a '-' sign.
2112 * If "prep" is not NULL, returns a flag to indicate the type of the number:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002113 * 0 decimal
2114 * '0' octal
Bram Moolenaarc17e66c2020-06-02 21:38:22 +02002115 * 'O' octal
2116 * 'o' octal
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002117 * 'B' bin
2118 * 'b' bin
Bram Moolenaar071d4272004-06-13 20:20:40 +00002119 * 'X' hex
2120 * 'x' hex
2121 * If "len" is not NULL, the length of the number in characters is returned.
2122 * If "nptr" is not NULL, the signed result is returned in it.
2123 * If "unptr" is not NULL, the unsigned result is returned in it.
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002124 * If "what" contains STR2NR_BIN recognize binary numbers
2125 * If "what" contains STR2NR_OCT recognize octal numbers
2126 * If "what" contains STR2NR_HEX recognize hex numbers
2127 * If "what" contains STR2NR_FORCE always assume bin/oct/hex.
Bram Moolenaar1ac90b42019-09-15 14:49:52 +02002128 * If "what" contains STR2NR_QUOTE ignore embedded single quotes
Bram Moolenaarce157752017-10-28 16:07:33 +02002129 * If maxlen > 0, check at a maximum maxlen chars.
Bram Moolenaar16e9b852019-05-19 19:59:35 +02002130 * If strict is TRUE, check the number strictly. return *len = 0 if fail.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002131 */
2132 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002133vim_str2nr(
2134 char_u *start,
Bram Moolenaar16e9b852019-05-19 19:59:35 +02002135 int *prep, // return: type of number 0 = decimal, 'x'
Bram Moolenaarc17e66c2020-06-02 21:38:22 +02002136 // or 'X' is hex, '0', 'o' or 'O' is octal,
2137 // 'b' or 'B' is bin
Bram Moolenaar16e9b852019-05-19 19:59:35 +02002138 int *len, // return: detected length of number
2139 int what, // what numbers to recognize
2140 varnumber_T *nptr, // return: signed result
2141 uvarnumber_T *unptr, // return: unsigned result
2142 int maxlen, // max length of string to check
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002143 int strict, // check strictly
2144 int *overflow) // when not NULL set to TRUE for overflow
Bram Moolenaar071d4272004-06-13 20:20:40 +00002145{
2146 char_u *ptr = start;
Bram Moolenaar16e9b852019-05-19 19:59:35 +02002147 int pre = 0; // default is decimal
Bram Moolenaar071d4272004-06-13 20:20:40 +00002148 int negative = FALSE;
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002149 uvarnumber_T un = 0;
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00002150 int n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002151
Bram Moolenaar16e9b852019-05-19 19:59:35 +02002152 if (len != NULL)
2153 *len = 0;
2154
Bram Moolenaar071d4272004-06-13 20:20:40 +00002155 if (ptr[0] == '-')
2156 {
2157 negative = TRUE;
2158 ++ptr;
2159 }
2160
Bram Moolenaarc667da52019-11-30 20:52:27 +01002161 // Recognize hex, octal, and bin.
Bram Moolenaar5d1bc782015-07-17 13:03:48 +02002162 if (ptr[0] == '0' && ptr[1] != '8' && ptr[1] != '9'
2163 && (maxlen == 0 || maxlen > 1))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002164 {
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002165 pre = ptr[1];
2166 if ((what & STR2NR_HEX)
2167 && (pre == 'X' || pre == 'x') && vim_isxdigit(ptr[2])
2168 && (maxlen == 0 || maxlen > 2))
Bram Moolenaarc667da52019-11-30 20:52:27 +01002169 // hexadecimal
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002170 ptr += 2;
2171 else if ((what & STR2NR_BIN)
2172 && (pre == 'B' || pre == 'b') && vim_isbdigit(ptr[2])
2173 && (maxlen == 0 || maxlen > 2))
Bram Moolenaarc667da52019-11-30 20:52:27 +01002174 // binary
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002175 ptr += 2;
Bram Moolenaarc17e66c2020-06-02 21:38:22 +02002176 else if ((what & STR2NR_OOCT)
Bram Moolenaarc37b6552021-01-07 19:36:30 +01002177 && (pre == 'O' || pre == 'o') && vim_isodigit(ptr[2])
Bram Moolenaarc17e66c2020-06-02 21:38:22 +02002178 && (maxlen == 0 || maxlen > 2))
2179 // octal with prefix "0o"
2180 ptr += 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002181 else
2182 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002183 // decimal or octal, default is decimal
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002184 pre = 0;
2185 if (what & STR2NR_OCT)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00002186 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002187 // Don't interpret "0", "08" or "0129" as octal.
Bram Moolenaarce157752017-10-28 16:07:33 +02002188 for (n = 1; n != maxlen && VIM_ISDIGIT(ptr[n]); ++n)
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00002189 {
2190 if (ptr[n] > '7')
2191 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002192 pre = 0; // can't be octal
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00002193 break;
2194 }
Bram Moolenaarc667da52019-11-30 20:52:27 +01002195 pre = '0'; // assume octal
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00002196 }
2197 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002198 }
2199 }
2200
Bram Moolenaar16e9b852019-05-19 19:59:35 +02002201 // Do the conversion manually to avoid sscanf() quirks.
Bram Moolenaar5d1bc782015-07-17 13:03:48 +02002202 n = 1;
Bram Moolenaar1ac90b42019-09-15 14:49:52 +02002203 if (pre == 'B' || pre == 'b'
2204 || ((what & STR2NR_BIN) && (what & STR2NR_FORCE)))
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002205 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002206 // bin
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002207 if (pre != 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002208 n += 2; // skip over "0b"
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002209 while ('0' <= *ptr && *ptr <= '1')
2210 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002211 // avoid ubsan error for overflow
Bram Moolenaar07ccf7c2018-06-12 17:25:36 +02002212 if (un <= UVARNUM_MAX / 2)
2213 un = 2 * un + (uvarnumber_T)(*ptr - '0');
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002214 else
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002215 {
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002216 un = UVARNUM_MAX;
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002217 if (overflow != NULL)
2218 *overflow = TRUE;
2219 }
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002220 ++ptr;
2221 if (n++ == maxlen)
2222 break;
Bram Moolenaar1ac90b42019-09-15 14:49:52 +02002223 if ((what & STR2NR_QUOTE) && *ptr == '\''
2224 && '0' <= ptr[1] && ptr[1] <= '1')
2225 {
2226 ++ptr;
2227 if (n++ == maxlen)
2228 break;
2229 }
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002230 }
2231 }
Bram Moolenaarc17e66c2020-06-02 21:38:22 +02002232 else if (pre == 'O' || pre == 'o' ||
2233 pre == '0' || ((what & STR2NR_OCT) && (what & STR2NR_FORCE)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002234 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002235 // octal
Bram Moolenaarc17e66c2020-06-02 21:38:22 +02002236 if (pre != 0 && pre != '0')
2237 n += 2; // skip over "0o"
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00002238 while ('0' <= *ptr && *ptr <= '7')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002239 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002240 // avoid ubsan error for overflow
Bram Moolenaar07ccf7c2018-06-12 17:25:36 +02002241 if (un <= UVARNUM_MAX / 8)
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002242 un = 8 * un + (uvarnumber_T)(*ptr - '0');
2243 else
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002244 {
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002245 un = UVARNUM_MAX;
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002246 if (overflow != NULL)
2247 *overflow = TRUE;
2248 }
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00002249 ++ptr;
Bram Moolenaar5d1bc782015-07-17 13:03:48 +02002250 if (n++ == maxlen)
2251 break;
Bram Moolenaar1ac90b42019-09-15 14:49:52 +02002252 if ((what & STR2NR_QUOTE) && *ptr == '\''
2253 && '0' <= ptr[1] && ptr[1] <= '7')
2254 {
2255 ++ptr;
2256 if (n++ == maxlen)
2257 break;
2258 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002259 }
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00002260 }
Bram Moolenaar1ac90b42019-09-15 14:49:52 +02002261 else if (pre != 0 || ((what & STR2NR_HEX) && (what & STR2NR_FORCE)))
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00002262 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002263 // hex
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002264 if (pre != 0)
Bram Moolenaarc667da52019-11-30 20:52:27 +01002265 n += 2; // skip over "0x"
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00002266 while (vim_isxdigit(*ptr))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002267 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002268 // avoid ubsan error for overflow
Bram Moolenaar07ccf7c2018-06-12 17:25:36 +02002269 if (un <= UVARNUM_MAX / 16)
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002270 un = 16 * un + (uvarnumber_T)hex2nr(*ptr);
2271 else
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002272 {
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002273 un = UVARNUM_MAX;
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002274 if (overflow != NULL)
2275 *overflow = TRUE;
2276 }
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +00002277 ++ptr;
Bram Moolenaar5d1bc782015-07-17 13:03:48 +02002278 if (n++ == maxlen)
2279 break;
Bram Moolenaar1ac90b42019-09-15 14:49:52 +02002280 if ((what & STR2NR_QUOTE) && *ptr == '\'' && vim_isxdigit(ptr[1]))
2281 {
2282 ++ptr;
2283 if (n++ == maxlen)
2284 break;
2285 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002286 }
2287 }
2288 else
2289 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002290 // decimal
Bram Moolenaar071d4272004-06-13 20:20:40 +00002291 while (VIM_ISDIGIT(*ptr))
2292 {
Bram Moolenaar07ccf7c2018-06-12 17:25:36 +02002293 uvarnumber_T digit = (uvarnumber_T)(*ptr - '0');
2294
Bram Moolenaarc667da52019-11-30 20:52:27 +01002295 // avoid ubsan error for overflow
Bram Moolenaar07ccf7c2018-06-12 17:25:36 +02002296 if (un < UVARNUM_MAX / 10
2297 || (un == UVARNUM_MAX / 10 && digit <= UVARNUM_MAX % 10))
2298 un = 10 * un + digit;
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002299 else
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002300 {
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002301 un = UVARNUM_MAX;
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002302 if (overflow != NULL)
2303 *overflow = TRUE;
2304 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002305 ++ptr;
Bram Moolenaar5d1bc782015-07-17 13:03:48 +02002306 if (n++ == maxlen)
2307 break;
Bram Moolenaar1ac90b42019-09-15 14:49:52 +02002308 if ((what & STR2NR_QUOTE) && *ptr == '\'' && VIM_ISDIGIT(ptr[1]))
2309 {
2310 ++ptr;
2311 if (n++ == maxlen)
2312 break;
2313 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002314 }
2315 }
Bram Moolenaar1ac90b42019-09-15 14:49:52 +02002316
Bram Moolenaar4b96df52020-01-26 22:00:26 +01002317 // Check for an alphanumeric character immediately following, that is
Bram Moolenaar16e9b852019-05-19 19:59:35 +02002318 // most likely a typo.
2319 if (strict && n - 1 != maxlen && ASCII_ISALNUM(*ptr))
2320 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002321
Bram Moolenaar887c1fe2016-01-02 17:56:35 +01002322 if (prep != NULL)
2323 *prep = pre;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002324 if (len != NULL)
2325 *len = (int)(ptr - start);
2326 if (nptr != NULL)
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +00002327 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002328 if (negative) // account for leading '-' for decimal numbers
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002329 {
Bram Moolenaarc667da52019-11-30 20:52:27 +01002330 // avoid ubsan error for overflow
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002331 if (un > VARNUM_MAX)
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002332 {
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002333 *nptr = VARNUM_MIN;
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002334 if (overflow != NULL)
2335 *overflow = TRUE;
2336 }
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002337 else
2338 *nptr = -(varnumber_T)un;
2339 }
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +00002340 else
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002341 {
dundargocc57b5bc2022-11-02 13:30:51 +00002342 // prevent a large unsigned number to become negative
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002343 if (un > VARNUM_MAX)
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002344 {
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002345 un = VARNUM_MAX;
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00002346 if (overflow != NULL)
2347 *overflow = TRUE;
2348 }
Bram Moolenaar22fcfad2016-07-01 18:17:26 +02002349 *nptr = (varnumber_T)un;
Bram Moolenaar7a40ea22017-01-22 18:34:57 +01002350 }
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +00002351 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002352 if (unptr != NULL)
2353 *unptr = un;
2354}
2355
2356/*
2357 * Return the value of a single hex character.
2358 * Only valid when the argument is '0' - '9', 'A' - 'F' or 'a' - 'f'.
2359 */
2360 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002361hex2nr(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002362{
2363 if (c >= 'a' && c <= 'f')
2364 return c - 'a' + 10;
2365 if (c >= 'A' && c <= 'F')
2366 return c - 'A' + 10;
2367 return c - '0';
2368}
2369
Bram Moolenaar071d4272004-06-13 20:20:40 +00002370/*
2371 * Convert two hex characters to a byte.
2372 * Return -1 if one of the characters is not hex.
2373 */
2374 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002375hexhex2nr(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002376{
2377 if (!vim_isxdigit(p[0]) || !vim_isxdigit(p[1]))
2378 return -1;
2379 return (hex2nr(p[0]) << 4) + hex2nr(p[1]);
2380}
Bram Moolenaar071d4272004-06-13 20:20:40 +00002381
2382/*
2383 * Return TRUE if "str" starts with a backslash that should be removed.
Bram Moolenaar2c519cf2019-03-21 21:45:34 +01002384 * For MS-DOS, MSWIN and OS/2 this is only done when the character after the
Bram Moolenaar071d4272004-06-13 20:20:40 +00002385 * backslash is not a normal file name character.
2386 * '$' is a valid file name character, we don't remove the backslash before
2387 * it. This means it is not possible to use an environment variable after a
2388 * backslash. "C:\$VIM\doc" is taken literally, only "$VIM\doc" works.
2389 * Although "\ name" is valid, the backslash in "Program\ files" must be
2390 * removed. Assume a file name doesn't start with a space.
2391 * For multi-byte names, never remove a backslash before a non-ascii
2392 * character, assume that all multi-byte characters are valid file name
2393 * characters.
2394 */
2395 int
Bram Moolenaar7454a062016-01-30 15:14:10 +01002396rem_backslash(char_u *str)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002397{
2398#ifdef BACKSLASH_IN_FILENAME
2399 return (str[0] == '\\'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002400 && str[1] < 0x80
Bram Moolenaar071d4272004-06-13 20:20:40 +00002401 && (str[1] == ' '
2402 || (str[1] != NUL
2403 && str[1] != '*'
2404 && str[1] != '?'
2405 && !vim_isfilec(str[1]))));
2406#else
2407 return (str[0] == '\\' && str[1] != NUL);
2408#endif
2409}
2410
2411/*
2412 * Halve the number of backslashes in a file name argument.
2413 * For MS-DOS we only do this if the character after the backslash
2414 * is not a normal file character.
2415 */
2416 void
Bram Moolenaar7454a062016-01-30 15:14:10 +01002417backslash_halve(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002418{
2419 for ( ; *p; ++p)
2420 if (rem_backslash(p))
Bram Moolenaar446cb832008-06-24 21:56:24 +00002421 STRMOVE(p, p + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002422}
2423
2424/*
2425 * backslash_halve() plus save the result in allocated memory.
Bram Moolenaare2c453d2019-08-21 14:37:09 +02002426 * However, returns "p" when out of memory.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002427 */
2428 char_u *
Bram Moolenaar7454a062016-01-30 15:14:10 +01002429backslash_halve_save(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002430{
2431 char_u *res;
2432
2433 res = vim_strsave(p);
2434 if (res == NULL)
2435 return p;
2436 backslash_halve(res);
2437 return res;
2438}