blob: 710b1d35ce59d1da211e8b48278b7ed00e239c0c [file] [log] [blame]
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001/* vi:set ts=8 sts=4 sw=4 noet:
2 *
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/*
11 * strings.c: string manipulation functions
12 */
13
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +020014#define USING_FLOAT_STUFF
Yegappan Lakshmanana2438132021-07-10 21:29:18 +020015#include "vim.h"
16
17/*
18 * Copy "string" into newly allocated memory.
19 */
20 char_u *
21vim_strsave(char_u *string)
22{
23 char_u *p;
24 size_t len;
25
26 len = STRLEN(string) + 1;
27 p = alloc(len);
28 if (p != NULL)
29 mch_memmove(p, string, len);
30 return p;
31}
32
33/*
34 * Copy up to "len" bytes of "string" into newly allocated memory and
35 * terminate with a NUL.
36 * The allocated memory always has size "len + 1", also when "string" is
37 * shorter.
38 */
39 char_u *
40vim_strnsave(char_u *string, size_t len)
41{
42 char_u *p;
43
44 p = alloc(len + 1);
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +000045 if (p == NULL)
46 return NULL;
47
48 STRNCPY(p, string, len);
49 p[len] = NUL;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +020050 return p;
51}
52
53/*
54 * Same as vim_strsave(), but any characters found in esc_chars are preceded
55 * by a backslash.
56 */
57 char_u *
58vim_strsave_escaped(char_u *string, char_u *esc_chars)
59{
60 return vim_strsave_escaped_ext(string, esc_chars, '\\', FALSE);
61}
62
63/*
64 * Same as vim_strsave_escaped(), but when "bsl" is TRUE also escape
65 * characters where rem_backslash() would remove the backslash.
66 * Escape the characters with "cc".
67 */
68 char_u *
69vim_strsave_escaped_ext(
70 char_u *string,
71 char_u *esc_chars,
72 int cc,
73 int bsl)
74{
75 char_u *p;
76 char_u *p2;
77 char_u *escaped_string;
78 unsigned length;
79 int l;
80
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +020081 // First count the number of backslashes required.
82 // Then allocate the memory and insert them.
Yegappan Lakshmanana2438132021-07-10 21:29:18 +020083 length = 1; // count the trailing NUL
84 for (p = string; *p; p++)
85 {
86 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
87 {
88 length += l; // count a multibyte char
89 p += l - 1;
90 continue;
91 }
92 if (vim_strchr(esc_chars, *p) != NULL || (bsl && rem_backslash(p)))
93 ++length; // count a backslash
94 ++length; // count an ordinary char
95 }
96 escaped_string = alloc(length);
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +000097 if (escaped_string == NULL)
98 return NULL;
99 p2 = escaped_string;
100 for (p = string; *p; p++)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200101 {
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000102 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200103 {
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000104 mch_memmove(p2, p, (size_t)l);
105 p2 += l;
106 p += l - 1; // skip multibyte char
107 continue;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200108 }
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000109 if (vim_strchr(esc_chars, *p) != NULL || (bsl && rem_backslash(p)))
110 *p2++ = cc;
111 *p2++ = *p;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200112 }
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000113 *p2 = NUL;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200114 return escaped_string;
115}
116
117/*
118 * Return TRUE when 'shell' has "csh" in the tail.
119 */
120 int
121csh_like_shell(void)
122{
123 return (strstr((char *)gettail(p_sh), "csh") != NULL);
124}
125
126/*
Jason Cox6e823512021-08-29 12:36:49 +0200127 * Return TRUE when 'shell' has "fish" in the tail.
128 */
Dominique Pellede05ae72021-08-30 19:57:34 +0200129 static int
Jason Cox6e823512021-08-29 12:36:49 +0200130fish_like_shell(void)
131{
132 return (strstr((char *)gettail(p_sh), "fish") != NULL);
133}
134
135/*
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200136 * Escape "string" for use as a shell argument with system().
137 * This uses single quotes, except when we know we need to use double quotes
138 * (MS-DOS and MS-Windows not using PowerShell and without 'shellslash' set).
139 * PowerShell also uses a novel escaping for enclosed single quotes - double
140 * them up.
141 * Escape a newline, depending on the 'shell' option.
142 * When "do_special" is TRUE also replace "!", "%", "#" and things starting
143 * with "<" like "<cfile>".
144 * When "do_newline" is FALSE do not escape newline unless it is csh shell.
145 * Returns the result in allocated memory, NULL if we have run out.
146 */
147 char_u *
148vim_strsave_shellescape(char_u *string, int do_special, int do_newline)
149{
150 unsigned length;
151 char_u *p;
152 char_u *d;
153 char_u *escaped_string;
154 int l;
155 int csh_like;
Jason Cox6e823512021-08-29 12:36:49 +0200156 int fish_like;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200157 char_u *shname;
158 int powershell;
159# ifdef MSWIN
160 int double_quotes;
161# endif
162
163 // Only csh and similar shells expand '!' within single quotes. For sh and
164 // the like we must not put a backslash before it, it will be taken
165 // literally. If do_special is set the '!' will be escaped twice.
166 // Csh also needs to have "\n" escaped twice when do_special is set.
167 csh_like = csh_like_shell();
168
Jason Cox6e823512021-08-29 12:36:49 +0200169 // Fish shell uses '\' as an escape character within single quotes, so '\'
170 // itself must be escaped to get a literal '\'.
171 fish_like = fish_like_shell();
172
Dominique Pelleaf4a61a2021-12-27 17:21:41 +0000173 // PowerShell uses its own version for quoting single quotes
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200174 shname = gettail(p_sh);
175 powershell = strstr((char *)shname, "pwsh") != NULL;
176# ifdef MSWIN
177 powershell = powershell || strstr((char *)shname, "powershell") != NULL;
178 // PowerShell only accepts single quotes so override shellslash.
179 double_quotes = !powershell && !p_ssl;
180# endif
181
182 // First count the number of extra bytes required.
183 length = (unsigned)STRLEN(string) + 3; // two quotes and a trailing NUL
184 for (p = string; *p != NUL; MB_PTR_ADV(p))
185 {
186# ifdef MSWIN
187 if (double_quotes)
188 {
189 if (*p == '"')
190 ++length; // " -> ""
191 }
192 else
193# endif
194 if (*p == '\'')
195 {
196 if (powershell)
197 length +=2; // ' => ''
198 else
199 length += 3; // ' => '\''
200 }
201 if ((*p == '\n' && (csh_like || do_newline))
202 || (*p == '!' && (csh_like || do_special)))
203 {
204 ++length; // insert backslash
205 if (csh_like && do_special)
206 ++length; // insert backslash
207 }
208 if (do_special && find_cmdline_var(p, &l) >= 0)
209 {
210 ++length; // insert backslash
211 p += l - 1;
212 }
Jason Cox6e823512021-08-29 12:36:49 +0200213 if (*p == '\\' && fish_like)
214 ++length; // insert backslash
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200215 }
216
217 // Allocate memory for the result and fill it.
218 escaped_string = alloc(length);
219 if (escaped_string != NULL)
220 {
221 d = escaped_string;
222
223 // add opening quote
224# ifdef MSWIN
225 if (double_quotes)
226 *d++ = '"';
227 else
228# endif
229 *d++ = '\'';
230
231 for (p = string; *p != NUL; )
232 {
233# ifdef MSWIN
234 if (double_quotes)
235 {
236 if (*p == '"')
237 {
238 *d++ = '"';
239 *d++ = '"';
240 ++p;
241 continue;
242 }
243 }
244 else
245# endif
246 if (*p == '\'')
247 {
248 if (powershell)
249 {
250 *d++ = '\'';
251 *d++ = '\'';
252 }
253 else
254 {
255 *d++ = '\'';
256 *d++ = '\\';
257 *d++ = '\'';
258 *d++ = '\'';
259 }
260 ++p;
261 continue;
262 }
263 if ((*p == '\n' && (csh_like || do_newline))
264 || (*p == '!' && (csh_like || do_special)))
265 {
266 *d++ = '\\';
267 if (csh_like && do_special)
268 *d++ = '\\';
269 *d++ = *p++;
270 continue;
271 }
272 if (do_special && find_cmdline_var(p, &l) >= 0)
273 {
274 *d++ = '\\'; // insert backslash
275 while (--l >= 0) // copy the var
276 *d++ = *p++;
277 continue;
278 }
Jason Cox6e823512021-08-29 12:36:49 +0200279 if (*p == '\\' && fish_like)
280 {
281 *d++ = '\\';
282 *d++ = *p++;
Bram Moolenaar66315972021-09-01 14:31:51 +0200283 continue;
Jason Cox6e823512021-08-29 12:36:49 +0200284 }
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200285
286 MB_COPY_CHAR(p, d);
287 }
288
289 // add terminating quote and finish with a NUL
290# ifdef MSWIN
291 if (double_quotes)
292 *d++ = '"';
293 else
294# endif
295 *d++ = '\'';
296 *d = NUL;
297 }
298
299 return escaped_string;
300}
301
302/*
303 * Like vim_strsave(), but make all characters uppercase.
304 * This uses ASCII lower-to-upper case translation, language independent.
305 */
306 char_u *
307vim_strsave_up(char_u *string)
308{
309 char_u *p1;
310
311 p1 = vim_strsave(string);
312 vim_strup(p1);
313 return p1;
314}
315
316/*
317 * Like vim_strnsave(), but make all characters uppercase.
318 * This uses ASCII lower-to-upper case translation, language independent.
319 */
320 char_u *
321vim_strnsave_up(char_u *string, size_t len)
322{
323 char_u *p1;
324
325 p1 = vim_strnsave(string, len);
326 vim_strup(p1);
327 return p1;
328}
329
330/*
331 * ASCII lower-to-upper case translation, language independent.
332 */
333 void
334vim_strup(
335 char_u *p)
336{
337 char_u *p2;
338 int c;
339
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000340 if (p == NULL)
341 return;
342
343 p2 = p;
344 while ((c = *p2) != NUL)
345 *p2++ = (c < 'a' || c > 'z') ? c : (c - 0x20);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200346}
347
348#if defined(FEAT_EVAL) || defined(FEAT_SPELL) || defined(PROTO)
349/*
350 * Make string "s" all upper-case and return it in allocated memory.
351 * Handles multi-byte characters as well as possible.
352 * Returns NULL when out of memory.
353 */
354 static char_u *
355strup_save(char_u *orig)
356{
357 char_u *p;
358 char_u *res;
359
360 res = p = vim_strsave(orig);
361
362 if (res != NULL)
363 while (*p != NUL)
364 {
365 int l;
366
367 if (enc_utf8)
368 {
369 int c, uc;
370 int newl;
371 char_u *s;
372
373 c = utf_ptr2char(p);
374 l = utf_ptr2len(p);
375 if (c == 0)
376 {
377 // overlong sequence, use only the first byte
378 c = *p;
379 l = 1;
380 }
381 uc = utf_toupper(c);
382
383 // Reallocate string when byte count changes. This is rare,
384 // thus it's OK to do another malloc()/free().
385 newl = utf_char2len(uc);
386 if (newl != l)
387 {
388 s = alloc(STRLEN(res) + 1 + newl - l);
389 if (s == NULL)
390 {
391 vim_free(res);
392 return NULL;
393 }
394 mch_memmove(s, res, p - res);
395 STRCPY(s + (p - res) + newl, p + l);
396 p = s + (p - res);
397 vim_free(res);
398 res = s;
399 }
400
401 utf_char2bytes(uc, p);
402 p += newl;
403 }
404 else if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
405 p += l; // skip multi-byte character
406 else
407 {
408 *p = TOUPPER_LOC(*p); // note that toupper() can be a macro
409 p++;
410 }
411 }
412
413 return res;
414}
415
416/*
417 * Make string "s" all lower-case and return it in allocated memory.
418 * Handles multi-byte characters as well as possible.
419 * Returns NULL when out of memory.
420 */
421 char_u *
422strlow_save(char_u *orig)
423{
424 char_u *p;
425 char_u *res;
426
427 res = p = vim_strsave(orig);
428
429 if (res != NULL)
430 while (*p != NUL)
431 {
432 int l;
433
434 if (enc_utf8)
435 {
436 int c, lc;
437 int newl;
438 char_u *s;
439
440 c = utf_ptr2char(p);
441 l = utf_ptr2len(p);
442 if (c == 0)
443 {
444 // overlong sequence, use only the first byte
445 c = *p;
446 l = 1;
447 }
448 lc = utf_tolower(c);
449
450 // Reallocate string when byte count changes. This is rare,
451 // thus it's OK to do another malloc()/free().
452 newl = utf_char2len(lc);
453 if (newl != l)
454 {
455 s = alloc(STRLEN(res) + 1 + newl - l);
456 if (s == NULL)
457 {
458 vim_free(res);
459 return NULL;
460 }
461 mch_memmove(s, res, p - res);
462 STRCPY(s + (p - res) + newl, p + l);
463 p = s + (p - res);
464 vim_free(res);
465 res = s;
466 }
467
468 utf_char2bytes(lc, p);
469 p += newl;
470 }
471 else if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)
472 p += l; // skip multi-byte character
473 else
474 {
475 *p = TOLOWER_LOC(*p); // note that tolower() can be a macro
476 p++;
477 }
478 }
479
480 return res;
481}
482#endif
483
484/*
485 * delete spaces at the end of a string
486 */
487 void
488del_trailing_spaces(char_u *ptr)
489{
490 char_u *q;
491
492 q = ptr + STRLEN(ptr);
493 while (--q > ptr && VIM_ISWHITE(q[0]) && q[-1] != '\\' && q[-1] != Ctrl_V)
494 *q = NUL;
495}
496
497/*
498 * Like strncpy(), but always terminate the result with one NUL.
499 * "to" must be "len + 1" long!
500 */
501 void
502vim_strncpy(char_u *to, char_u *from, size_t len)
503{
504 STRNCPY(to, from, len);
505 to[len] = NUL;
506}
507
508/*
509 * Like strcat(), but make sure the result fits in "tosize" bytes and is
510 * always NUL terminated. "from" and "to" may overlap.
511 */
512 void
513vim_strcat(char_u *to, char_u *from, size_t tosize)
514{
515 size_t tolen = STRLEN(to);
516 size_t fromlen = STRLEN(from);
517
518 if (tolen + fromlen + 1 > tosize)
519 {
520 mch_memmove(to + tolen, from, tosize - tolen - 1);
521 to[tosize - 1] = NUL;
522 }
523 else
524 mch_memmove(to + tolen, from, fromlen + 1);
525}
526
Bram Moolenaarc32949b2023-01-04 15:56:51 +0000527/*
528 * A version of strlen() that has a maximum length.
529 */
530 size_t
531vim_strlen_maxlen(char *s, size_t maxlen)
532{
533 size_t i;
534 for (i = 0; i < maxlen; ++i)
535 if (s[i] == NUL)
536 break;
537 return i;
538}
539
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200540#if (!defined(HAVE_STRCASECMP) && !defined(HAVE_STRICMP)) || defined(PROTO)
541/*
542 * Compare two strings, ignoring case, using current locale.
543 * Doesn't work for multi-byte characters.
544 * return 0 for match, < 0 for smaller, > 0 for bigger
545 */
546 int
547vim_stricmp(char *s1, char *s2)
548{
549 int i;
550
551 for (;;)
552 {
553 i = (int)TOLOWER_LOC(*s1) - (int)TOLOWER_LOC(*s2);
554 if (i != 0)
555 return i; // this character different
556 if (*s1 == NUL)
557 break; // strings match until NUL
558 ++s1;
559 ++s2;
560 }
561 return 0; // strings match
562}
563#endif
564
565#if (!defined(HAVE_STRNCASECMP) && !defined(HAVE_STRNICMP)) || defined(PROTO)
566/*
567 * Compare two strings, for length "len", ignoring case, using current locale.
568 * Doesn't work for multi-byte characters.
569 * return 0 for match, < 0 for smaller, > 0 for bigger
570 */
571 int
572vim_strnicmp(char *s1, char *s2, size_t len)
573{
574 int i;
575
576 while (len > 0)
577 {
578 i = (int)TOLOWER_LOC(*s1) - (int)TOLOWER_LOC(*s2);
579 if (i != 0)
580 return i; // this character different
581 if (*s1 == NUL)
582 break; // strings match until NUL
583 ++s1;
584 ++s2;
585 --len;
586 }
587 return 0; // strings match
588}
589#endif
590
591/*
592 * Search for first occurrence of "c" in "string".
593 * Version of strchr() that handles unsigned char strings with characters from
594 * 128 to 255 correctly. It also doesn't return a pointer to the NUL at the
595 * end of the string.
596 */
Bram Moolenaarc32949b2023-01-04 15:56:51 +0000597 char_u *
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200598vim_strchr(char_u *string, int c)
599{
600 char_u *p;
601 int b;
602
603 p = string;
604 if (enc_utf8 && c >= 0x80)
605 {
606 while (*p != NUL)
607 {
608 int l = utfc_ptr2len(p);
609
610 // Avoid matching an illegal byte here.
611 if (utf_ptr2char(p) == c && l > 1)
612 return p;
613 p += l;
614 }
615 return NULL;
616 }
617 if (enc_dbcs != 0 && c > 255)
618 {
619 int n2 = c & 0xff;
620
621 c = ((unsigned)c >> 8) & 0xff;
622 while ((b = *p) != NUL)
623 {
624 if (b == c && p[1] == n2)
625 return p;
626 p += (*mb_ptr2len)(p);
627 }
628 return NULL;
629 }
630 if (has_mbyte)
631 {
632 while ((b = *p) != NUL)
633 {
634 if (b == c)
635 return p;
636 p += (*mb_ptr2len)(p);
637 }
638 return NULL;
639 }
640 while ((b = *p) != NUL)
641 {
642 if (b == c)
643 return p;
644 ++p;
645 }
646 return NULL;
647}
648
649/*
650 * Version of strchr() that only works for bytes and handles unsigned char
651 * strings with characters above 128 correctly. It also doesn't return a
652 * pointer to the NUL at the end of the string.
653 */
654 char_u *
655vim_strbyte(char_u *string, int c)
656{
657 char_u *p = string;
658
659 while (*p != NUL)
660 {
661 if (*p == c)
662 return p;
663 ++p;
664 }
665 return NULL;
666}
667
668/*
669 * Search for last occurrence of "c" in "string".
670 * Version of strrchr() that handles unsigned char strings with characters from
671 * 128 to 255 correctly. It also doesn't return a pointer to the NUL at the
672 * end of the string.
673 * Return NULL if not found.
674 * Does not handle multi-byte char for "c"!
675 */
676 char_u *
677vim_strrchr(char_u *string, int c)
678{
679 char_u *retval = NULL;
680 char_u *p = string;
681
682 while (*p)
683 {
684 if (*p == c)
685 retval = p;
686 MB_PTR_ADV(p);
687 }
688 return retval;
689}
690
691/*
692 * Vim's version of strpbrk(), in case it's missing.
693 * Don't generate a prototype for this, causes problems when it's not used.
694 */
695#ifndef PROTO
696# ifndef HAVE_STRPBRK
697# ifdef vim_strpbrk
698# undef vim_strpbrk
699# endif
700 char_u *
701vim_strpbrk(char_u *s, char_u *charset)
702{
703 while (*s)
704 {
705 if (vim_strchr(charset, *s) != NULL)
706 return s;
707 MB_PTR_ADV(s);
708 }
709 return NULL;
710}
711# endif
712#endif
713
714/*
715 * Sort an array of strings.
716 */
717static int sort_compare(const void *s1, const void *s2);
718
719 static int
720sort_compare(const void *s1, const void *s2)
721{
722 return STRCMP(*(char **)s1, *(char **)s2);
723}
724
725 void
726sort_strings(
727 char_u **files,
728 int count)
729{
730 qsort((void *)files, (size_t)count, sizeof(char_u *), sort_compare);
731}
732
733#if defined(FEAT_QUICKFIX) || defined(FEAT_SPELL) || defined(PROTO)
734/*
735 * Return TRUE if string "s" contains a non-ASCII character (128 or higher).
736 * When "s" is NULL FALSE is returned.
737 */
738 int
739has_non_ascii(char_u *s)
740{
741 char_u *p;
742
743 if (s != NULL)
744 for (p = s; *p != NUL; ++p)
745 if (*p >= 128)
746 return TRUE;
747 return FALSE;
748}
749#endif
750
751/*
752 * Concatenate two strings and return the result in allocated memory.
753 * Returns NULL when out of memory.
754 */
755 char_u *
756concat_str(char_u *str1, char_u *str2)
757{
758 char_u *dest;
759 size_t l = str1 == NULL ? 0 : STRLEN(str1);
760
761 dest = alloc(l + (str2 == NULL ? 0 : STRLEN(str2)) + 1L);
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000762 if (dest == NULL)
763 return NULL;
764 if (str1 == NULL)
765 *dest = NUL;
766 else
767 STRCPY(dest, str1);
768 if (str2 != NULL)
769 STRCPY(dest + l, str2);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200770 return dest;
771}
772
zeertzjq4dd266c2023-08-19 11:35:03 +0200773#if defined(FEAT_EVAL) || defined(FEAT_RIGHTLEFT) || defined(PROTO)
774/*
775 * Reverse text into allocated memory.
776 * Returns the allocated string, NULL when out of memory.
777 */
778 char_u *
779reverse_text(char_u *s)
780{
781 size_t len = STRLEN(s);
782 char_u *rev = alloc(len + 1);
783 if (rev == NULL)
784 return NULL;
785
786 for (size_t s_i = 0, rev_i = len; s_i < len; ++s_i)
787 {
788 if (has_mbyte)
789 {
790 int mb_len = (*mb_ptr2len)(s + s_i);
791 rev_i -= mb_len;
792 mch_memmove(rev + rev_i, s + s_i, mb_len);
793 s_i += mb_len - 1;
794 }
795 else
796 rev[--rev_i] = s[s_i];
797 }
798 rev[len] = NUL;
799 return rev;
800}
801#endif
802
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200803#if defined(FEAT_EVAL) || defined(PROTO)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200804/*
805 * Return string "str" in ' quotes, doubling ' characters.
806 * If "str" is NULL an empty string is assumed.
807 * If "function" is TRUE make it function('string').
808 */
809 char_u *
810string_quote(char_u *str, int function)
811{
812 unsigned len;
813 char_u *p, *r, *s;
814
815 len = (function ? 13 : 3);
816 if (str != NULL)
817 {
818 len += (unsigned)STRLEN(str);
819 for (p = str; *p != NUL; MB_PTR_ADV(p))
820 if (*p == '\'')
821 ++len;
822 }
823 s = r = alloc(len);
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000824 if (r == NULL)
825 return NULL;
826
827 if (function)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200828 {
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000829 STRCPY(r, "function('");
830 r += 10;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200831 }
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000832 else
833 *r++ = '\'';
834 if (str != NULL)
835 for (p = str; *p != NUL; )
836 {
837 if (*p == '\'')
838 *r++ = '\'';
839 MB_COPY_CHAR(p, r);
840 }
841 *r++ = '\'';
842 if (function)
843 *r++ = ')';
844 *r++ = NUL;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200845 return s;
846}
847
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000848/*
849 * Count the number of times "needle" occurs in string "haystack". Case is
850 * ignored if "ic" is TRUE.
851 */
852 long
853string_count(char_u *haystack, char_u *needle, int ic)
854{
855 long n = 0;
856 char_u *p = haystack;
857 char_u *next;
858
859 if (p == NULL || needle == NULL || *needle == NUL)
860 return 0;
861
862 if (ic)
863 {
864 size_t len = STRLEN(needle);
865
866 while (*p != NUL)
867 {
868 if (MB_STRNICMP(p, needle, len) == 0)
869 {
870 ++n;
871 p += len;
872 }
873 else
874 MB_PTR_ADV(p);
875 }
876 }
877 else
878 while ((next = (char_u *)strstr((char *)p, (char *)needle)) != NULL)
879 {
880 ++n;
881 p = next + STRLEN(needle);
882 }
883
884 return n;
885}
886
887/*
888 * Make a typval_T of the first character of "input" and store it in "output".
889 * Return OK or FAIL.
890 */
891 static int
892copy_first_char_to_tv(char_u *input, typval_T *output)
893{
894 char_u buf[MB_MAXBYTES + 1];
895 int len;
896
897 if (input == NULL || output == NULL)
898 return FAIL;
899
900 len = has_mbyte ? mb_ptr2len(input) : 1;
901 STRNCPY(buf, input, len);
902 buf[len] = NUL;
903 output->v_type = VAR_STRING;
904 output->vval.v_string = vim_strsave(buf);
905
906 return output->vval.v_string == NULL ? FAIL : OK;
907}
908
909/*
910 * Implementation of map() and filter() for a String. Apply "expr" to every
911 * character in string "str" and return the result in "rettv".
912 */
913 void
914string_filter_map(
915 char_u *str,
916 filtermap_T filtermap,
917 typval_T *expr,
918 typval_T *rettv)
919{
920 char_u *p;
921 typval_T tv;
922 garray_T ga;
923 int len = 0;
924 int idx = 0;
925 int rem;
Bram Moolenaar82418262022-09-28 16:16:15 +0100926 typval_T newtv;
927 funccall_T *fc;
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000928
929 rettv->v_type = VAR_STRING;
930 rettv->vval.v_string = NULL;
931
932 // set_vim_var_nr() doesn't set the type
933 set_vim_var_type(VV_KEY, VAR_NUMBER);
934
zeertzjqe7d49462023-04-16 20:53:55 +0100935 // Create one funccall_T for all eval_expr_typval() calls.
Bram Moolenaar82418262022-09-28 16:16:15 +0100936 fc = eval_expr_get_funccal(expr, &newtv);
937
Bram Moolenaar04935fb2022-01-08 16:19:22 +0000938 ga_init2(&ga, sizeof(char), 80);
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000939 for (p = str; *p != NUL; p += len)
940 {
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000941 if (copy_first_char_to_tv(p, &tv) == FAIL)
942 break;
943 len = (int)STRLEN(tv.vval.v_string);
944
Bram Moolenaardd7eff02022-05-06 11:02:05 +0100945 newtv.v_type = VAR_UNKNOWN;
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000946 set_vim_var_nr(VV_KEY, idx);
Bram Moolenaar82418262022-09-28 16:16:15 +0100947 if (filter_map_one(&tv, expr, filtermap, fc, &newtv, &rem) == FAIL
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000948 || did_emsg)
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000949 {
950 clear_tv(&newtv);
951 clear_tv(&tv);
952 break;
953 }
954 else if (filtermap != FILTERMAP_FILTER)
955 {
956 if (newtv.v_type != VAR_STRING)
957 {
958 clear_tv(&newtv);
959 clear_tv(&tv);
Bram Moolenaare70cec92022-01-01 14:25:55 +0000960 emsg(_(e_string_required));
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000961 break;
962 }
963 else
964 ga_concat(&ga, newtv.vval.v_string);
965 }
966 else if (!rem)
967 ga_concat(&ga, tv.vval.v_string);
968
969 clear_tv(&newtv);
970 clear_tv(&tv);
971
972 ++idx;
973 }
974 ga_append(&ga, NUL);
975 rettv->vval.v_string = ga.ga_data;
Bram Moolenaar82418262022-09-28 16:16:15 +0100976 if (fc != NULL)
977 remove_funccal();
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000978}
979
980/*
Bram Moolenaarf1c60d42022-09-22 17:07:00 +0100981 * Implementation of reduce() for String "argvars[0]" using the function "expr"
982 * starting with the optional initial value "argvars[2]" and return the result
983 * in "rettv".
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000984 */
985 void
986string_reduce(
987 typval_T *argvars,
Bram Moolenaarf1c60d42022-09-22 17:07:00 +0100988 typval_T *expr,
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000989 typval_T *rettv)
990{
991 char_u *p = tv_get_string(&argvars[0]);
992 int len;
993 typval_T argv[3];
994 int r;
995 int called_emsg_start = called_emsg;
Bram Moolenaar82418262022-09-28 16:16:15 +0100996 funccall_T *fc;
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000997
998 if (argvars[2].v_type == VAR_UNKNOWN)
999 {
1000 if (*p == NUL)
1001 {
Bram Moolenaare70cec92022-01-01 14:25:55 +00001002 semsg(_(e_reduce_of_an_empty_str_with_no_initial_value), "String");
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +00001003 return;
1004 }
1005 if (copy_first_char_to_tv(p, rettv) == FAIL)
1006 return;
1007 p += STRLEN(rettv->vval.v_string);
1008 }
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01001009 else if (check_for_string_arg(argvars, 2) == FAIL)
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +00001010 return;
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +00001011 else
1012 copy_tv(&argvars[2], rettv);
1013
zeertzjqe7d49462023-04-16 20:53:55 +01001014 // Create one funccall_T for all eval_expr_typval() calls.
Bram Moolenaar82418262022-09-28 16:16:15 +01001015 fc = eval_expr_get_funccal(expr, rettv);
1016
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +00001017 for ( ; *p != NUL; p += len)
1018 {
1019 argv[0] = *rettv;
1020 if (copy_first_char_to_tv(p, &argv[1]) == FAIL)
1021 break;
1022 len = (int)STRLEN(argv[1].vval.v_string);
Bram Moolenaarf1c60d42022-09-22 17:07:00 +01001023
zeertzjqad0c4422023-08-17 22:15:47 +02001024 r = eval_expr_typval(expr, TRUE, argv, 2, fc, rettv);
Bram Moolenaarf1c60d42022-09-22 17:07:00 +01001025
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +00001026 clear_tv(&argv[0]);
1027 clear_tv(&argv[1]);
1028 if (r == FAIL || called_emsg != called_emsg_start)
1029 return;
1030 }
Bram Moolenaar82418262022-09-28 16:16:15 +01001031
1032 if (fc != NULL)
1033 remove_funccal();
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +00001034}
1035
Bram Moolenaare4098452023-05-07 18:53:49 +01001036/*
1037 * Implementation of "byteidx()" and "byteidxcomp()" functions
1038 */
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001039 static void
Bram Moolenaare4098452023-05-07 18:53:49 +01001040byteidx_common(typval_T *argvars, typval_T *rettv, int comp UNUSED)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001041{
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001042 rettv->vval.v_number = -1;
1043
1044 if (in_vim9script()
1045 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan577922b2023-06-08 17:09:45 +01001046 || check_for_number_arg(argvars, 1) == FAIL
1047 || check_for_opt_bool_arg(argvars, 2) == FAIL))
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001048 return;
1049
Christian Brabandt67672ef2023-04-24 21:09:54 +01001050 char_u *str = tv_get_string_chk(&argvars[0]);
1051 varnumber_T idx = tv_get_number_chk(&argvars[1], NULL);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001052 if (str == NULL || idx < 0)
1053 return;
1054
Christian Brabandt67672ef2023-04-24 21:09:54 +01001055 varnumber_T utf16idx = FALSE;
1056 if (argvars[2].v_type != VAR_UNKNOWN)
1057 {
zeertzjq8cf51372023-05-08 15:31:38 +01001058 int error = FALSE;
1059 utf16idx = tv_get_bool_chk(&argvars[2], &error);
1060 if (error)
1061 return;
Christian Brabandt67672ef2023-04-24 21:09:54 +01001062 if (utf16idx < 0 || utf16idx > 1)
1063 {
zeertzjq8cf51372023-05-08 15:31:38 +01001064 semsg(_(e_using_number_as_bool_nr), utf16idx);
Christian Brabandt67672ef2023-04-24 21:09:54 +01001065 return;
1066 }
1067 }
1068
1069 int (*ptr2len)(char_u *);
1070 if (enc_utf8 && comp)
1071 ptr2len = utf_ptr2len;
1072 else
1073 ptr2len = mb_ptr2len;
1074
1075 char_u *t = str;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001076 for ( ; idx > 0; idx--)
1077 {
1078 if (*t == NUL) // EOL reached
1079 return;
Christian Brabandt67672ef2023-04-24 21:09:54 +01001080 if (utf16idx)
1081 {
1082 int clen = ptr2len(t);
1083 int c = (clen > 1) ? utf_ptr2char(t) : *t;
1084 if (c > 0xFFFF)
1085 idx--;
1086 }
1087 if (idx > 0)
1088 t += ptr2len(t);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001089 }
1090 rettv->vval.v_number = (varnumber_T)(t - str);
1091}
1092
1093/*
1094 * "byteidx()" function
1095 */
1096 void
1097f_byteidx(typval_T *argvars, typval_T *rettv)
1098{
Bram Moolenaare4098452023-05-07 18:53:49 +01001099 byteidx_common(argvars, rettv, FALSE);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001100}
1101
1102/*
1103 * "byteidxcomp()" function
1104 */
1105 void
1106f_byteidxcomp(typval_T *argvars, typval_T *rettv)
1107{
Bram Moolenaare4098452023-05-07 18:53:49 +01001108 byteidx_common(argvars, rettv, TRUE);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001109}
1110
1111/*
1112 * "charidx()" function
1113 */
1114 void
1115f_charidx(typval_T *argvars, typval_T *rettv)
1116{
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001117 rettv->vval.v_number = -1;
1118
Christian Brabandt67672ef2023-04-24 21:09:54 +01001119 if (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001120 || check_for_number_arg(argvars, 1) == FAIL
Christian Brabandt67672ef2023-04-24 21:09:54 +01001121 || check_for_opt_bool_arg(argvars, 2) == FAIL
1122 || (argvars[2].v_type != VAR_UNKNOWN
1123 && check_for_opt_bool_arg(argvars, 3) == FAIL))
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001124 return;
1125
Christian Brabandt67672ef2023-04-24 21:09:54 +01001126 char_u *str = tv_get_string_chk(&argvars[0]);
1127 varnumber_T idx = tv_get_number_chk(&argvars[1], NULL);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001128 if (str == NULL || idx < 0)
1129 return;
1130
Christian Brabandt67672ef2023-04-24 21:09:54 +01001131 varnumber_T countcc = FALSE;
1132 varnumber_T utf16idx = FALSE;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001133 if (argvars[2].v_type != VAR_UNKNOWN)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001134 {
Christian Brabandt67672ef2023-04-24 21:09:54 +01001135 countcc = tv_get_bool(&argvars[2]);
1136 if (argvars[3].v_type != VAR_UNKNOWN)
1137 utf16idx = tv_get_bool(&argvars[3]);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001138 }
1139
Christian Brabandt67672ef2023-04-24 21:09:54 +01001140 int (*ptr2len)(char_u *);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001141 if (enc_utf8 && countcc)
1142 ptr2len = utf_ptr2len;
1143 else
1144 ptr2len = mb_ptr2len;
1145
Christian Brabandt67672ef2023-04-24 21:09:54 +01001146 char_u *p;
1147 int len;
1148 for (p = str, len = 0; utf16idx ? idx >= 0 : p <= str + idx; len++)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001149 {
1150 if (*p == NUL)
Yegappan Lakshmanan577922b2023-06-08 17:09:45 +01001151 {
1152 // If the index is exactly the number of bytes or utf-16 code units
1153 // in the string then return the length of the string in
1154 // characters.
1155 if (utf16idx ? (idx == 0) : (p == (str + idx)))
1156 rettv->vval.v_number = len;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001157 return;
Yegappan Lakshmanan577922b2023-06-08 17:09:45 +01001158 }
Christian Brabandt67672ef2023-04-24 21:09:54 +01001159 if (utf16idx)
1160 {
1161 idx--;
1162 int clen = ptr2len(p);
1163 int c = (clen > 1) ? utf_ptr2char(p) : *p;
1164 if (c > 0xFFFF)
1165 idx--;
1166 }
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001167 p += ptr2len(p);
1168 }
1169
1170 rettv->vval.v_number = len > 0 ? len - 1 : 0;
1171}
1172
1173/*
1174 * "str2list()" function
1175 */
1176 void
1177f_str2list(typval_T *argvars, typval_T *rettv)
1178{
1179 char_u *p;
1180 int utf8 = FALSE;
1181
1182 if (rettv_list_alloc(rettv) == FAIL)
1183 return;
1184
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001185 if (in_vim9script()
1186 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001187 || check_for_opt_bool_arg(argvars, 1) == FAIL))
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001188 return;
1189
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001190 if (argvars[1].v_type != VAR_UNKNOWN)
1191 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
1192
1193 p = tv_get_string(&argvars[0]);
1194
1195 if (has_mbyte || utf8)
1196 {
1197 int (*ptr2len)(char_u *);
1198 int (*ptr2char)(char_u *);
1199
1200 if (utf8 || enc_utf8)
1201 {
1202 ptr2len = utf_ptr2len;
1203 ptr2char = utf_ptr2char;
1204 }
1205 else
1206 {
1207 ptr2len = mb_ptr2len;
1208 ptr2char = mb_ptr2char;
1209 }
1210
1211 for ( ; *p != NUL; p += (*ptr2len)(p))
1212 list_append_number(rettv->vval.v_list, (*ptr2char)(p));
1213 }
1214 else
1215 for ( ; *p != NUL; ++p)
1216 list_append_number(rettv->vval.v_list, *p);
1217}
1218
1219/*
1220 * "str2nr()" function
1221 */
1222 void
1223f_str2nr(typval_T *argvars, typval_T *rettv)
1224{
1225 int base = 10;
1226 char_u *p;
1227 varnumber_T n;
1228 int what = 0;
1229 int isneg;
1230
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001231 if (in_vim9script()
1232 && (check_for_string_arg(argvars, 0) == FAIL
1233 || check_for_opt_number_arg(argvars, 1) == FAIL
1234 || (argvars[1].v_type != VAR_UNKNOWN
1235 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
1236 return;
1237
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001238 if (argvars[1].v_type != VAR_UNKNOWN)
1239 {
1240 base = (int)tv_get_number(&argvars[1]);
1241 if (base != 2 && base != 8 && base != 10 && base != 16)
1242 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00001243 emsg(_(e_invalid_argument));
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001244 return;
1245 }
1246 if (argvars[2].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[2]))
1247 what |= STR2NR_QUOTE;
1248 }
1249
1250 p = skipwhite(tv_get_string_strict(&argvars[0]));
1251 isneg = (*p == '-');
1252 if (*p == '+' || *p == '-')
1253 p = skipwhite(p + 1);
1254 switch (base)
1255 {
1256 case 2: what |= STR2NR_BIN + STR2NR_FORCE; break;
1257 case 8: what |= STR2NR_OCT + STR2NR_OOCT + STR2NR_FORCE; break;
1258 case 16: what |= STR2NR_HEX + STR2NR_FORCE; break;
1259 }
Bram Moolenaar5fb78c32023-03-04 20:47:39 +00001260 vim_str2nr(p, NULL, NULL, what, &n, NULL, 0, FALSE, NULL);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001261 // Text after the number is silently ignored.
1262 if (isneg)
1263 rettv->vval.v_number = -n;
1264 else
1265 rettv->vval.v_number = n;
1266
1267}
1268
1269/*
1270 * "strgetchar()" function
1271 */
1272 void
1273f_strgetchar(typval_T *argvars, typval_T *rettv)
1274{
1275 char_u *str;
1276 int len;
1277 int error = FALSE;
1278 int charidx;
1279 int byteidx = 0;
1280
1281 rettv->vval.v_number = -1;
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001282
1283 if (in_vim9script()
1284 && (check_for_string_arg(argvars, 0) == FAIL
1285 || check_for_number_arg(argvars, 1) == FAIL))
1286 return;
1287
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001288 str = tv_get_string_chk(&argvars[0]);
1289 if (str == NULL)
1290 return;
1291 len = (int)STRLEN(str);
1292 charidx = (int)tv_get_number_chk(&argvars[1], &error);
1293 if (error)
1294 return;
1295
1296 while (charidx >= 0 && byteidx < len)
1297 {
1298 if (charidx == 0)
1299 {
1300 rettv->vval.v_number = mb_ptr2char(str + byteidx);
1301 break;
1302 }
1303 --charidx;
1304 byteidx += MB_CPTR2LEN(str + byteidx);
1305 }
1306}
1307
1308/*
1309 * "stridx()" function
1310 */
1311 void
1312f_stridx(typval_T *argvars, typval_T *rettv)
1313{
1314 char_u buf[NUMBUFLEN];
1315 char_u *needle;
1316 char_u *haystack;
1317 char_u *save_haystack;
1318 char_u *pos;
1319 int start_idx;
1320
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001321 if (in_vim9script()
1322 && (check_for_string_arg(argvars, 0) == FAIL
1323 || check_for_string_arg(argvars, 1) == FAIL
1324 || check_for_opt_number_arg(argvars, 2) == FAIL))
1325 return;
1326
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001327 needle = tv_get_string_chk(&argvars[1]);
1328 save_haystack = haystack = tv_get_string_buf_chk(&argvars[0], buf);
1329 rettv->vval.v_number = -1;
1330 if (needle == NULL || haystack == NULL)
1331 return; // type error; errmsg already given
1332
1333 if (argvars[2].v_type != VAR_UNKNOWN)
1334 {
1335 int error = FALSE;
1336
1337 start_idx = (int)tv_get_number_chk(&argvars[2], &error);
1338 if (error || start_idx >= (int)STRLEN(haystack))
1339 return;
1340 if (start_idx >= 0)
1341 haystack += start_idx;
1342 }
1343
1344 pos = (char_u *)strstr((char *)haystack, (char *)needle);
1345 if (pos != NULL)
1346 rettv->vval.v_number = (varnumber_T)(pos - save_haystack);
1347}
1348
1349/*
1350 * "string()" function
1351 */
1352 void
1353f_string(typval_T *argvars, typval_T *rettv)
1354{
1355 char_u *tofree;
1356 char_u numbuf[NUMBUFLEN];
1357
1358 rettv->v_type = VAR_STRING;
1359 rettv->vval.v_string = tv2string(&argvars[0], &tofree, numbuf,
1360 get_copyID());
1361 // Make a copy if we have a value but it's not in allocated memory.
1362 if (rettv->vval.v_string != NULL && tofree == NULL)
1363 rettv->vval.v_string = vim_strsave(rettv->vval.v_string);
1364}
1365
1366/*
1367 * "strlen()" function
1368 */
1369 void
1370f_strlen(typval_T *argvars, typval_T *rettv)
1371{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001372 if (in_vim9script()
1373 && check_for_string_or_number_arg(argvars, 0) == FAIL)
1374 return;
1375
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001376 rettv->vval.v_number = (varnumber_T)(STRLEN(
1377 tv_get_string(&argvars[0])));
1378}
1379
1380 static void
1381strchar_common(typval_T *argvars, typval_T *rettv, int skipcc)
1382{
1383 char_u *s = tv_get_string(&argvars[0]);
1384 varnumber_T len = 0;
1385 int (*func_mb_ptr2char_adv)(char_u **pp);
1386
1387 func_mb_ptr2char_adv = skipcc ? mb_ptr2char_adv : mb_cptr2char_adv;
1388 while (*s != NUL)
1389 {
1390 func_mb_ptr2char_adv(&s);
1391 ++len;
1392 }
1393 rettv->vval.v_number = len;
1394}
1395
1396/*
1397 * "strcharlen()" function
1398 */
1399 void
1400f_strcharlen(typval_T *argvars, typval_T *rettv)
1401{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001402 if (in_vim9script()
1403 && check_for_string_or_number_arg(argvars, 0) == FAIL)
1404 return;
1405
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001406 strchar_common(argvars, rettv, TRUE);
1407}
1408
1409/*
1410 * "strchars()" function
1411 */
1412 void
1413f_strchars(typval_T *argvars, typval_T *rettv)
1414{
1415 varnumber_T skipcc = FALSE;
1416
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001417 if (in_vim9script()
1418 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001419 || check_for_opt_bool_arg(argvars, 1) == FAIL))
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001420 return;
1421
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001422 if (argvars[1].v_type != VAR_UNKNOWN)
Bram Moolenaare4098452023-05-07 18:53:49 +01001423 {
zeertzjq8cf51372023-05-08 15:31:38 +01001424 int error = FALSE;
1425 skipcc = tv_get_bool_chk(&argvars[1], &error);
1426 if (error)
1427 return;
1428 if (skipcc < 0 || skipcc > 1)
1429 {
Bram Moolenaare4098452023-05-07 18:53:49 +01001430 semsg(_(e_using_number_as_bool_nr), skipcc);
zeertzjq8cf51372023-05-08 15:31:38 +01001431 return;
1432 }
Bram Moolenaare4098452023-05-07 18:53:49 +01001433 }
zeertzjq8cf51372023-05-08 15:31:38 +01001434
1435 strchar_common(argvars, rettv, skipcc);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001436}
1437
1438/*
Christian Brabandt67672ef2023-04-24 21:09:54 +01001439 * "strutf16len()" function
1440 */
1441 void
1442f_strutf16len(typval_T *argvars, typval_T *rettv)
1443{
1444 rettv->vval.v_number = -1;
1445
1446 if (check_for_string_arg(argvars, 0) == FAIL
1447 || check_for_opt_bool_arg(argvars, 1) == FAIL)
1448 return;
1449
1450 varnumber_T countcc = FALSE;
1451 if (argvars[1].v_type != VAR_UNKNOWN)
1452 countcc = tv_get_bool(&argvars[1]);
1453
1454 char_u *s = tv_get_string(&argvars[0]);
1455 varnumber_T len = 0;
1456 int (*func_mb_ptr2char_adv)(char_u **pp);
1457 int ch;
1458
1459 func_mb_ptr2char_adv = countcc ? mb_cptr2char_adv : mb_ptr2char_adv;
1460 while (*s != NUL)
1461 {
1462 ch = func_mb_ptr2char_adv(&s);
1463 if (ch > 0xFFFF)
1464 ++len;
1465 ++len;
1466 }
1467 rettv->vval.v_number = len;
1468}
1469
1470/*
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001471 * "strdisplaywidth()" function
1472 */
1473 void
1474f_strdisplaywidth(typval_T *argvars, typval_T *rettv)
1475{
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001476 char_u *s;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001477 int col = 0;
1478
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001479 rettv->vval.v_number = -1;
1480
1481 if (in_vim9script()
1482 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001483 || check_for_opt_number_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001484 return;
1485
1486 s = tv_get_string(&argvars[0]);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001487 if (argvars[1].v_type != VAR_UNKNOWN)
1488 col = (int)tv_get_number(&argvars[1]);
1489
1490 rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s) - col);
1491}
1492
1493/*
1494 * "strwidth()" function
1495 */
1496 void
1497f_strwidth(typval_T *argvars, typval_T *rettv)
1498{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001499 char_u *s;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001500
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001501 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
1502 return;
1503
1504 s = tv_get_string_strict(&argvars[0]);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001505 rettv->vval.v_number = (varnumber_T)(mb_string2cells(s, -1));
1506}
1507
1508/*
1509 * "strcharpart()" function
1510 */
1511 void
1512f_strcharpart(typval_T *argvars, typval_T *rettv)
1513{
1514 char_u *p;
1515 int nchar;
1516 int nbyte = 0;
1517 int charlen;
1518 int skipcc = FALSE;
1519 int len = 0;
1520 int slen;
1521 int error = FALSE;
1522
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001523 if (in_vim9script()
1524 && (check_for_string_arg(argvars, 0) == FAIL
1525 || check_for_number_arg(argvars, 1) == FAIL
1526 || check_for_opt_number_arg(argvars, 2) == FAIL
1527 || (argvars[2].v_type != VAR_UNKNOWN
1528 && check_for_opt_bool_arg(argvars, 3) == FAIL)))
1529 return;
1530
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001531 p = tv_get_string(&argvars[0]);
1532 slen = (int)STRLEN(p);
1533
1534 nchar = (int)tv_get_number_chk(&argvars[1], &error);
1535 if (!error)
1536 {
1537 if (argvars[2].v_type != VAR_UNKNOWN
1538 && argvars[3].v_type != VAR_UNKNOWN)
1539 {
zeertzjq8cf51372023-05-08 15:31:38 +01001540 skipcc = tv_get_bool_chk(&argvars[3], &error);
1541 if (error)
1542 return;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001543 if (skipcc < 0 || skipcc > 1)
1544 {
zeertzjq8cf51372023-05-08 15:31:38 +01001545 semsg(_(e_using_number_as_bool_nr), skipcc);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001546 return;
1547 }
1548 }
1549
1550 if (nchar > 0)
1551 while (nchar > 0 && nbyte < slen)
1552 {
1553 if (skipcc)
1554 nbyte += mb_ptr2len(p + nbyte);
1555 else
1556 nbyte += MB_CPTR2LEN(p + nbyte);
1557 --nchar;
1558 }
1559 else
1560 nbyte = nchar;
1561 if (argvars[2].v_type != VAR_UNKNOWN)
1562 {
1563 charlen = (int)tv_get_number(&argvars[2]);
1564 while (charlen > 0 && nbyte + len < slen)
1565 {
1566 int off = nbyte + len;
1567
1568 if (off < 0)
1569 len += 1;
1570 else
1571 {
1572 if (skipcc)
1573 len += mb_ptr2len(p + off);
1574 else
1575 len += MB_CPTR2LEN(p + off);
1576 }
1577 --charlen;
1578 }
1579 }
1580 else
1581 len = slen - nbyte; // default: all bytes that are available.
1582 }
1583
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02001584 // Only return the overlap between the specified part and the actual
1585 // string.
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001586 if (nbyte < 0)
1587 {
1588 len += nbyte;
1589 nbyte = 0;
1590 }
1591 else if (nbyte > slen)
1592 nbyte = slen;
1593 if (len < 0)
1594 len = 0;
1595 else if (nbyte + len > slen)
1596 len = slen - nbyte;
1597
1598 rettv->v_type = VAR_STRING;
1599 rettv->vval.v_string = vim_strnsave(p + nbyte, len);
1600}
1601
1602/*
1603 * "strpart()" function
1604 */
1605 void
1606f_strpart(typval_T *argvars, typval_T *rettv)
1607{
1608 char_u *p;
1609 int n;
1610 int len;
1611 int slen;
1612 int error = FALSE;
1613
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001614 if (in_vim9script()
1615 && (check_for_string_arg(argvars, 0) == FAIL
1616 || check_for_number_arg(argvars, 1) == FAIL
1617 || check_for_opt_number_arg(argvars, 2) == FAIL
1618 || (argvars[2].v_type != VAR_UNKNOWN
1619 && check_for_opt_bool_arg(argvars, 3) == FAIL)))
1620 return;
1621
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001622 p = tv_get_string(&argvars[0]);
1623 slen = (int)STRLEN(p);
1624
1625 n = (int)tv_get_number_chk(&argvars[1], &error);
1626 if (error)
1627 len = 0;
1628 else if (argvars[2].v_type != VAR_UNKNOWN)
1629 len = (int)tv_get_number(&argvars[2]);
1630 else
1631 len = slen - n; // default len: all bytes that are available.
1632
1633 // Only return the overlap between the specified part and the actual
1634 // string.
1635 if (n < 0)
1636 {
1637 len += n;
1638 n = 0;
1639 }
1640 else if (n > slen)
1641 n = slen;
1642 if (len < 0)
1643 len = 0;
1644 else if (n + len > slen)
1645 len = slen - n;
1646
1647 if (argvars[2].v_type != VAR_UNKNOWN && argvars[3].v_type != VAR_UNKNOWN)
1648 {
1649 int off;
1650
1651 // length in characters
1652 for (off = n; off < slen && len > 0; --len)
1653 off += mb_ptr2len(p + off);
1654 len = off - n;
1655 }
1656
1657 rettv->v_type = VAR_STRING;
1658 rettv->vval.v_string = vim_strnsave(p + n, len);
1659}
1660
1661/*
1662 * "strridx()" function
1663 */
1664 void
1665f_strridx(typval_T *argvars, typval_T *rettv)
1666{
1667 char_u buf[NUMBUFLEN];
1668 char_u *needle;
1669 char_u *haystack;
1670 char_u *rest;
1671 char_u *lastmatch = NULL;
1672 int haystack_len, end_idx;
1673
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001674 if (in_vim9script()
1675 && (check_for_string_arg(argvars, 0) == FAIL
1676 || check_for_string_arg(argvars, 1) == FAIL
1677 || check_for_opt_number_arg(argvars, 2) == FAIL))
1678 return;
1679
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001680 needle = tv_get_string_chk(&argvars[1]);
1681 haystack = tv_get_string_buf_chk(&argvars[0], buf);
1682
1683 rettv->vval.v_number = -1;
1684 if (needle == NULL || haystack == NULL)
1685 return; // type error; errmsg already given
1686
1687 haystack_len = (int)STRLEN(haystack);
1688 if (argvars[2].v_type != VAR_UNKNOWN)
1689 {
1690 // Third argument: upper limit for index
1691 end_idx = (int)tv_get_number_chk(&argvars[2], NULL);
1692 if (end_idx < 0)
1693 return; // can never find a match
1694 }
1695 else
1696 end_idx = haystack_len;
1697
1698 if (*needle == NUL)
1699 {
1700 // Empty string matches past the end.
1701 lastmatch = haystack + end_idx;
1702 }
1703 else
1704 {
1705 for (rest = haystack; *rest != '\0'; ++rest)
1706 {
1707 rest = (char_u *)strstr((char *)rest, (char *)needle);
1708 if (rest == NULL || rest > haystack + end_idx)
1709 break;
1710 lastmatch = rest;
1711 }
1712 }
1713
1714 if (lastmatch == NULL)
1715 rettv->vval.v_number = -1;
1716 else
1717 rettv->vval.v_number = (varnumber_T)(lastmatch - haystack);
1718}
1719
1720/*
1721 * "strtrans()" function
1722 */
1723 void
1724f_strtrans(typval_T *argvars, typval_T *rettv)
1725{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001726 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
1727 return;
1728
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001729 rettv->v_type = VAR_STRING;
1730 rettv->vval.v_string = transstr(tv_get_string(&argvars[0]));
1731}
1732
Christian Brabandt67672ef2023-04-24 21:09:54 +01001733
1734/*
Christian Brabandt67672ef2023-04-24 21:09:54 +01001735 * "utf16idx()" function
Yegappan Lakshmanan95707032023-06-14 13:10:15 +01001736 *
1737 * Converts a byte or character offset in a string to the corresponding UTF-16
1738 * code unit offset.
Christian Brabandt67672ef2023-04-24 21:09:54 +01001739 */
1740 void
1741f_utf16idx(typval_T *argvars, typval_T *rettv)
1742{
1743 rettv->vval.v_number = -1;
1744
1745 if (check_for_string_arg(argvars, 0) == FAIL
1746 || check_for_opt_number_arg(argvars, 1) == FAIL
1747 || check_for_opt_bool_arg(argvars, 2) == FAIL
1748 || (argvars[2].v_type != VAR_UNKNOWN
1749 && check_for_opt_bool_arg(argvars, 3) == FAIL))
1750 return;
1751
1752 char_u *str = tv_get_string_chk(&argvars[0]);
1753 varnumber_T idx = tv_get_number_chk(&argvars[1], NULL);
1754 if (str == NULL || idx < 0)
1755 return;
1756
1757 varnumber_T countcc = FALSE;
1758 varnumber_T charidx = FALSE;
1759 if (argvars[2].v_type != VAR_UNKNOWN)
1760 {
1761 countcc = tv_get_bool(&argvars[2]);
1762 if (argvars[3].v_type != VAR_UNKNOWN)
1763 charidx = tv_get_bool(&argvars[3]);
1764 }
1765
1766 int (*ptr2len)(char_u *);
1767 if (enc_utf8 && countcc)
1768 ptr2len = utf_ptr2len;
1769 else
1770 ptr2len = mb_ptr2len;
1771
1772 char_u *p;
1773 int len;
Yegappan Lakshmanan95707032023-06-14 13:10:15 +01001774 int utf16idx = 0;
Christian Brabandt67672ef2023-04-24 21:09:54 +01001775 for (p = str, len = 0; charidx ? idx >= 0 : p <= str + idx; len++)
1776 {
1777 if (*p == NUL)
Yegappan Lakshmanan577922b2023-06-08 17:09:45 +01001778 {
1779 // If the index is exactly the number of bytes or characters in the
1780 // string then return the length of the string in utf-16 code
1781 // units.
1782 if (charidx ? (idx == 0) : (p == (str + idx)))
1783 rettv->vval.v_number = len;
Christian Brabandt67672ef2023-04-24 21:09:54 +01001784 return;
Yegappan Lakshmanan577922b2023-06-08 17:09:45 +01001785 }
Yegappan Lakshmanan95707032023-06-14 13:10:15 +01001786 utf16idx = len;
Christian Brabandt67672ef2023-04-24 21:09:54 +01001787 int clen = ptr2len(p);
1788 int c = (clen > 1) ? utf_ptr2char(p) : *p;
1789 if (c > 0xFFFF)
1790 len++;
1791 p += ptr2len(p);
1792 if (charidx)
1793 idx--;
1794 }
1795
Yegappan Lakshmanan95707032023-06-14 13:10:15 +01001796 rettv->vval.v_number = utf16idx;
Christian Brabandt67672ef2023-04-24 21:09:54 +01001797}
1798
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001799/*
1800 * "tolower(string)" function
1801 */
1802 void
1803f_tolower(typval_T *argvars, typval_T *rettv)
1804{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001805 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
1806 return;
1807
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001808 rettv->v_type = VAR_STRING;
1809 rettv->vval.v_string = strlow_save(tv_get_string(&argvars[0]));
1810}
1811
1812/*
1813 * "toupper(string)" function
1814 */
1815 void
1816f_toupper(typval_T *argvars, typval_T *rettv)
1817{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001818 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
1819 return;
1820
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001821 rettv->v_type = VAR_STRING;
1822 rettv->vval.v_string = strup_save(tv_get_string(&argvars[0]));
1823}
1824
1825/*
1826 * "tr(string, fromstr, tostr)" function
1827 */
1828 void
1829f_tr(typval_T *argvars, typval_T *rettv)
1830{
1831 char_u *in_str;
1832 char_u *fromstr;
1833 char_u *tostr;
1834 char_u *p;
1835 int inlen;
1836 int fromlen;
1837 int tolen;
1838 int idx;
1839 char_u *cpstr;
1840 int cplen;
1841 int first = TRUE;
1842 char_u buf[NUMBUFLEN];
1843 char_u buf2[NUMBUFLEN];
1844 garray_T ga;
1845
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001846 if (in_vim9script()
1847 && (check_for_string_arg(argvars, 0) == FAIL
1848 || check_for_string_arg(argvars, 1) == FAIL
1849 || check_for_string_arg(argvars, 2) == FAIL))
1850 return;
1851
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001852 in_str = tv_get_string(&argvars[0]);
1853 fromstr = tv_get_string_buf_chk(&argvars[1], buf);
1854 tostr = tv_get_string_buf_chk(&argvars[2], buf2);
1855
1856 // Default return value: empty string.
1857 rettv->v_type = VAR_STRING;
1858 rettv->vval.v_string = NULL;
1859 if (fromstr == NULL || tostr == NULL)
1860 return; // type error; errmsg already given
Bram Moolenaar04935fb2022-01-08 16:19:22 +00001861 ga_init2(&ga, sizeof(char), 80);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001862
1863 if (!has_mbyte)
1864 // not multi-byte: fromstr and tostr must be the same length
1865 if (STRLEN(fromstr) != STRLEN(tostr))
1866 {
1867error:
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00001868 semsg(_(e_invalid_argument_str), fromstr);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001869 ga_clear(&ga);
1870 return;
1871 }
1872
1873 // fromstr and tostr have to contain the same number of chars
1874 while (*in_str != NUL)
1875 {
1876 if (has_mbyte)
1877 {
1878 inlen = (*mb_ptr2len)(in_str);
1879 cpstr = in_str;
1880 cplen = inlen;
1881 idx = 0;
1882 for (p = fromstr; *p != NUL; p += fromlen)
1883 {
1884 fromlen = (*mb_ptr2len)(p);
1885 if (fromlen == inlen && STRNCMP(in_str, p, inlen) == 0)
1886 {
1887 for (p = tostr; *p != NUL; p += tolen)
1888 {
1889 tolen = (*mb_ptr2len)(p);
1890 if (idx-- == 0)
1891 {
1892 cplen = tolen;
1893 cpstr = p;
1894 break;
1895 }
1896 }
1897 if (*p == NUL) // tostr is shorter than fromstr
1898 goto error;
1899 break;
1900 }
1901 ++idx;
1902 }
1903
1904 if (first && cpstr == in_str)
1905 {
1906 // Check that fromstr and tostr have the same number of
1907 // (multi-byte) characters. Done only once when a character
1908 // of in_str doesn't appear in fromstr.
1909 first = FALSE;
1910 for (p = tostr; *p != NUL; p += tolen)
1911 {
1912 tolen = (*mb_ptr2len)(p);
1913 --idx;
1914 }
1915 if (idx != 0)
1916 goto error;
1917 }
1918
1919 (void)ga_grow(&ga, cplen);
1920 mch_memmove((char *)ga.ga_data + ga.ga_len, cpstr, (size_t)cplen);
1921 ga.ga_len += cplen;
1922
1923 in_str += inlen;
1924 }
1925 else
1926 {
1927 // When not using multi-byte chars we can do it faster.
1928 p = vim_strchr(fromstr, *in_str);
1929 if (p != NULL)
1930 ga_append(&ga, tostr[p - fromstr]);
1931 else
1932 ga_append(&ga, *in_str);
1933 ++in_str;
1934 }
1935 }
1936
1937 // add a terminating NUL
1938 (void)ga_grow(&ga, 1);
1939 ga_append(&ga, NUL);
1940
1941 rettv->vval.v_string = ga.ga_data;
1942}
1943
1944/*
1945 * "trim({expr})" function
1946 */
1947 void
1948f_trim(typval_T *argvars, typval_T *rettv)
1949{
1950 char_u buf1[NUMBUFLEN];
1951 char_u buf2[NUMBUFLEN];
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001952 char_u *head;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001953 char_u *mask = NULL;
1954 char_u *tail;
1955 char_u *prev;
1956 char_u *p;
1957 int c1;
1958 int dir = 0;
1959
1960 rettv->v_type = VAR_STRING;
1961 rettv->vval.v_string = NULL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001962
1963 if (in_vim9script()
1964 && (check_for_string_arg(argvars, 0) == FAIL
1965 || check_for_opt_string_arg(argvars, 1) == FAIL
1966 || (argvars[1].v_type != VAR_UNKNOWN
1967 && check_for_opt_number_arg(argvars, 2) == FAIL)))
1968 return;
1969
1970 head = tv_get_string_buf_chk(&argvars[0], buf1);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001971 if (head == NULL)
1972 return;
1973
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01001974 if (check_for_opt_string_arg(argvars, 1) == FAIL)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001975 return;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001976
1977 if (argvars[1].v_type == VAR_STRING)
1978 {
1979 mask = tv_get_string_buf_chk(&argvars[1], buf2);
1980
1981 if (argvars[2].v_type != VAR_UNKNOWN)
1982 {
1983 int error = 0;
1984
1985 // leading or trailing characters to trim
1986 dir = (int)tv_get_number_chk(&argvars[2], &error);
1987 if (error)
1988 return;
1989 if (dir < 0 || dir > 2)
1990 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00001991 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[2]));
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001992 return;
1993 }
1994 }
1995 }
1996
1997 if (dir == 0 || dir == 1)
1998 {
1999 // Trim leading characters
2000 while (*head != NUL)
2001 {
2002 c1 = PTR2CHAR(head);
2003 if (mask == NULL)
2004 {
2005 if (c1 > ' ' && c1 != 0xa0)
2006 break;
2007 }
2008 else
2009 {
2010 for (p = mask; *p != NUL; MB_PTR_ADV(p))
2011 if (c1 == PTR2CHAR(p))
2012 break;
2013 if (*p == NUL)
2014 break;
2015 }
2016 MB_PTR_ADV(head);
2017 }
2018 }
2019
2020 tail = head + STRLEN(head);
2021 if (dir == 0 || dir == 2)
2022 {
2023 // Trim trailing characters
2024 for (; tail > head; tail = prev)
2025 {
2026 prev = tail;
2027 MB_PTR_BACK(head, prev);
2028 c1 = PTR2CHAR(prev);
2029 if (mask == NULL)
2030 {
2031 if (c1 > ' ' && c1 != 0xa0)
2032 break;
2033 }
2034 else
2035 {
2036 for (p = mask; *p != NUL; MB_PTR_ADV(p))
2037 if (c1 == PTR2CHAR(p))
2038 break;
2039 if (*p == NUL)
2040 break;
2041 }
2042 }
2043 }
2044 rettv->vval.v_string = vim_strnsave(head, tail - head);
2045}
2046
Bram Moolenaar677658a2022-01-05 16:09:06 +00002047static char *e_printf = N_(e_insufficient_arguments_for_printf);
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002048
2049/*
2050 * Get number argument from "idxp" entry in "tvs". First entry is 1.
2051 */
2052 static varnumber_T
2053tv_nr(typval_T *tvs, int *idxp)
2054{
2055 int idx = *idxp - 1;
2056 varnumber_T n = 0;
2057 int err = FALSE;
2058
2059 if (tvs[idx].v_type == VAR_UNKNOWN)
2060 emsg(_(e_printf));
2061 else
2062 {
2063 ++*idxp;
2064 n = tv_get_number_chk(&tvs[idx], &err);
2065 if (err)
2066 n = 0;
2067 }
2068 return n;
2069}
2070
2071/*
2072 * Get string argument from "idxp" entry in "tvs". First entry is 1.
2073 * If "tofree" is NULL tv_get_string_chk() is used. Some types (e.g. List)
2074 * are not converted to a string.
2075 * If "tofree" is not NULL echo_string() is used. All types are converted to
2076 * a string with the same format as ":echo". The caller must free "*tofree".
2077 * Returns NULL for an error.
2078 */
2079 static char *
2080tv_str(typval_T *tvs, int *idxp, char_u **tofree)
2081{
2082 int idx = *idxp - 1;
2083 char *s = NULL;
2084 static char_u numbuf[NUMBUFLEN];
2085
2086 if (tvs[idx].v_type == VAR_UNKNOWN)
2087 emsg(_(e_printf));
2088 else
2089 {
2090 ++*idxp;
2091 if (tofree != NULL)
2092 s = (char *)echo_string(&tvs[idx], tofree, numbuf, get_copyID());
2093 else
2094 s = (char *)tv_get_string_chk(&tvs[idx]);
2095 }
2096 return s;
2097}
2098
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002099/*
2100 * Get float argument from "idxp" entry in "tvs". First entry is 1.
2101 */
2102 static double
2103tv_float(typval_T *tvs, int *idxp)
2104{
2105 int idx = *idxp - 1;
2106 double f = 0;
2107
2108 if (tvs[idx].v_type == VAR_UNKNOWN)
2109 emsg(_(e_printf));
2110 else
2111 {
2112 ++*idxp;
2113 if (tvs[idx].v_type == VAR_FLOAT)
2114 f = tvs[idx].vval.v_float;
2115 else if (tvs[idx].v_type == VAR_NUMBER)
2116 f = (double)tvs[idx].vval.v_number;
2117 else
Bram Moolenaar9d00e4a2022-01-05 17:49:15 +00002118 emsg(_(e_expected_float_argument_for_printf));
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002119 }
2120 return f;
2121}
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +00002122
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002123#endif
2124
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002125/*
2126 * Return the representation of infinity for printf() function:
2127 * "-inf", "inf", "+inf", " inf", "-INF", "INF", "+INF" or " INF".
2128 */
2129 static const char *
2130infinity_str(int positive,
2131 char fmt_spec,
2132 int force_sign,
2133 int space_for_positive)
2134{
2135 static const char *table[] =
2136 {
2137 "-inf", "inf", "+inf", " inf",
2138 "-INF", "INF", "+INF", " INF"
2139 };
2140 int idx = positive * (1 + force_sign + force_sign * space_for_positive);
2141
2142 if (ASCII_ISUPPER(fmt_spec))
2143 idx += 4;
2144 return table[idx];
2145}
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002146
2147/*
2148 * This code was included to provide a portable vsnprintf() and snprintf().
2149 * Some systems may provide their own, but we always use this one for
2150 * consistency.
2151 *
2152 * This code is based on snprintf.c - a portable implementation of snprintf
2153 * by Mark Martinec <mark.martinec@ijs.si>, Version 2.2, 2000-10-06.
2154 * Included with permission. It was heavily modified to fit in Vim.
2155 * The original code, including useful comments, can be found here:
2156 * http://www.ijs.si/software/snprintf/
2157 *
2158 * This snprintf() only supports the following conversion specifiers:
2159 * s, c, d, u, o, x, X, p (and synonyms: i, D, U, O - see below)
2160 * with flags: '-', '+', ' ', '0' and '#'.
2161 * An asterisk is supported for field width as well as precision.
2162 *
2163 * Limited support for floating point was added: 'f', 'F', 'e', 'E', 'g', 'G'.
2164 *
2165 * Length modifiers 'h' (short int) and 'l' (long int) and 'll' (long long int)
2166 * are supported. NOTE: for 'll' the argument is varnumber_T or uvarnumber_T.
2167 *
2168 * The locale is not used, the string is used as a byte string. This is only
2169 * relevant for double-byte encodings where the second byte may be '%'.
2170 *
2171 * It is permitted for "str_m" to be zero, and it is permitted to specify NULL
2172 * pointer for resulting string argument if "str_m" is zero (as per ISO C99).
2173 *
2174 * The return value is the number of characters which would be generated
2175 * for the given input, excluding the trailing NUL. If this value
2176 * is greater or equal to "str_m", not all characters from the result
2177 * have been stored in str, output bytes beyond the ("str_m"-1) -th character
2178 * are discarded. If "str_m" is greater than zero it is guaranteed
2179 * the resulting string will be NUL-terminated.
2180 */
2181
2182/*
2183 * When va_list is not supported we only define vim_snprintf().
2184 *
2185 * vim_vsnprintf_typval() can be invoked with either "va_list" or a list of
2186 * "typval_T". When the latter is not used it must be NULL.
2187 */
2188
2189// When generating prototypes all of this is skipped, cproto doesn't
2190// understand this.
2191#ifndef PROTO
2192
2193// Like vim_vsnprintf() but append to the string.
2194 int
2195vim_snprintf_add(char *str, size_t str_m, const char *fmt, ...)
2196{
2197 va_list ap;
2198 int str_l;
2199 size_t len = STRLEN(str);
2200 size_t space;
2201
2202 if (str_m <= len)
2203 space = 0;
2204 else
2205 space = str_m - len;
2206 va_start(ap, fmt);
2207 str_l = vim_vsnprintf(str + len, space, fmt, ap);
2208 va_end(ap);
2209 return str_l;
2210}
2211
2212 int
2213vim_snprintf(char *str, size_t str_m, const char *fmt, ...)
2214{
2215 va_list ap;
2216 int str_l;
2217
2218 va_start(ap, fmt);
2219 str_l = vim_vsnprintf(str, str_m, fmt, ap);
2220 va_end(ap);
2221 return str_l;
2222}
2223
2224 int
2225vim_vsnprintf(
2226 char *str,
2227 size_t str_m,
2228 const char *fmt,
2229 va_list ap)
2230{
2231 return vim_vsnprintf_typval(str, str_m, fmt, ap, NULL);
2232}
2233
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002234enum
2235{
2236 TYPE_UNKNOWN = -1,
2237 TYPE_INT,
2238 TYPE_LONGINT,
2239 TYPE_LONGLONGINT,
2240 TYPE_UNSIGNEDINT,
2241 TYPE_UNSIGNEDLONGINT,
2242 TYPE_UNSIGNEDLONGLONGINT,
2243 TYPE_POINTER,
2244 TYPE_PERCENT,
2245 TYPE_CHAR,
2246 TYPE_STRING,
2247 TYPE_FLOAT
2248};
2249
2250/* Types that can be used in a format string
2251 */
zeertzjq7772c932023-08-15 22:48:40 +02002252 static int
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002253format_typeof(
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02002254 const char *type)
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002255{
2256 // allowed values: \0, h, l, L
2257 char length_modifier = '\0';
2258
2259 // current conversion specifier character
2260 char fmt_spec = '\0';
2261
2262 // parse 'h', 'l' and 'll' length modifiers
2263 if (*type == 'h' || *type == 'l')
2264 {
2265 length_modifier = *type;
2266 type++;
2267 if (length_modifier == 'l' && *type == 'l')
2268 {
2269 // double l = __int64 / varnumber_T
2270 length_modifier = 'L';
2271 type++;
2272 }
2273 }
2274 fmt_spec = *type;
2275
2276 // common synonyms:
2277 switch (fmt_spec)
2278 {
2279 case 'i': fmt_spec = 'd'; break;
2280 case '*': fmt_spec = 'd'; length_modifier = 'h'; break;
2281 case 'D': fmt_spec = 'd'; length_modifier = 'l'; break;
2282 case 'U': fmt_spec = 'u'; length_modifier = 'l'; break;
2283 case 'O': fmt_spec = 'o'; length_modifier = 'l'; break;
2284 default: break;
2285 }
2286
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002287 // get parameter value, do initial processing
2288 switch (fmt_spec)
2289 {
2290 // '%' and 'c' behave similar to 's' regarding flags and field
2291 // widths
2292 case '%':
2293 return TYPE_PERCENT;
2294
2295 case 'c':
2296 return TYPE_CHAR;
2297
2298 case 's':
2299 case 'S':
2300 return TYPE_STRING;
2301
2302 case 'd': case 'u':
2303 case 'b': case 'B':
2304 case 'o':
2305 case 'x': case 'X':
2306 case 'p':
2307 {
2308 // NOTE: the u, b, o, x, X and p conversion specifiers
2309 // imply the value is unsigned; d implies a signed
2310 // value
2311
2312 // 0 if numeric argument is zero (or if pointer is
2313 // NULL for 'p'), +1 if greater than zero (or nonzero
2314 // for unsigned arguments), -1 if negative (unsigned
2315 // argument is never negative)
2316
2317 if (fmt_spec == 'p')
2318 return TYPE_POINTER;
2319 else if (fmt_spec == 'b' || fmt_spec == 'B')
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02002320 return TYPE_UNSIGNEDLONGLONGINT;
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002321 else if (fmt_spec == 'd')
2322 {
2323 // signed
2324 switch (length_modifier)
2325 {
2326 case '\0':
2327 case 'h':
2328 // char and short arguments are passed as int.
2329 return TYPE_INT;
2330 case 'l':
2331 return TYPE_LONGINT;
2332 case 'L':
2333 return TYPE_LONGLONGINT;
2334 }
2335 }
2336 else
2337 {
2338 // unsigned
2339 switch (length_modifier)
2340 {
2341 case '\0':
2342 case 'h':
2343 return TYPE_UNSIGNEDINT;
2344 case 'l':
2345 return TYPE_UNSIGNEDLONGINT;
2346 case 'L':
2347 return TYPE_UNSIGNEDLONGLONGINT;
2348 }
2349 }
2350 }
2351 break;
2352
2353 case 'f':
2354 case 'F':
2355 case 'e':
2356 case 'E':
2357 case 'g':
2358 case 'G':
2359 return TYPE_FLOAT;
2360 }
2361
2362 return TYPE_UNKNOWN;
2363}
2364
zeertzjq7772c932023-08-15 22:48:40 +02002365 static char *
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002366format_typename(
2367 const char *type)
2368{
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02002369 switch (format_typeof(type))
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002370 {
2371 case TYPE_INT:
2372 return _(typename_int);
2373
2374 case TYPE_LONGINT:
2375 return _(typename_longint);
2376
2377 case TYPE_LONGLONGINT:
2378 return _(typename_longlongint);
2379
2380 case TYPE_UNSIGNEDINT:
2381 return _(typename_unsignedint);
2382
2383 case TYPE_UNSIGNEDLONGINT:
2384 return _(typename_unsignedlongint);
2385
2386 case TYPE_UNSIGNEDLONGLONGINT:
2387 return _(typename_unsignedlonglongint);
2388
2389 case TYPE_POINTER:
2390 return _(typename_pointer);
2391
2392 case TYPE_PERCENT:
2393 return _(typename_percent);
2394
2395 case TYPE_CHAR:
2396 return _(typename_char);
2397
2398 case TYPE_STRING:
2399 return _(typename_string);
2400
2401 case TYPE_FLOAT:
2402 return _(typename_float);
2403 }
2404
2405 return _(typename_unknown);
2406}
2407
zeertzjq7772c932023-08-15 22:48:40 +02002408 static int
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002409adjust_types(
2410 const char ***ap_types,
2411 int arg,
2412 int *num_posarg,
2413 const char *type)
2414{
2415 if (*ap_types == NULL || *num_posarg < arg)
2416 {
2417 int idx;
2418 const char **new_types;
2419
2420 if (*ap_types == NULL)
2421 new_types = ALLOC_CLEAR_MULT(const char *, arg);
2422 else
K.Takata4c215ec2023-08-26 18:05:08 +02002423 new_types = vim_realloc((char **)*ap_types,
2424 arg * sizeof(const char *));
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002425
2426 if (new_types == NULL)
2427 return FAIL;
2428
2429 for (idx = *num_posarg; idx < arg; ++idx)
2430 new_types[idx] = NULL;
2431
2432 *ap_types = new_types;
2433 *num_posarg = arg;
2434 }
2435
2436 if ((*ap_types)[arg - 1] != NULL)
2437 {
2438 if ((*ap_types)[arg - 1][0] == '*' || type[0] == '*')
2439 {
2440 const char *pt = type;
2441 if (pt[0] == '*')
2442 pt = (*ap_types)[arg - 1];
2443
2444 if (pt[0] != '*')
2445 {
2446 switch (pt[0])
2447 {
2448 case 'd': case 'i': break;
2449 default:
2450 semsg(_(e_positional_num_field_spec_reused_str_str), arg, format_typename((*ap_types)[arg - 1]), format_typename(type));
2451 return FAIL;
2452 }
2453 }
2454 }
2455 else
2456 {
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02002457 if (format_typeof(type) != format_typeof((*ap_types)[arg - 1]))
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002458 {
2459 semsg(_( e_positional_arg_num_type_inconsistent_str_str), arg, format_typename(type), format_typename((*ap_types)[arg - 1]));
2460 return FAIL;
2461 }
2462 }
2463 }
2464
2465 (*ap_types)[arg - 1] = type;
2466
2467 return OK;
2468}
2469
zeertzjq7772c932023-08-15 22:48:40 +02002470 static int
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002471parse_fmt_types(
2472 const char ***ap_types,
2473 int *num_posarg,
2474 const char *fmt,
2475 typval_T *tvs UNUSED
2476 )
2477{
2478 const char *p = fmt;
2479 const char *arg = NULL;
2480
2481 int any_pos = 0;
2482 int any_arg = 0;
2483 int arg_idx;
2484
2485#define CHECK_POS_ARG do { \
2486 if (any_pos && any_arg) \
2487 { \
2488 semsg(_( e_cannot_mix_positional_and_non_positional_str), fmt); \
2489 goto error; \
2490 } \
2491} while (0);
2492
2493 if (p == NULL)
2494 return OK;
2495
2496 while (*p != NUL)
2497 {
2498 if (*p != '%')
2499 {
2500 char *q = strchr(p + 1, '%');
2501 size_t n = (q == NULL) ? STRLEN(p) : (size_t)(q - p);
2502
2503 p += n;
2504 }
2505 else
2506 {
2507 // allowed values: \0, h, l, L
2508 char length_modifier = '\0';
2509
2510 // variable for positional arg
2511 int pos_arg = -1;
2512 const char *ptype = NULL;
2513
2514 p++; // skip '%'
2515
2516 // First check to see if we find a positional
2517 // argument specifier
2518 ptype = p;
2519
2520 while (VIM_ISDIGIT(*ptype))
2521 ++ptype;
2522
2523 if (*ptype == '$')
2524 {
2525 if (*p == '0')
2526 {
2527 // 0 flag at the wrong place
2528 semsg(_( e_invalid_format_specifier_str), fmt);
2529 goto error;
2530 }
2531
2532 // Positional argument
2533 unsigned int uj = *p++ - '0';
2534
2535 while (VIM_ISDIGIT((int)(*p)))
2536 uj = 10 * uj + (unsigned int)(*p++ - '0');
2537 pos_arg = uj;
2538
2539 any_pos = 1;
2540 CHECK_POS_ARG;
2541
2542 ++p;
2543 }
2544
2545 // parse flags
2546 while (*p == '0' || *p == '-' || *p == '+' || *p == ' '
2547 || *p == '#' || *p == '\'')
2548 {
2549 switch (*p)
2550 {
2551 case '0': break;
2552 case '-': break;
2553 case '+': break;
2554 case ' ': // If both the ' ' and '+' flags appear, the ' '
2555 // flag should be ignored
2556 break;
2557 case '#': break;
2558 case '\'': break;
2559 }
2560 p++;
2561 }
2562 // If the '0' and '-' flags both appear, the '0' flag should be
2563 // ignored.
2564
2565 // parse field width
2566 if (*(arg = p) == '*')
2567 {
2568 p++;
2569
2570 if (VIM_ISDIGIT((int)(*p)))
2571 {
2572 // Positional argument field width
2573 unsigned int uj = *p++ - '0';
2574
2575 while (VIM_ISDIGIT((int)(*p)))
2576 uj = 10 * uj + (unsigned int)(*p++ - '0');
2577
2578 if (*p != '$')
2579 {
2580 semsg(_( e_invalid_format_specifier_str), fmt);
2581 goto error;
2582 }
2583 else
2584 {
2585 ++p;
2586 any_pos = 1;
2587 CHECK_POS_ARG;
2588
2589 if (adjust_types(ap_types, uj, num_posarg, arg) == FAIL)
2590 goto error;
2591 }
2592 }
2593 else
2594 {
2595 any_arg = 1;
2596 CHECK_POS_ARG;
2597 }
2598 }
2599 else if (VIM_ISDIGIT((int)(*(arg = p))))
2600 {
2601 // size_t could be wider than unsigned int; make sure we treat
2602 // argument like common implementations do
2603 unsigned int uj = *p++ - '0';
2604
2605 while (VIM_ISDIGIT((int)(*p)))
2606 uj = 10 * uj + (unsigned int)(*p++ - '0');
2607
2608 if (*p == '$')
2609 {
2610 semsg(_( e_invalid_format_specifier_str), fmt);
2611 goto error;
2612 }
2613 }
2614
2615 // parse precision
2616 if (*p == '.')
2617 {
2618 p++;
2619
2620 if (*(arg = p) == '*')
2621 {
2622 p++;
2623
2624 if (VIM_ISDIGIT((int)(*p)))
2625 {
2626 // Parse precision
2627 unsigned int uj = *p++ - '0';
2628
2629 while (VIM_ISDIGIT((int)(*p)))
2630 uj = 10 * uj + (unsigned int)(*p++ - '0');
2631
2632 if (*p == '$')
2633 {
2634 any_pos = 1;
2635 CHECK_POS_ARG;
2636
2637 ++p;
2638
2639 if (adjust_types(ap_types, uj, num_posarg, arg) == FAIL)
2640 goto error;
2641 }
2642 else
2643 {
2644 semsg(_( e_invalid_format_specifier_str), fmt);
2645 goto error;
2646 }
2647 }
2648 else
2649 {
2650 any_arg = 1;
2651 CHECK_POS_ARG;
2652 }
2653 }
2654 else if (VIM_ISDIGIT((int)(*(arg = p))))
2655 {
2656 // size_t could be wider than unsigned int; make sure we
2657 // treat argument like common implementations do
2658 unsigned int uj = *p++ - '0';
2659
2660 while (VIM_ISDIGIT((int)(*p)))
2661 uj = 10 * uj + (unsigned int)(*p++ - '0');
2662
2663 if (*p == '$')
2664 {
2665 semsg(_( e_invalid_format_specifier_str), fmt);
2666 goto error;
2667 }
2668 }
2669 }
2670
2671 if (pos_arg != -1)
2672 {
2673 any_pos = 1;
2674 CHECK_POS_ARG;
2675
2676 ptype = p;
2677 }
2678
2679 // parse 'h', 'l' and 'll' length modifiers
2680 if (*p == 'h' || *p == 'l')
2681 {
2682 length_modifier = *p;
2683 p++;
2684 if (length_modifier == 'l' && *p == 'l')
2685 {
2686 // double l = __int64 / varnumber_T
2687 length_modifier = 'L';
2688 p++;
2689 }
2690 }
2691
2692 switch (*p)
2693 {
2694 // Check for known format specifiers. % is special!
2695 case 'i':
2696 case '*':
2697 case 'd':
2698 case 'u':
2699 case 'o':
2700 case 'D':
2701 case 'U':
2702 case 'O':
2703 case 'x':
2704 case 'X':
2705 case 'b':
2706 case 'B':
2707 case 'c':
2708 case 's':
2709 case 'S':
2710 case 'p':
2711 case 'f':
2712 case 'F':
2713 case 'e':
2714 case 'E':
2715 case 'g':
2716 case 'G':
2717 if (pos_arg != -1)
2718 {
2719 if (adjust_types(ap_types, pos_arg, num_posarg, ptype) == FAIL)
2720 goto error;
2721 }
2722 else
2723 {
2724 any_arg = 1;
2725 CHECK_POS_ARG;
2726 }
2727 break;
2728
2729 default:
2730 if (pos_arg != -1)
2731 {
2732 semsg(_( e_cannot_mix_positional_and_non_positional_str), fmt);
2733 goto error;
2734 }
2735 }
2736
2737 if (*p != NUL)
2738 p++; // step over the just processed conversion specifier
2739 }
2740 }
2741
2742 for (arg_idx = 0; arg_idx < *num_posarg; ++arg_idx)
2743 {
2744 if ((*ap_types)[arg_idx] == NULL)
2745 {
2746 semsg(_(e_fmt_arg_nr_unused_str), arg_idx + 1, fmt);
2747 goto error;
2748 }
2749
2750# if defined(FEAT_EVAL)
2751 if (tvs != NULL && tvs[arg_idx].v_type == VAR_UNKNOWN)
2752 {
2753 semsg(_(e_positional_nr_out_of_bounds_str), arg_idx + 1, fmt);
2754 goto error;
2755 }
2756# endif
2757 }
2758
2759 return OK;
2760
2761error:
K.Takata4c215ec2023-08-26 18:05:08 +02002762 vim_free((char**)*ap_types);
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002763 *ap_types = NULL;
2764 *num_posarg = 0;
2765 return FAIL;
2766}
2767
zeertzjq7772c932023-08-15 22:48:40 +02002768 static void
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002769skip_to_arg(
2770 const char **ap_types,
2771 va_list ap_start,
2772 va_list *ap,
2773 int *arg_idx,
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02002774 int *arg_cur,
2775 const char *fmt)
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002776{
2777 int arg_min = 0;
2778
2779 if (*arg_cur + 1 == *arg_idx)
2780 {
2781 ++*arg_cur;
2782 ++*arg_idx;
2783 return;
2784 }
2785
2786 if (*arg_cur >= *arg_idx)
2787 {
2788 // Reset ap to ap_start and skip arg_idx - 1 types
2789 va_end(*ap);
2790 va_copy(*ap, ap_start);
2791 }
2792 else
2793 {
2794 // Skip over any we should skip
2795 arg_min = *arg_cur;
2796 }
2797
2798 for (*arg_cur = arg_min; *arg_cur < *arg_idx - 1; ++*arg_cur)
2799 {
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02002800 const char *p;
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002801
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02002802 if (ap_types == NULL || ap_types[*arg_cur] == NULL)
2803 {
zeertzjq7db89bd2023-09-04 07:54:02 +02002804 siemsg(e_aptypes_is_null_str_nr, fmt, *arg_cur);
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02002805 return;
2806 }
2807
2808 p = ap_types[*arg_cur];
2809
2810 int fmt_type = format_typeof(p);
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002811
2812 // get parameter value, do initial processing
2813 switch (fmt_type)
2814 {
2815 case TYPE_PERCENT:
2816 case TYPE_UNKNOWN:
2817 break;
2818
2819 case TYPE_CHAR:
2820 va_arg(*ap, int);
2821 break;
2822
2823 case TYPE_STRING:
2824 va_arg(*ap, char *);
2825 break;
2826
2827 case TYPE_POINTER:
2828 va_arg(*ap, void *);
2829 break;
2830
2831 case TYPE_INT:
2832 va_arg(*ap, int);
2833 break;
2834
2835 case TYPE_LONGINT:
2836 va_arg(*ap, long int);
2837 break;
2838
2839 case TYPE_LONGLONGINT:
2840 va_arg(*ap, varnumber_T);
2841 break;
2842
2843 case TYPE_UNSIGNEDINT:
2844 va_arg(*ap, unsigned int);
2845 break;
2846
2847 case TYPE_UNSIGNEDLONGINT:
2848 va_arg(*ap, unsigned long int);
2849 break;
2850
2851 case TYPE_UNSIGNEDLONGLONGINT:
2852 va_arg(*ap, uvarnumber_T);
2853 break;
2854
2855 case TYPE_FLOAT:
2856 va_arg(*ap, double);
2857 break;
2858 }
2859 }
2860
2861 // Because we know that after we return from this call,
2862 // a va_arg() call is made, we can pre-emptively
2863 // increment the current argument index.
2864 ++*arg_cur;
2865 ++*arg_idx;
2866
2867 return;
2868}
2869
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002870 int
2871vim_vsnprintf_typval(
2872 char *str,
2873 size_t str_m,
2874 const char *fmt,
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002875 va_list ap_start,
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002876 typval_T *tvs)
2877{
2878 size_t str_l = 0;
2879 const char *p = fmt;
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002880 int arg_cur = 0;
2881 int num_posarg = 0;
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002882 int arg_idx = 1;
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002883 va_list ap;
2884 const char **ap_types = NULL;
2885
2886 if (parse_fmt_types(&ap_types, &num_posarg, fmt, tvs) == FAIL)
2887 return 0;
2888
2889 va_copy(ap, ap_start);
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002890
2891 if (p == NULL)
2892 p = "";
2893 while (*p != NUL)
2894 {
2895 if (*p != '%')
2896 {
2897 char *q = strchr(p + 1, '%');
2898 size_t n = (q == NULL) ? STRLEN(p) : (size_t)(q - p);
2899
2900 // Copy up to the next '%' or NUL without any changes.
2901 if (str_l < str_m)
2902 {
2903 size_t avail = str_m - str_l;
2904
2905 mch_memmove(str + str_l, p, n > avail ? avail : n);
2906 }
2907 p += n;
2908 str_l += n;
2909 }
2910 else
2911 {
2912 size_t min_field_width = 0, precision = 0;
2913 int zero_padding = 0, precision_specified = 0, justify_left = 0;
2914 int alternate_form = 0, force_sign = 0;
2915
2916 // If both the ' ' and '+' flags appear, the ' ' flag should be
2917 // ignored.
2918 int space_for_positive = 1;
2919
2920 // allowed values: \0, h, l, L
2921 char length_modifier = '\0';
2922
2923 // temporary buffer for simple numeric->string conversion
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002924# define TMP_LEN 350 // On my system 1e308 is the biggest number possible.
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002925 // That sounds reasonable to use as the maximum
2926 // printable.
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002927 char tmp[TMP_LEN];
2928
2929 // string address in case of string argument
2930 const char *str_arg = NULL;
2931
2932 // natural field width of arg without padding and sign
2933 size_t str_arg_l;
2934
2935 // unsigned char argument value - only defined for c conversion.
2936 // N.B. standard explicitly states the char argument for the c
2937 // conversion is unsigned
2938 unsigned char uchar_arg;
2939
2940 // number of zeros to be inserted for numeric conversions as
2941 // required by the precision or minimal field width
2942 size_t number_of_zeros_to_pad = 0;
2943
2944 // index into tmp where zero padding is to be inserted
2945 size_t zero_padding_insertion_ind = 0;
2946
2947 // current conversion specifier character
2948 char fmt_spec = '\0';
2949
2950 // buffer for 's' and 'S' specs
2951 char_u *tofree = NULL;
2952
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002953 // variables for positional arg
2954 int pos_arg = -1;
2955 const char *ptype;
2956
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002957
2958 p++; // skip '%'
2959
Christ van Willegen0c6181f2023-08-13 18:03:14 +02002960 // First check to see if we find a positional
2961 // argument specifier
2962 ptype = p;
2963
2964 while (VIM_ISDIGIT(*ptype))
2965 ++ptype;
2966
2967 if (*ptype == '$')
2968 {
2969 // Positional argument
2970 unsigned int uj = *p++ - '0';
2971
2972 while (VIM_ISDIGIT((int)(*p)))
2973 uj = 10 * uj + (unsigned int)(*p++ - '0');
2974 pos_arg = uj;
2975
2976 ++p;
2977 }
2978
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002979 // parse flags
2980 while (*p == '0' || *p == '-' || *p == '+' || *p == ' '
2981 || *p == '#' || *p == '\'')
2982 {
2983 switch (*p)
2984 {
2985 case '0': zero_padding = 1; break;
2986 case '-': justify_left = 1; break;
2987 case '+': force_sign = 1; space_for_positive = 0; break;
2988 case ' ': force_sign = 1;
2989 // If both the ' ' and '+' flags appear, the ' '
2990 // flag should be ignored
2991 break;
2992 case '#': alternate_form = 1; break;
2993 case '\'': break;
2994 }
2995 p++;
2996 }
2997 // If the '0' and '-' flags both appear, the '0' flag should be
2998 // ignored.
2999
3000 // parse field width
3001 if (*p == '*')
3002 {
3003 int j;
3004
3005 p++;
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003006
3007 if (VIM_ISDIGIT((int)(*p)))
3008 {
3009 // Positional argument field width
3010 unsigned int uj = *p++ - '0';
3011
3012 while (VIM_ISDIGIT((int)(*p)))
3013 uj = 10 * uj + (unsigned int)(*p++ - '0');
3014 arg_idx = uj;
3015
3016 ++p;
3017 }
3018
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003019 j =
3020# if defined(FEAT_EVAL)
3021 tvs != NULL ? tv_nr(tvs, &arg_idx) :
3022# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003023 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3024 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003025 va_arg(ap, int));
3026
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003027 if (j >= 0)
3028 min_field_width = j;
3029 else
3030 {
3031 min_field_width = -j;
3032 justify_left = 1;
3033 }
3034 }
3035 else if (VIM_ISDIGIT((int)(*p)))
3036 {
3037 // size_t could be wider than unsigned int; make sure we treat
3038 // argument like common implementations do
3039 unsigned int uj = *p++ - '0';
3040
3041 while (VIM_ISDIGIT((int)(*p)))
3042 uj = 10 * uj + (unsigned int)(*p++ - '0');
3043 min_field_width = uj;
3044 }
3045
3046 // parse precision
3047 if (*p == '.')
3048 {
3049 p++;
3050 precision_specified = 1;
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003051
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003052 if (VIM_ISDIGIT((int)(*p)))
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003053 {
3054 // size_t could be wider than unsigned int; make sure we
3055 // treat argument like common implementations do
3056 unsigned int uj = *p++ - '0';
3057
3058 while (VIM_ISDIGIT((int)(*p)))
3059 uj = 10 * uj + (unsigned int)(*p++ - '0');
3060 precision = uj;
3061 }
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003062 else if (*p == '*')
3063 {
3064 int j;
3065
3066 p++;
3067
3068 if (VIM_ISDIGIT((int)(*p)))
3069 {
3070 // positional argument
3071 unsigned int uj = *p++ - '0';
3072
3073 while (VIM_ISDIGIT((int)(*p)))
3074 uj = 10 * uj + (unsigned int)(*p++ - '0');
3075 arg_idx = uj;
3076
3077 ++p;
3078 }
3079
3080 j =
3081# if defined(FEAT_EVAL)
3082 tvs != NULL ? tv_nr(tvs, &arg_idx) :
3083# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003084 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3085 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003086 va_arg(ap, int));
3087
3088 if (j >= 0)
3089 precision = j;
3090 else
3091 {
3092 precision_specified = 0;
3093 precision = 0;
3094 }
3095 }
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003096 }
3097
3098 // parse 'h', 'l' and 'll' length modifiers
3099 if (*p == 'h' || *p == 'l')
3100 {
3101 length_modifier = *p;
3102 p++;
3103 if (length_modifier == 'l' && *p == 'l')
3104 {
3105 // double l = __int64 / varnumber_T
3106 length_modifier = 'L';
3107 p++;
3108 }
3109 }
3110 fmt_spec = *p;
3111
3112 // common synonyms:
3113 switch (fmt_spec)
3114 {
3115 case 'i': fmt_spec = 'd'; break;
3116 case 'D': fmt_spec = 'd'; length_modifier = 'l'; break;
3117 case 'U': fmt_spec = 'u'; length_modifier = 'l'; break;
3118 case 'O': fmt_spec = 'o'; length_modifier = 'l'; break;
3119 default: break;
3120 }
3121
3122# if defined(FEAT_EVAL)
3123 switch (fmt_spec)
3124 {
3125 case 'd': case 'u': case 'o': case 'x': case 'X':
3126 if (tvs != NULL && length_modifier == '\0')
3127 length_modifier = 'L';
3128 }
3129# endif
3130
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003131 if (pos_arg != -1)
3132 arg_idx = pos_arg;
3133
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003134 // get parameter value, do initial processing
3135 switch (fmt_spec)
3136 {
3137 // '%' and 'c' behave similar to 's' regarding flags and field
3138 // widths
3139 case '%':
3140 case 'c':
3141 case 's':
3142 case 'S':
3143 str_arg_l = 1;
3144 switch (fmt_spec)
3145 {
3146 case '%':
3147 str_arg = p;
3148 break;
3149
3150 case 'c':
3151 {
3152 int j;
3153
3154 j =
3155# if defined(FEAT_EVAL)
3156 tvs != NULL ? tv_nr(tvs, &arg_idx) :
3157# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003158 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3159 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003160 va_arg(ap, int));
3161
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003162 // standard demands unsigned char
3163 uchar_arg = (unsigned char)j;
3164 str_arg = (char *)&uchar_arg;
3165 break;
3166 }
3167
3168 case 's':
3169 case 'S':
3170 str_arg =
3171# if defined(FEAT_EVAL)
3172 tvs != NULL ? tv_str(tvs, &arg_idx, &tofree) :
3173# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003174 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3175 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003176 va_arg(ap, char *));
3177
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003178 if (str_arg == NULL)
3179 {
3180 str_arg = "[NULL]";
3181 str_arg_l = 6;
3182 }
3183 // make sure not to address string beyond the specified
3184 // precision !!!
3185 else if (!precision_specified)
3186 str_arg_l = strlen(str_arg);
3187 // truncate string if necessary as requested by precision
3188 else if (precision == 0)
3189 str_arg_l = 0;
3190 else
3191 {
3192 // Don't put the #if inside memchr(), it can be a
3193 // macro.
3194 // memchr on HP does not like n > 2^31 !!!
3195 char *q = memchr(str_arg, '\0',
3196 precision <= (size_t)0x7fffffffL ? precision
3197 : (size_t)0x7fffffffL);
presukud85fccd2021-11-20 19:38:31 +00003198
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003199 str_arg_l = (q == NULL) ? precision
3200 : (size_t)(q - str_arg);
3201 }
3202 if (fmt_spec == 'S')
3203 {
presuku1f2453f2021-11-24 15:32:57 +00003204 char_u *p1;
3205 size_t i;
3206 int cell;
presukud85fccd2021-11-20 19:38:31 +00003207
presuku1f2453f2021-11-24 15:32:57 +00003208 for (i = 0, p1 = (char_u *)str_arg; *p1;
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003209 p1 += mb_ptr2len(p1))
presuku1f2453f2021-11-24 15:32:57 +00003210 {
3211 cell = mb_ptr2cells(p1);
3212 if (precision_specified && i + cell > precision)
3213 break;
3214 i += cell;
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003215 }
presuku1f2453f2021-11-24 15:32:57 +00003216
3217 str_arg_l = p1 - (char_u *)str_arg;
presukud85fccd2021-11-20 19:38:31 +00003218 if (min_field_width != 0)
presuku1f2453f2021-11-24 15:32:57 +00003219 min_field_width += str_arg_l - i;
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003220 }
3221 break;
3222
3223 default:
3224 break;
3225 }
3226 break;
3227
3228 case 'd': case 'u':
3229 case 'b': case 'B':
3230 case 'o':
3231 case 'x': case 'X':
3232 case 'p':
3233 {
3234 // NOTE: the u, b, o, x, X and p conversion specifiers
3235 // imply the value is unsigned; d implies a signed
3236 // value
3237
3238 // 0 if numeric argument is zero (or if pointer is
3239 // NULL for 'p'), +1 if greater than zero (or nonzero
3240 // for unsigned arguments), -1 if negative (unsigned
3241 // argument is never negative)
3242 int arg_sign = 0;
3243
3244 // only set for length modifier h, or for no length
3245 // modifiers
3246 int int_arg = 0;
3247 unsigned int uint_arg = 0;
3248
3249 // only set for length modifier l
3250 long int long_arg = 0;
3251 unsigned long int ulong_arg = 0;
3252
3253 // only set for length modifier ll
3254 varnumber_T llong_arg = 0;
3255 uvarnumber_T ullong_arg = 0;
3256
3257 // only set for b conversion
3258 uvarnumber_T bin_arg = 0;
3259
3260 // pointer argument value -only defined for p
3261 // conversion
3262 void *ptr_arg = NULL;
3263
3264 if (fmt_spec == 'p')
3265 {
3266 length_modifier = '\0';
3267 ptr_arg =
3268# if defined(FEAT_EVAL)
3269 tvs != NULL ? (void *)tv_str(tvs, &arg_idx,
3270 NULL) :
3271# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003272 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3273 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003274 va_arg(ap, void *));
3275
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003276 if (ptr_arg != NULL)
3277 arg_sign = 1;
3278 }
3279 else if (fmt_spec == 'b' || fmt_spec == 'B')
3280 {
3281 bin_arg =
3282# if defined(FEAT_EVAL)
3283 tvs != NULL ?
3284 (uvarnumber_T)tv_nr(tvs, &arg_idx) :
3285# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003286 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3287 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003288 va_arg(ap, uvarnumber_T));
3289
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003290 if (bin_arg != 0)
3291 arg_sign = 1;
3292 }
3293 else if (fmt_spec == 'd')
3294 {
3295 // signed
3296 switch (length_modifier)
3297 {
3298 case '\0':
3299 case 'h':
3300 // char and short arguments are passed as int.
3301 int_arg =
3302# if defined(FEAT_EVAL)
3303 tvs != NULL ? tv_nr(tvs, &arg_idx) :
3304# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003305 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3306 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003307 va_arg(ap, int));
3308
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003309 if (int_arg > 0)
3310 arg_sign = 1;
3311 else if (int_arg < 0)
3312 arg_sign = -1;
3313 break;
3314 case 'l':
3315 long_arg =
3316# if defined(FEAT_EVAL)
3317 tvs != NULL ? tv_nr(tvs, &arg_idx) :
3318# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003319 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3320 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003321 va_arg(ap, long int));
3322
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003323 if (long_arg > 0)
3324 arg_sign = 1;
3325 else if (long_arg < 0)
3326 arg_sign = -1;
3327 break;
3328 case 'L':
3329 llong_arg =
3330# if defined(FEAT_EVAL)
3331 tvs != NULL ? tv_nr(tvs, &arg_idx) :
3332# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003333 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3334 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003335 va_arg(ap, varnumber_T));
3336
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003337 if (llong_arg > 0)
3338 arg_sign = 1;
3339 else if (llong_arg < 0)
3340 arg_sign = -1;
3341 break;
3342 }
3343 }
3344 else
3345 {
3346 // unsigned
3347 switch (length_modifier)
3348 {
3349 case '\0':
3350 case 'h':
3351 uint_arg =
3352# if defined(FEAT_EVAL)
3353 tvs != NULL ? (unsigned)
3354 tv_nr(tvs, &arg_idx) :
3355# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003356 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3357 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003358 va_arg(ap, unsigned int));
3359
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003360 if (uint_arg != 0)
3361 arg_sign = 1;
3362 break;
3363 case 'l':
3364 ulong_arg =
3365# if defined(FEAT_EVAL)
3366 tvs != NULL ? (unsigned long)
3367 tv_nr(tvs, &arg_idx) :
3368# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003369 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3370 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003371 va_arg(ap, unsigned long int));
3372
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003373 if (ulong_arg != 0)
3374 arg_sign = 1;
3375 break;
3376 case 'L':
3377 ullong_arg =
3378# if defined(FEAT_EVAL)
3379 tvs != NULL ? (uvarnumber_T)
3380 tv_nr(tvs, &arg_idx) :
3381# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003382 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3383 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003384 va_arg(ap, uvarnumber_T));
3385
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003386 if (ullong_arg != 0)
3387 arg_sign = 1;
3388 break;
3389 }
3390 }
3391
3392 str_arg = tmp;
3393 str_arg_l = 0;
3394
3395 // NOTE:
3396 // For d, i, u, o, x, and X conversions, if precision is
3397 // specified, the '0' flag should be ignored. This is so
3398 // with Solaris 2.6, Digital UNIX 4.0, HPUX 10, Linux,
3399 // FreeBSD, NetBSD; but not with Perl.
3400 if (precision_specified)
3401 zero_padding = 0;
3402 if (fmt_spec == 'd')
3403 {
3404 if (force_sign && arg_sign >= 0)
3405 tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
3406 // leave negative numbers for sprintf to handle, to
3407 // avoid handling tricky cases like (short int)-32768
3408 }
3409 else if (alternate_form)
3410 {
3411 if (arg_sign != 0
3412 && (fmt_spec == 'b' || fmt_spec == 'B'
3413 || fmt_spec == 'x' || fmt_spec == 'X') )
3414 {
3415 tmp[str_arg_l++] = '0';
3416 tmp[str_arg_l++] = fmt_spec;
3417 }
3418 // alternate form should have no effect for p
3419 // conversion, but ...
3420 }
3421
3422 zero_padding_insertion_ind = str_arg_l;
3423 if (!precision_specified)
3424 precision = 1; // default precision is 1
3425 if (precision == 0 && arg_sign == 0)
3426 {
3427 // When zero value is formatted with an explicit
3428 // precision 0, the resulting formatted string is
3429 // empty (d, i, u, b, B, o, x, X, p).
3430 }
3431 else
3432 {
3433 char f[6];
3434 int f_l = 0;
3435
3436 // construct a simple format string for sprintf
3437 f[f_l++] = '%';
3438 if (!length_modifier)
3439 ;
3440 else if (length_modifier == 'L')
3441 {
3442# ifdef MSWIN
3443 f[f_l++] = 'I';
3444 f[f_l++] = '6';
3445 f[f_l++] = '4';
3446# else
3447 f[f_l++] = 'l';
3448 f[f_l++] = 'l';
3449# endif
3450 }
3451 else
3452 f[f_l++] = length_modifier;
3453 f[f_l++] = fmt_spec;
3454 f[f_l++] = '\0';
3455
3456 if (fmt_spec == 'p')
3457 str_arg_l += sprintf(tmp + str_arg_l, f, ptr_arg);
3458 else if (fmt_spec == 'b' || fmt_spec == 'B')
3459 {
3460 char b[8 * sizeof(uvarnumber_T)];
3461 size_t b_l = 0;
3462 uvarnumber_T bn = bin_arg;
3463
3464 do
3465 {
3466 b[sizeof(b) - ++b_l] = '0' + (bn & 0x1);
3467 bn >>= 1;
3468 }
3469 while (bn != 0);
3470
3471 memcpy(tmp + str_arg_l, b + sizeof(b) - b_l, b_l);
3472 str_arg_l += b_l;
3473 }
3474 else if (fmt_spec == 'd')
3475 {
3476 // signed
3477 switch (length_modifier)
3478 {
3479 case '\0': str_arg_l += sprintf(
3480 tmp + str_arg_l, f,
3481 int_arg);
3482 break;
3483 case 'h': str_arg_l += sprintf(
3484 tmp + str_arg_l, f,
3485 (short)int_arg);
3486 break;
3487 case 'l': str_arg_l += sprintf(
3488 tmp + str_arg_l, f, long_arg);
3489 break;
3490 case 'L': str_arg_l += sprintf(
3491 tmp + str_arg_l, f, llong_arg);
3492 break;
3493 }
3494 }
3495 else
3496 {
3497 // unsigned
3498 switch (length_modifier)
3499 {
3500 case '\0': str_arg_l += sprintf(
3501 tmp + str_arg_l, f,
3502 uint_arg);
3503 break;
3504 case 'h': str_arg_l += sprintf(
3505 tmp + str_arg_l, f,
3506 (unsigned short)uint_arg);
3507 break;
3508 case 'l': str_arg_l += sprintf(
3509 tmp + str_arg_l, f, ulong_arg);
3510 break;
3511 case 'L': str_arg_l += sprintf(
3512 tmp + str_arg_l, f, ullong_arg);
3513 break;
3514 }
3515 }
3516
3517 // include the optional minus sign and possible
3518 // "0x" in the region before the zero padding
3519 // insertion point
3520 if (zero_padding_insertion_ind < str_arg_l
3521 && tmp[zero_padding_insertion_ind] == '-')
3522 zero_padding_insertion_ind++;
3523 if (zero_padding_insertion_ind + 1 < str_arg_l
3524 && tmp[zero_padding_insertion_ind] == '0'
3525 && (tmp[zero_padding_insertion_ind + 1] == 'x'
3526 || tmp[zero_padding_insertion_ind + 1] == 'X'))
3527 zero_padding_insertion_ind += 2;
3528 }
3529
3530 {
3531 size_t num_of_digits = str_arg_l
3532 - zero_padding_insertion_ind;
3533
3534 if (alternate_form && fmt_spec == 'o'
3535 // unless zero is already the first
3536 // character
3537 && !(zero_padding_insertion_ind < str_arg_l
3538 && tmp[zero_padding_insertion_ind] == '0'))
3539 {
3540 // assure leading zero for alternate-form
3541 // octal numbers
3542 if (!precision_specified
3543 || precision < num_of_digits + 1)
3544 {
3545 // precision is increased to force the
3546 // first character to be zero, except if a
3547 // zero value is formatted with an
3548 // explicit precision of zero
3549 precision = num_of_digits + 1;
3550 }
3551 }
3552 // zero padding to specified precision?
3553 if (num_of_digits < precision)
3554 number_of_zeros_to_pad = precision - num_of_digits;
3555 }
3556 // zero padding to specified minimal field width?
3557 if (!justify_left && zero_padding)
3558 {
3559 int n = (int)(min_field_width - (str_arg_l
3560 + number_of_zeros_to_pad));
3561 if (n > 0)
3562 number_of_zeros_to_pad += n;
3563 }
3564 break;
3565 }
3566
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003567 case 'f':
3568 case 'F':
3569 case 'e':
3570 case 'E':
3571 case 'g':
3572 case 'G':
3573 {
3574 // Floating point.
3575 double f;
3576 double abs_f;
3577 char format[40];
3578 int l;
3579 int remove_trailing_zeroes = FALSE;
3580
3581 f =
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01003582# if defined(FEAT_EVAL)
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003583 tvs != NULL ? tv_float(tvs, &arg_idx) :
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01003584# endif
Christ van Willegenaa90d4f2023-09-03 17:22:37 +02003585 (skip_to_arg(ap_types, ap_start, &ap, &arg_idx,
3586 &arg_cur, fmt),
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003587 va_arg(ap, double));
3588
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003589 abs_f = f < 0 ? -f : f;
3590
3591 if (fmt_spec == 'g' || fmt_spec == 'G')
3592 {
3593 // Would be nice to use %g directly, but it prints
3594 // "1.0" as "1", we don't want that.
3595 if ((abs_f >= 0.001 && abs_f < 10000000.0)
3596 || abs_f == 0.0)
3597 fmt_spec = ASCII_ISUPPER(fmt_spec) ? 'F' : 'f';
3598 else
3599 fmt_spec = fmt_spec == 'g' ? 'e' : 'E';
3600 remove_trailing_zeroes = TRUE;
3601 }
3602
3603 if ((fmt_spec == 'f' || fmt_spec == 'F') &&
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01003604# ifdef VAX
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003605 abs_f > 1.0e38
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01003606# else
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003607 abs_f > 1.0e307
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01003608# endif
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003609 )
3610 {
3611 // Avoid a buffer overflow
3612 STRCPY(tmp, infinity_str(f > 0.0, fmt_spec,
3613 force_sign, space_for_positive));
3614 str_arg_l = STRLEN(tmp);
3615 zero_padding = 0;
3616 }
3617 else
3618 {
3619 if (isnan(f))
3620 {
3621 // Not a number: nan or NAN
3622 STRCPY(tmp, ASCII_ISUPPER(fmt_spec) ? "NAN"
3623 : "nan");
3624 str_arg_l = 3;
3625 zero_padding = 0;
3626 }
3627 else if (isinf(f))
3628 {
3629 STRCPY(tmp, infinity_str(f > 0.0, fmt_spec,
3630 force_sign, space_for_positive));
3631 str_arg_l = STRLEN(tmp);
3632 zero_padding = 0;
3633 }
3634 else
3635 {
3636 // Regular float number
3637 format[0] = '%';
3638 l = 1;
3639 if (force_sign)
3640 format[l++] = space_for_positive ? ' ' : '+';
3641 if (precision_specified)
3642 {
3643 size_t max_prec = TMP_LEN - 10;
3644
3645 // Make sure we don't get more digits than we
3646 // have room for.
3647 if ((fmt_spec == 'f' || fmt_spec == 'F')
3648 && abs_f > 1.0)
3649 max_prec -= (size_t)log10(abs_f);
3650 if (precision > max_prec)
3651 precision = max_prec;
3652 l += sprintf(format + l, ".%d", (int)precision);
3653 }
3654 format[l] = fmt_spec == 'F' ? 'f' : fmt_spec;
3655 format[l + 1] = NUL;
3656
3657 str_arg_l = sprintf(tmp, format, f);
3658 }
3659
3660 if (remove_trailing_zeroes)
3661 {
3662 int i;
3663 char *tp;
3664
3665 // Using %g or %G: remove superfluous zeroes.
3666 if (fmt_spec == 'f' || fmt_spec == 'F')
3667 tp = tmp + str_arg_l - 1;
3668 else
3669 {
3670 tp = (char *)vim_strchr((char_u *)tmp,
3671 fmt_spec == 'e' ? 'e' : 'E');
3672 if (tp != NULL)
3673 {
3674 // Remove superfluous '+' and leading
3675 // zeroes from the exponent.
3676 if (tp[1] == '+')
3677 {
3678 // Change "1.0e+07" to "1.0e07"
3679 STRMOVE(tp + 1, tp + 2);
3680 --str_arg_l;
3681 }
3682 i = (tp[1] == '-') ? 2 : 1;
3683 while (tp[i] == '0')
3684 {
3685 // Change "1.0e07" to "1.0e7"
3686 STRMOVE(tp + i, tp + i + 1);
3687 --str_arg_l;
3688 }
3689 --tp;
3690 }
3691 }
3692
3693 if (tp != NULL && !precision_specified)
3694 // Remove trailing zeroes, but keep the one
3695 // just after a dot.
3696 while (tp > tmp + 2 && *tp == '0'
3697 && tp[-1] != '.')
3698 {
3699 STRMOVE(tp, tp + 1);
3700 --tp;
3701 --str_arg_l;
3702 }
3703 }
3704 else
3705 {
3706 char *tp;
3707
3708 // Be consistent: some printf("%e") use 1.0e+12
3709 // and some 1.0e+012. Remove one zero in the last
3710 // case.
3711 tp = (char *)vim_strchr((char_u *)tmp,
3712 fmt_spec == 'e' ? 'e' : 'E');
3713 if (tp != NULL && (tp[1] == '+' || tp[1] == '-')
3714 && tp[2] == '0'
3715 && vim_isdigit(tp[3])
3716 && vim_isdigit(tp[4]))
3717 {
3718 STRMOVE(tp + 2, tp + 3);
3719 --str_arg_l;
3720 }
3721 }
3722 }
3723 if (zero_padding && min_field_width > str_arg_l
3724 && (tmp[0] == '-' || force_sign))
3725 {
3726 // padding 0's should be inserted after the sign
3727 number_of_zeros_to_pad = min_field_width - str_arg_l;
3728 zero_padding_insertion_ind = 1;
3729 }
3730 str_arg = tmp;
3731 break;
3732 }
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003733
3734 default:
3735 // unrecognized conversion specifier, keep format string
3736 // as-is
3737 zero_padding = 0; // turn zero padding off for non-numeric
3738 // conversion
3739 justify_left = 1;
3740 min_field_width = 0; // reset flags
3741
3742 // discard the unrecognized conversion, just keep *
3743 // the unrecognized conversion character
3744 str_arg = p;
3745 str_arg_l = 0;
3746 if (*p != NUL)
3747 str_arg_l++; // include invalid conversion specifier
3748 // unchanged if not at end-of-string
3749 break;
3750 }
3751
3752 if (*p != NUL)
3753 p++; // step over the just processed conversion specifier
3754
3755 // insert padding to the left as requested by min_field_width;
3756 // this does not include the zero padding in case of numerical
3757 // conversions
3758 if (!justify_left)
3759 {
3760 // left padding with blank or zero
3761 int pn = (int)(min_field_width - (str_arg_l + number_of_zeros_to_pad));
3762
3763 if (pn > 0)
3764 {
3765 if (str_l < str_m)
3766 {
3767 size_t avail = str_m - str_l;
3768
3769 vim_memset(str + str_l, zero_padding ? '0' : ' ',
3770 (size_t)pn > avail ? avail
3771 : (size_t)pn);
3772 }
3773 str_l += pn;
3774 }
3775 }
3776
3777 // zero padding as requested by the precision or by the minimal
3778 // field width for numeric conversions required?
3779 if (number_of_zeros_to_pad == 0)
3780 {
3781 // will not copy first part of numeric right now, *
3782 // force it to be copied later in its entirety
3783 zero_padding_insertion_ind = 0;
3784 }
3785 else
3786 {
3787 // insert first part of numerics (sign or '0x') before zero
3788 // padding
3789 int zn = (int)zero_padding_insertion_ind;
3790
3791 if (zn > 0)
3792 {
3793 if (str_l < str_m)
3794 {
3795 size_t avail = str_m - str_l;
3796
3797 mch_memmove(str + str_l, str_arg,
3798 (size_t)zn > avail ? avail
3799 : (size_t)zn);
3800 }
3801 str_l += zn;
3802 }
3803
3804 // insert zero padding as requested by the precision or min
3805 // field width
3806 zn = (int)number_of_zeros_to_pad;
3807 if (zn > 0)
3808 {
3809 if (str_l < str_m)
3810 {
3811 size_t avail = str_m - str_l;
3812
3813 vim_memset(str + str_l, '0',
3814 (size_t)zn > avail ? avail
3815 : (size_t)zn);
3816 }
3817 str_l += zn;
3818 }
3819 }
3820
3821 // insert formatted string
3822 // (or as-is conversion specifier for unknown conversions)
3823 {
3824 int sn = (int)(str_arg_l - zero_padding_insertion_ind);
3825
3826 if (sn > 0)
3827 {
3828 if (str_l < str_m)
3829 {
3830 size_t avail = str_m - str_l;
3831
3832 mch_memmove(str + str_l,
3833 str_arg + zero_padding_insertion_ind,
3834 (size_t)sn > avail ? avail : (size_t)sn);
3835 }
3836 str_l += sn;
3837 }
3838 }
3839
3840 // insert right padding
3841 if (justify_left)
3842 {
3843 // right blank padding to the field width
3844 int pn = (int)(min_field_width
3845 - (str_arg_l + number_of_zeros_to_pad));
3846
3847 if (pn > 0)
3848 {
3849 if (str_l < str_m)
3850 {
3851 size_t avail = str_m - str_l;
3852
3853 vim_memset(str + str_l, ' ',
3854 (size_t)pn > avail ? avail
3855 : (size_t)pn);
3856 }
3857 str_l += pn;
3858 }
3859 }
3860 vim_free(tofree);
3861 }
3862 }
3863
3864 if (str_m > 0)
3865 {
3866 // make sure the string is nul-terminated even at the expense of
3867 // overwriting the last character (shouldn't happen, but just in case)
3868 //
3869 str[str_l <= str_m - 1 ? str_l : str_m - 1] = '\0';
3870 }
3871
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003872 if (tvs != NULL && tvs[num_posarg != 0 ? num_posarg : arg_idx - 1].v_type != VAR_UNKNOWN)
Bram Moolenaar677658a2022-01-05 16:09:06 +00003873 emsg(_(e_too_many_arguments_to_printf));
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003874
K.Takata4c215ec2023-08-26 18:05:08 +02003875 vim_free((char*)ap_types);
Christ van Willegen0c6181f2023-08-13 18:03:14 +02003876 va_end(ap);
3877
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02003878 // Return the number of characters formatted (excluding trailing nul
3879 // character), that is, the number of characters that would have been
3880 // written to the buffer if it were large enough.
3881 return (int)str_l;
3882}
3883
3884#endif // PROTO