blob: 22361ca31f7180b2e051cf3c688d3b5aa2b9d57f [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
773#if defined(FEAT_EVAL) || defined(PROTO)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200774/*
775 * Return string "str" in ' quotes, doubling ' characters.
776 * If "str" is NULL an empty string is assumed.
777 * If "function" is TRUE make it function('string').
778 */
779 char_u *
780string_quote(char_u *str, int function)
781{
782 unsigned len;
783 char_u *p, *r, *s;
784
785 len = (function ? 13 : 3);
786 if (str != NULL)
787 {
788 len += (unsigned)STRLEN(str);
789 for (p = str; *p != NUL; MB_PTR_ADV(p))
790 if (*p == '\'')
791 ++len;
792 }
793 s = r = alloc(len);
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000794 if (r == NULL)
795 return NULL;
796
797 if (function)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200798 {
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000799 STRCPY(r, "function('");
800 r += 10;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200801 }
Yegappan Lakshmanan6ec66662023-01-23 20:46:21 +0000802 else
803 *r++ = '\'';
804 if (str != NULL)
805 for (p = str; *p != NUL; )
806 {
807 if (*p == '\'')
808 *r++ = '\'';
809 MB_COPY_CHAR(p, r);
810 }
811 *r++ = '\'';
812 if (function)
813 *r++ = ')';
814 *r++ = NUL;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +0200815 return s;
816}
817
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000818/*
819 * Count the number of times "needle" occurs in string "haystack". Case is
820 * ignored if "ic" is TRUE.
821 */
822 long
823string_count(char_u *haystack, char_u *needle, int ic)
824{
825 long n = 0;
826 char_u *p = haystack;
827 char_u *next;
828
829 if (p == NULL || needle == NULL || *needle == NUL)
830 return 0;
831
832 if (ic)
833 {
834 size_t len = STRLEN(needle);
835
836 while (*p != NUL)
837 {
838 if (MB_STRNICMP(p, needle, len) == 0)
839 {
840 ++n;
841 p += len;
842 }
843 else
844 MB_PTR_ADV(p);
845 }
846 }
847 else
848 while ((next = (char_u *)strstr((char *)p, (char *)needle)) != NULL)
849 {
850 ++n;
851 p = next + STRLEN(needle);
852 }
853
854 return n;
855}
856
857/*
858 * Make a typval_T of the first character of "input" and store it in "output".
859 * Return OK or FAIL.
860 */
861 static int
862copy_first_char_to_tv(char_u *input, typval_T *output)
863{
864 char_u buf[MB_MAXBYTES + 1];
865 int len;
866
867 if (input == NULL || output == NULL)
868 return FAIL;
869
870 len = has_mbyte ? mb_ptr2len(input) : 1;
871 STRNCPY(buf, input, len);
872 buf[len] = NUL;
873 output->v_type = VAR_STRING;
874 output->vval.v_string = vim_strsave(buf);
875
876 return output->vval.v_string == NULL ? FAIL : OK;
877}
878
879/*
880 * Implementation of map() and filter() for a String. Apply "expr" to every
881 * character in string "str" and return the result in "rettv".
882 */
883 void
884string_filter_map(
885 char_u *str,
886 filtermap_T filtermap,
887 typval_T *expr,
888 typval_T *rettv)
889{
890 char_u *p;
891 typval_T tv;
892 garray_T ga;
893 int len = 0;
894 int idx = 0;
895 int rem;
Bram Moolenaar82418262022-09-28 16:16:15 +0100896 typval_T newtv;
897 funccall_T *fc;
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000898
899 rettv->v_type = VAR_STRING;
900 rettv->vval.v_string = NULL;
901
902 // set_vim_var_nr() doesn't set the type
903 set_vim_var_type(VV_KEY, VAR_NUMBER);
904
Bram Moolenaar82418262022-09-28 16:16:15 +0100905 // Create one funccal_T for all eval_expr_typval() calls.
906 fc = eval_expr_get_funccal(expr, &newtv);
907
Bram Moolenaar04935fb2022-01-08 16:19:22 +0000908 ga_init2(&ga, sizeof(char), 80);
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000909 for (p = str; *p != NUL; p += len)
910 {
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000911 if (copy_first_char_to_tv(p, &tv) == FAIL)
912 break;
913 len = (int)STRLEN(tv.vval.v_string);
914
Bram Moolenaardd7eff02022-05-06 11:02:05 +0100915 newtv.v_type = VAR_UNKNOWN;
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000916 set_vim_var_nr(VV_KEY, idx);
Bram Moolenaar82418262022-09-28 16:16:15 +0100917 if (filter_map_one(&tv, expr, filtermap, fc, &newtv, &rem) == FAIL
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000918 || did_emsg)
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000919 {
920 clear_tv(&newtv);
921 clear_tv(&tv);
922 break;
923 }
924 else if (filtermap != FILTERMAP_FILTER)
925 {
926 if (newtv.v_type != VAR_STRING)
927 {
928 clear_tv(&newtv);
929 clear_tv(&tv);
Bram Moolenaare70cec92022-01-01 14:25:55 +0000930 emsg(_(e_string_required));
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000931 break;
932 }
933 else
934 ga_concat(&ga, newtv.vval.v_string);
935 }
936 else if (!rem)
937 ga_concat(&ga, tv.vval.v_string);
938
939 clear_tv(&newtv);
940 clear_tv(&tv);
941
942 ++idx;
943 }
944 ga_append(&ga, NUL);
945 rettv->vval.v_string = ga.ga_data;
Bram Moolenaar82418262022-09-28 16:16:15 +0100946 if (fc != NULL)
947 remove_funccal();
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000948}
949
950/*
Bram Moolenaarf1c60d42022-09-22 17:07:00 +0100951 * Implementation of reduce() for String "argvars[0]" using the function "expr"
952 * starting with the optional initial value "argvars[2]" and return the result
953 * in "rettv".
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000954 */
955 void
956string_reduce(
957 typval_T *argvars,
Bram Moolenaarf1c60d42022-09-22 17:07:00 +0100958 typval_T *expr,
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000959 typval_T *rettv)
960{
961 char_u *p = tv_get_string(&argvars[0]);
962 int len;
963 typval_T argv[3];
964 int r;
965 int called_emsg_start = called_emsg;
Bram Moolenaar82418262022-09-28 16:16:15 +0100966 funccall_T *fc;
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000967
968 if (argvars[2].v_type == VAR_UNKNOWN)
969 {
970 if (*p == NUL)
971 {
Bram Moolenaare70cec92022-01-01 14:25:55 +0000972 semsg(_(e_reduce_of_an_empty_str_with_no_initial_value), "String");
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000973 return;
974 }
975 if (copy_first_char_to_tv(p, rettv) == FAIL)
976 return;
977 p += STRLEN(rettv->vval.v_string);
978 }
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +0100979 else if (check_for_string_arg(argvars, 2) == FAIL)
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000980 return;
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000981 else
982 copy_tv(&argvars[2], rettv);
983
Bram Moolenaar82418262022-09-28 16:16:15 +0100984 // Create one funccal_T for all eval_expr_typval() calls.
985 fc = eval_expr_get_funccal(expr, rettv);
986
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000987 for ( ; *p != NUL; p += len)
988 {
989 argv[0] = *rettv;
990 if (copy_first_char_to_tv(p, &argv[1]) == FAIL)
991 break;
992 len = (int)STRLEN(argv[1].vval.v_string);
Bram Moolenaarf1c60d42022-09-22 17:07:00 +0100993
Bram Moolenaar82418262022-09-28 16:16:15 +0100994 r = eval_expr_typval(expr, argv, 2, fc, rettv);
Bram Moolenaarf1c60d42022-09-22 17:07:00 +0100995
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +0000996 clear_tv(&argv[0]);
997 clear_tv(&argv[1]);
998 if (r == FAIL || called_emsg != called_emsg_start)
999 return;
1000 }
Bram Moolenaar82418262022-09-28 16:16:15 +01001001
1002 if (fc != NULL)
1003 remove_funccal();
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +00001004}
1005
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001006 static void
1007byteidx(typval_T *argvars, typval_T *rettv, int comp UNUSED)
1008{
1009 char_u *t;
1010 char_u *str;
1011 varnumber_T idx;
1012
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001013 rettv->vval.v_number = -1;
1014
1015 if (in_vim9script()
1016 && (check_for_string_arg(argvars, 0) == FAIL
1017 || check_for_number_arg(argvars, 1) == FAIL))
1018 return;
1019
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001020 str = tv_get_string_chk(&argvars[0]);
1021 idx = tv_get_number_chk(&argvars[1], NULL);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001022 if (str == NULL || idx < 0)
1023 return;
1024
1025 t = str;
1026 for ( ; idx > 0; idx--)
1027 {
1028 if (*t == NUL) // EOL reached
1029 return;
1030 if (enc_utf8 && comp)
1031 t += utf_ptr2len(t);
1032 else
1033 t += (*mb_ptr2len)(t);
1034 }
1035 rettv->vval.v_number = (varnumber_T)(t - str);
1036}
1037
1038/*
1039 * "byteidx()" function
1040 */
1041 void
1042f_byteidx(typval_T *argvars, typval_T *rettv)
1043{
1044 byteidx(argvars, rettv, FALSE);
1045}
1046
1047/*
1048 * "byteidxcomp()" function
1049 */
1050 void
1051f_byteidxcomp(typval_T *argvars, typval_T *rettv)
1052{
1053 byteidx(argvars, rettv, TRUE);
1054}
1055
1056/*
1057 * "charidx()" function
1058 */
1059 void
1060f_charidx(typval_T *argvars, typval_T *rettv)
1061{
1062 char_u *str;
1063 varnumber_T idx;
1064 varnumber_T countcc = FALSE;
1065 char_u *p;
1066 int len;
1067 int (*ptr2len)(char_u *);
1068
1069 rettv->vval.v_number = -1;
1070
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01001071 if ((check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001072 || check_for_number_arg(argvars, 1) == FAIL
1073 || check_for_opt_bool_arg(argvars, 2) == FAIL))
1074 return;
1075
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001076 str = tv_get_string_chk(&argvars[0]);
1077 idx = tv_get_number_chk(&argvars[1], NULL);
1078 if (str == NULL || idx < 0)
1079 return;
1080
1081 if (argvars[2].v_type != VAR_UNKNOWN)
1082 countcc = tv_get_bool(&argvars[2]);
1083 if (countcc < 0 || countcc > 1)
1084 {
1085 semsg(_(e_using_number_as_bool_nr), countcc);
1086 return;
1087 }
1088
1089 if (enc_utf8 && countcc)
1090 ptr2len = utf_ptr2len;
1091 else
1092 ptr2len = mb_ptr2len;
1093
1094 for (p = str, len = 0; p <= str + idx; len++)
1095 {
1096 if (*p == NUL)
1097 return;
1098 p += ptr2len(p);
1099 }
1100
1101 rettv->vval.v_number = len > 0 ? len - 1 : 0;
1102}
1103
1104/*
1105 * "str2list()" function
1106 */
1107 void
1108f_str2list(typval_T *argvars, typval_T *rettv)
1109{
1110 char_u *p;
1111 int utf8 = FALSE;
1112
1113 if (rettv_list_alloc(rettv) == FAIL)
1114 return;
1115
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001116 if (in_vim9script()
1117 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001118 || check_for_opt_bool_arg(argvars, 1) == FAIL))
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001119 return;
1120
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001121 if (argvars[1].v_type != VAR_UNKNOWN)
1122 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL);
1123
1124 p = tv_get_string(&argvars[0]);
1125
1126 if (has_mbyte || utf8)
1127 {
1128 int (*ptr2len)(char_u *);
1129 int (*ptr2char)(char_u *);
1130
1131 if (utf8 || enc_utf8)
1132 {
1133 ptr2len = utf_ptr2len;
1134 ptr2char = utf_ptr2char;
1135 }
1136 else
1137 {
1138 ptr2len = mb_ptr2len;
1139 ptr2char = mb_ptr2char;
1140 }
1141
1142 for ( ; *p != NUL; p += (*ptr2len)(p))
1143 list_append_number(rettv->vval.v_list, (*ptr2char)(p));
1144 }
1145 else
1146 for ( ; *p != NUL; ++p)
1147 list_append_number(rettv->vval.v_list, *p);
1148}
1149
1150/*
1151 * "str2nr()" function
1152 */
1153 void
1154f_str2nr(typval_T *argvars, typval_T *rettv)
1155{
1156 int base = 10;
1157 char_u *p;
1158 varnumber_T n;
1159 int what = 0;
1160 int isneg;
1161
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001162 if (in_vim9script()
1163 && (check_for_string_arg(argvars, 0) == FAIL
1164 || check_for_opt_number_arg(argvars, 1) == FAIL
1165 || (argvars[1].v_type != VAR_UNKNOWN
1166 && check_for_opt_bool_arg(argvars, 2) == FAIL)))
1167 return;
1168
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001169 if (argvars[1].v_type != VAR_UNKNOWN)
1170 {
1171 base = (int)tv_get_number(&argvars[1]);
1172 if (base != 2 && base != 8 && base != 10 && base != 16)
1173 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00001174 emsg(_(e_invalid_argument));
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001175 return;
1176 }
1177 if (argvars[2].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[2]))
1178 what |= STR2NR_QUOTE;
1179 }
1180
1181 p = skipwhite(tv_get_string_strict(&argvars[0]));
1182 isneg = (*p == '-');
1183 if (*p == '+' || *p == '-')
1184 p = skipwhite(p + 1);
1185 switch (base)
1186 {
1187 case 2: what |= STR2NR_BIN + STR2NR_FORCE; break;
1188 case 8: what |= STR2NR_OCT + STR2NR_OOCT + STR2NR_FORCE; break;
1189 case 16: what |= STR2NR_HEX + STR2NR_FORCE; break;
1190 }
1191 vim_str2nr(p, NULL, NULL, what, &n, NULL, 0, FALSE);
1192 // Text after the number is silently ignored.
1193 if (isneg)
1194 rettv->vval.v_number = -n;
1195 else
1196 rettv->vval.v_number = n;
1197
1198}
1199
1200/*
1201 * "strgetchar()" function
1202 */
1203 void
1204f_strgetchar(typval_T *argvars, typval_T *rettv)
1205{
1206 char_u *str;
1207 int len;
1208 int error = FALSE;
1209 int charidx;
1210 int byteidx = 0;
1211
1212 rettv->vval.v_number = -1;
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001213
1214 if (in_vim9script()
1215 && (check_for_string_arg(argvars, 0) == FAIL
1216 || check_for_number_arg(argvars, 1) == FAIL))
1217 return;
1218
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001219 str = tv_get_string_chk(&argvars[0]);
1220 if (str == NULL)
1221 return;
1222 len = (int)STRLEN(str);
1223 charidx = (int)tv_get_number_chk(&argvars[1], &error);
1224 if (error)
1225 return;
1226
1227 while (charidx >= 0 && byteidx < len)
1228 {
1229 if (charidx == 0)
1230 {
1231 rettv->vval.v_number = mb_ptr2char(str + byteidx);
1232 break;
1233 }
1234 --charidx;
1235 byteidx += MB_CPTR2LEN(str + byteidx);
1236 }
1237}
1238
1239/*
1240 * "stridx()" function
1241 */
1242 void
1243f_stridx(typval_T *argvars, typval_T *rettv)
1244{
1245 char_u buf[NUMBUFLEN];
1246 char_u *needle;
1247 char_u *haystack;
1248 char_u *save_haystack;
1249 char_u *pos;
1250 int start_idx;
1251
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001252 if (in_vim9script()
1253 && (check_for_string_arg(argvars, 0) == FAIL
1254 || check_for_string_arg(argvars, 1) == FAIL
1255 || check_for_opt_number_arg(argvars, 2) == FAIL))
1256 return;
1257
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001258 needle = tv_get_string_chk(&argvars[1]);
1259 save_haystack = haystack = tv_get_string_buf_chk(&argvars[0], buf);
1260 rettv->vval.v_number = -1;
1261 if (needle == NULL || haystack == NULL)
1262 return; // type error; errmsg already given
1263
1264 if (argvars[2].v_type != VAR_UNKNOWN)
1265 {
1266 int error = FALSE;
1267
1268 start_idx = (int)tv_get_number_chk(&argvars[2], &error);
1269 if (error || start_idx >= (int)STRLEN(haystack))
1270 return;
1271 if (start_idx >= 0)
1272 haystack += start_idx;
1273 }
1274
1275 pos = (char_u *)strstr((char *)haystack, (char *)needle);
1276 if (pos != NULL)
1277 rettv->vval.v_number = (varnumber_T)(pos - save_haystack);
1278}
1279
1280/*
1281 * "string()" function
1282 */
1283 void
1284f_string(typval_T *argvars, typval_T *rettv)
1285{
1286 char_u *tofree;
1287 char_u numbuf[NUMBUFLEN];
1288
1289 rettv->v_type = VAR_STRING;
1290 rettv->vval.v_string = tv2string(&argvars[0], &tofree, numbuf,
1291 get_copyID());
1292 // Make a copy if we have a value but it's not in allocated memory.
1293 if (rettv->vval.v_string != NULL && tofree == NULL)
1294 rettv->vval.v_string = vim_strsave(rettv->vval.v_string);
1295}
1296
1297/*
1298 * "strlen()" function
1299 */
1300 void
1301f_strlen(typval_T *argvars, typval_T *rettv)
1302{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001303 if (in_vim9script()
1304 && check_for_string_or_number_arg(argvars, 0) == FAIL)
1305 return;
1306
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001307 rettv->vval.v_number = (varnumber_T)(STRLEN(
1308 tv_get_string(&argvars[0])));
1309}
1310
1311 static void
1312strchar_common(typval_T *argvars, typval_T *rettv, int skipcc)
1313{
1314 char_u *s = tv_get_string(&argvars[0]);
1315 varnumber_T len = 0;
1316 int (*func_mb_ptr2char_adv)(char_u **pp);
1317
1318 func_mb_ptr2char_adv = skipcc ? mb_ptr2char_adv : mb_cptr2char_adv;
1319 while (*s != NUL)
1320 {
1321 func_mb_ptr2char_adv(&s);
1322 ++len;
1323 }
1324 rettv->vval.v_number = len;
1325}
1326
1327/*
1328 * "strcharlen()" function
1329 */
1330 void
1331f_strcharlen(typval_T *argvars, typval_T *rettv)
1332{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001333 if (in_vim9script()
1334 && check_for_string_or_number_arg(argvars, 0) == FAIL)
1335 return;
1336
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001337 strchar_common(argvars, rettv, TRUE);
1338}
1339
1340/*
1341 * "strchars()" function
1342 */
1343 void
1344f_strchars(typval_T *argvars, typval_T *rettv)
1345{
1346 varnumber_T skipcc = FALSE;
1347
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001348 if (in_vim9script()
1349 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001350 || check_for_opt_bool_arg(argvars, 1) == FAIL))
Yegappan Lakshmanana9a7c0c2021-07-17 19:11:07 +02001351 return;
1352
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001353 if (argvars[1].v_type != VAR_UNKNOWN)
1354 skipcc = tv_get_bool(&argvars[1]);
1355 if (skipcc < 0 || skipcc > 1)
1356 semsg(_(e_using_number_as_bool_nr), skipcc);
1357 else
1358 strchar_common(argvars, rettv, skipcc);
1359}
1360
1361/*
1362 * "strdisplaywidth()" function
1363 */
1364 void
1365f_strdisplaywidth(typval_T *argvars, typval_T *rettv)
1366{
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001367 char_u *s;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001368 int col = 0;
1369
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001370 rettv->vval.v_number = -1;
1371
1372 if (in_vim9script()
1373 && (check_for_string_arg(argvars, 0) == FAIL
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001374 || check_for_opt_number_arg(argvars, 1) == FAIL))
Yegappan Lakshmanan1a71d312021-07-15 12:49:58 +02001375 return;
1376
1377 s = tv_get_string(&argvars[0]);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001378 if (argvars[1].v_type != VAR_UNKNOWN)
1379 col = (int)tv_get_number(&argvars[1]);
1380
1381 rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s) - col);
1382}
1383
1384/*
1385 * "strwidth()" function
1386 */
1387 void
1388f_strwidth(typval_T *argvars, typval_T *rettv)
1389{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001390 char_u *s;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001391
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001392 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
1393 return;
1394
1395 s = tv_get_string_strict(&argvars[0]);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001396 rettv->vval.v_number = (varnumber_T)(mb_string2cells(s, -1));
1397}
1398
1399/*
1400 * "strcharpart()" function
1401 */
1402 void
1403f_strcharpart(typval_T *argvars, typval_T *rettv)
1404{
1405 char_u *p;
1406 int nchar;
1407 int nbyte = 0;
1408 int charlen;
1409 int skipcc = FALSE;
1410 int len = 0;
1411 int slen;
1412 int error = FALSE;
1413
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001414 if (in_vim9script()
1415 && (check_for_string_arg(argvars, 0) == FAIL
1416 || check_for_number_arg(argvars, 1) == FAIL
1417 || check_for_opt_number_arg(argvars, 2) == FAIL
1418 || (argvars[2].v_type != VAR_UNKNOWN
1419 && check_for_opt_bool_arg(argvars, 3) == FAIL)))
1420 return;
1421
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001422 p = tv_get_string(&argvars[0]);
1423 slen = (int)STRLEN(p);
1424
1425 nchar = (int)tv_get_number_chk(&argvars[1], &error);
1426 if (!error)
1427 {
1428 if (argvars[2].v_type != VAR_UNKNOWN
1429 && argvars[3].v_type != VAR_UNKNOWN)
1430 {
1431 skipcc = tv_get_bool(&argvars[3]);
1432 if (skipcc < 0 || skipcc > 1)
1433 {
1434 semsg(_(e_using_number_as_bool_nr), skipcc);
1435 return;
1436 }
1437 }
1438
1439 if (nchar > 0)
1440 while (nchar > 0 && nbyte < slen)
1441 {
1442 if (skipcc)
1443 nbyte += mb_ptr2len(p + nbyte);
1444 else
1445 nbyte += MB_CPTR2LEN(p + nbyte);
1446 --nchar;
1447 }
1448 else
1449 nbyte = nchar;
1450 if (argvars[2].v_type != VAR_UNKNOWN)
1451 {
1452 charlen = (int)tv_get_number(&argvars[2]);
1453 while (charlen > 0 && nbyte + len < slen)
1454 {
1455 int off = nbyte + len;
1456
1457 if (off < 0)
1458 len += 1;
1459 else
1460 {
1461 if (skipcc)
1462 len += mb_ptr2len(p + off);
1463 else
1464 len += MB_CPTR2LEN(p + off);
1465 }
1466 --charlen;
1467 }
1468 }
1469 else
1470 len = slen - nbyte; // default: all bytes that are available.
1471 }
1472
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02001473 // Only return the overlap between the specified part and the actual
1474 // string.
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001475 if (nbyte < 0)
1476 {
1477 len += nbyte;
1478 nbyte = 0;
1479 }
1480 else if (nbyte > slen)
1481 nbyte = slen;
1482 if (len < 0)
1483 len = 0;
1484 else if (nbyte + len > slen)
1485 len = slen - nbyte;
1486
1487 rettv->v_type = VAR_STRING;
1488 rettv->vval.v_string = vim_strnsave(p + nbyte, len);
1489}
1490
1491/*
1492 * "strpart()" function
1493 */
1494 void
1495f_strpart(typval_T *argvars, typval_T *rettv)
1496{
1497 char_u *p;
1498 int n;
1499 int len;
1500 int slen;
1501 int error = FALSE;
1502
Yegappan Lakshmanan83494b42021-07-20 17:51:51 +02001503 if (in_vim9script()
1504 && (check_for_string_arg(argvars, 0) == FAIL
1505 || check_for_number_arg(argvars, 1) == FAIL
1506 || check_for_opt_number_arg(argvars, 2) == FAIL
1507 || (argvars[2].v_type != VAR_UNKNOWN
1508 && check_for_opt_bool_arg(argvars, 3) == FAIL)))
1509 return;
1510
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001511 p = tv_get_string(&argvars[0]);
1512 slen = (int)STRLEN(p);
1513
1514 n = (int)tv_get_number_chk(&argvars[1], &error);
1515 if (error)
1516 len = 0;
1517 else if (argvars[2].v_type != VAR_UNKNOWN)
1518 len = (int)tv_get_number(&argvars[2]);
1519 else
1520 len = slen - n; // default len: all bytes that are available.
1521
1522 // Only return the overlap between the specified part and the actual
1523 // string.
1524 if (n < 0)
1525 {
1526 len += n;
1527 n = 0;
1528 }
1529 else if (n > slen)
1530 n = slen;
1531 if (len < 0)
1532 len = 0;
1533 else if (n + len > slen)
1534 len = slen - n;
1535
1536 if (argvars[2].v_type != VAR_UNKNOWN && argvars[3].v_type != VAR_UNKNOWN)
1537 {
1538 int off;
1539
1540 // length in characters
1541 for (off = n; off < slen && len > 0; --len)
1542 off += mb_ptr2len(p + off);
1543 len = off - n;
1544 }
1545
1546 rettv->v_type = VAR_STRING;
1547 rettv->vval.v_string = vim_strnsave(p + n, len);
1548}
1549
1550/*
1551 * "strridx()" function
1552 */
1553 void
1554f_strridx(typval_T *argvars, typval_T *rettv)
1555{
1556 char_u buf[NUMBUFLEN];
1557 char_u *needle;
1558 char_u *haystack;
1559 char_u *rest;
1560 char_u *lastmatch = NULL;
1561 int haystack_len, end_idx;
1562
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001563 if (in_vim9script()
1564 && (check_for_string_arg(argvars, 0) == FAIL
1565 || check_for_string_arg(argvars, 1) == FAIL
1566 || check_for_opt_number_arg(argvars, 2) == FAIL))
1567 return;
1568
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001569 needle = tv_get_string_chk(&argvars[1]);
1570 haystack = tv_get_string_buf_chk(&argvars[0], buf);
1571
1572 rettv->vval.v_number = -1;
1573 if (needle == NULL || haystack == NULL)
1574 return; // type error; errmsg already given
1575
1576 haystack_len = (int)STRLEN(haystack);
1577 if (argvars[2].v_type != VAR_UNKNOWN)
1578 {
1579 // Third argument: upper limit for index
1580 end_idx = (int)tv_get_number_chk(&argvars[2], NULL);
1581 if (end_idx < 0)
1582 return; // can never find a match
1583 }
1584 else
1585 end_idx = haystack_len;
1586
1587 if (*needle == NUL)
1588 {
1589 // Empty string matches past the end.
1590 lastmatch = haystack + end_idx;
1591 }
1592 else
1593 {
1594 for (rest = haystack; *rest != '\0'; ++rest)
1595 {
1596 rest = (char_u *)strstr((char *)rest, (char *)needle);
1597 if (rest == NULL || rest > haystack + end_idx)
1598 break;
1599 lastmatch = rest;
1600 }
1601 }
1602
1603 if (lastmatch == NULL)
1604 rettv->vval.v_number = -1;
1605 else
1606 rettv->vval.v_number = (varnumber_T)(lastmatch - haystack);
1607}
1608
1609/*
1610 * "strtrans()" function
1611 */
1612 void
1613f_strtrans(typval_T *argvars, typval_T *rettv)
1614{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001615 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
1616 return;
1617
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001618 rettv->v_type = VAR_STRING;
1619 rettv->vval.v_string = transstr(tv_get_string(&argvars[0]));
1620}
1621
1622/*
1623 * "tolower(string)" function
1624 */
1625 void
1626f_tolower(typval_T *argvars, typval_T *rettv)
1627{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001628 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
1629 return;
1630
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001631 rettv->v_type = VAR_STRING;
1632 rettv->vval.v_string = strlow_save(tv_get_string(&argvars[0]));
1633}
1634
1635/*
1636 * "toupper(string)" function
1637 */
1638 void
1639f_toupper(typval_T *argvars, typval_T *rettv)
1640{
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001641 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
1642 return;
1643
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001644 rettv->v_type = VAR_STRING;
1645 rettv->vval.v_string = strup_save(tv_get_string(&argvars[0]));
1646}
1647
1648/*
1649 * "tr(string, fromstr, tostr)" function
1650 */
1651 void
1652f_tr(typval_T *argvars, typval_T *rettv)
1653{
1654 char_u *in_str;
1655 char_u *fromstr;
1656 char_u *tostr;
1657 char_u *p;
1658 int inlen;
1659 int fromlen;
1660 int tolen;
1661 int idx;
1662 char_u *cpstr;
1663 int cplen;
1664 int first = TRUE;
1665 char_u buf[NUMBUFLEN];
1666 char_u buf2[NUMBUFLEN];
1667 garray_T ga;
1668
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001669 if (in_vim9script()
1670 && (check_for_string_arg(argvars, 0) == FAIL
1671 || check_for_string_arg(argvars, 1) == FAIL
1672 || check_for_string_arg(argvars, 2) == FAIL))
1673 return;
1674
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001675 in_str = tv_get_string(&argvars[0]);
1676 fromstr = tv_get_string_buf_chk(&argvars[1], buf);
1677 tostr = tv_get_string_buf_chk(&argvars[2], buf2);
1678
1679 // Default return value: empty string.
1680 rettv->v_type = VAR_STRING;
1681 rettv->vval.v_string = NULL;
1682 if (fromstr == NULL || tostr == NULL)
1683 return; // type error; errmsg already given
Bram Moolenaar04935fb2022-01-08 16:19:22 +00001684 ga_init2(&ga, sizeof(char), 80);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001685
1686 if (!has_mbyte)
1687 // not multi-byte: fromstr and tostr must be the same length
1688 if (STRLEN(fromstr) != STRLEN(tostr))
1689 {
1690error:
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00001691 semsg(_(e_invalid_argument_str), fromstr);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001692 ga_clear(&ga);
1693 return;
1694 }
1695
1696 // fromstr and tostr have to contain the same number of chars
1697 while (*in_str != NUL)
1698 {
1699 if (has_mbyte)
1700 {
1701 inlen = (*mb_ptr2len)(in_str);
1702 cpstr = in_str;
1703 cplen = inlen;
1704 idx = 0;
1705 for (p = fromstr; *p != NUL; p += fromlen)
1706 {
1707 fromlen = (*mb_ptr2len)(p);
1708 if (fromlen == inlen && STRNCMP(in_str, p, inlen) == 0)
1709 {
1710 for (p = tostr; *p != NUL; p += tolen)
1711 {
1712 tolen = (*mb_ptr2len)(p);
1713 if (idx-- == 0)
1714 {
1715 cplen = tolen;
1716 cpstr = p;
1717 break;
1718 }
1719 }
1720 if (*p == NUL) // tostr is shorter than fromstr
1721 goto error;
1722 break;
1723 }
1724 ++idx;
1725 }
1726
1727 if (first && cpstr == in_str)
1728 {
1729 // Check that fromstr and tostr have the same number of
1730 // (multi-byte) characters. Done only once when a character
1731 // of in_str doesn't appear in fromstr.
1732 first = FALSE;
1733 for (p = tostr; *p != NUL; p += tolen)
1734 {
1735 tolen = (*mb_ptr2len)(p);
1736 --idx;
1737 }
1738 if (idx != 0)
1739 goto error;
1740 }
1741
1742 (void)ga_grow(&ga, cplen);
1743 mch_memmove((char *)ga.ga_data + ga.ga_len, cpstr, (size_t)cplen);
1744 ga.ga_len += cplen;
1745
1746 in_str += inlen;
1747 }
1748 else
1749 {
1750 // When not using multi-byte chars we can do it faster.
1751 p = vim_strchr(fromstr, *in_str);
1752 if (p != NULL)
1753 ga_append(&ga, tostr[p - fromstr]);
1754 else
1755 ga_append(&ga, *in_str);
1756 ++in_str;
1757 }
1758 }
1759
1760 // add a terminating NUL
1761 (void)ga_grow(&ga, 1);
1762 ga_append(&ga, NUL);
1763
1764 rettv->vval.v_string = ga.ga_data;
1765}
1766
1767/*
1768 * "trim({expr})" function
1769 */
1770 void
1771f_trim(typval_T *argvars, typval_T *rettv)
1772{
1773 char_u buf1[NUMBUFLEN];
1774 char_u buf2[NUMBUFLEN];
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001775 char_u *head;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001776 char_u *mask = NULL;
1777 char_u *tail;
1778 char_u *prev;
1779 char_u *p;
1780 int c1;
1781 int dir = 0;
1782
1783 rettv->v_type = VAR_STRING;
1784 rettv->vval.v_string = NULL;
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001785
1786 if (in_vim9script()
1787 && (check_for_string_arg(argvars, 0) == FAIL
1788 || check_for_opt_string_arg(argvars, 1) == FAIL
1789 || (argvars[1].v_type != VAR_UNKNOWN
1790 && check_for_opt_number_arg(argvars, 2) == FAIL)))
1791 return;
1792
1793 head = tv_get_string_buf_chk(&argvars[0], buf1);
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001794 if (head == NULL)
1795 return;
1796
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01001797 if (check_for_opt_string_arg(argvars, 1) == FAIL)
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001798 return;
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001799
1800 if (argvars[1].v_type == VAR_STRING)
1801 {
1802 mask = tv_get_string_buf_chk(&argvars[1], buf2);
1803
1804 if (argvars[2].v_type != VAR_UNKNOWN)
1805 {
1806 int error = 0;
1807
1808 // leading or trailing characters to trim
1809 dir = (int)tv_get_number_chk(&argvars[2], &error);
1810 if (error)
1811 return;
1812 if (dir < 0 || dir > 2)
1813 {
Bram Moolenaar436b5ad2021-12-31 22:49:24 +00001814 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[2]));
Yegappan Lakshmanana2438132021-07-10 21:29:18 +02001815 return;
1816 }
1817 }
1818 }
1819
1820 if (dir == 0 || dir == 1)
1821 {
1822 // Trim leading characters
1823 while (*head != NUL)
1824 {
1825 c1 = PTR2CHAR(head);
1826 if (mask == NULL)
1827 {
1828 if (c1 > ' ' && c1 != 0xa0)
1829 break;
1830 }
1831 else
1832 {
1833 for (p = mask; *p != NUL; MB_PTR_ADV(p))
1834 if (c1 == PTR2CHAR(p))
1835 break;
1836 if (*p == NUL)
1837 break;
1838 }
1839 MB_PTR_ADV(head);
1840 }
1841 }
1842
1843 tail = head + STRLEN(head);
1844 if (dir == 0 || dir == 2)
1845 {
1846 // Trim trailing characters
1847 for (; tail > head; tail = prev)
1848 {
1849 prev = tail;
1850 MB_PTR_BACK(head, prev);
1851 c1 = PTR2CHAR(prev);
1852 if (mask == NULL)
1853 {
1854 if (c1 > ' ' && c1 != 0xa0)
1855 break;
1856 }
1857 else
1858 {
1859 for (p = mask; *p != NUL; MB_PTR_ADV(p))
1860 if (c1 == PTR2CHAR(p))
1861 break;
1862 if (*p == NUL)
1863 break;
1864 }
1865 }
1866 }
1867 rettv->vval.v_string = vim_strnsave(head, tail - head);
1868}
1869
Bram Moolenaar677658a2022-01-05 16:09:06 +00001870static char *e_printf = N_(e_insufficient_arguments_for_printf);
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02001871
1872/*
1873 * Get number argument from "idxp" entry in "tvs". First entry is 1.
1874 */
1875 static varnumber_T
1876tv_nr(typval_T *tvs, int *idxp)
1877{
1878 int idx = *idxp - 1;
1879 varnumber_T n = 0;
1880 int err = FALSE;
1881
1882 if (tvs[idx].v_type == VAR_UNKNOWN)
1883 emsg(_(e_printf));
1884 else
1885 {
1886 ++*idxp;
1887 n = tv_get_number_chk(&tvs[idx], &err);
1888 if (err)
1889 n = 0;
1890 }
1891 return n;
1892}
1893
1894/*
1895 * Get string argument from "idxp" entry in "tvs". First entry is 1.
1896 * If "tofree" is NULL tv_get_string_chk() is used. Some types (e.g. List)
1897 * are not converted to a string.
1898 * If "tofree" is not NULL echo_string() is used. All types are converted to
1899 * a string with the same format as ":echo". The caller must free "*tofree".
1900 * Returns NULL for an error.
1901 */
1902 static char *
1903tv_str(typval_T *tvs, int *idxp, char_u **tofree)
1904{
1905 int idx = *idxp - 1;
1906 char *s = NULL;
1907 static char_u numbuf[NUMBUFLEN];
1908
1909 if (tvs[idx].v_type == VAR_UNKNOWN)
1910 emsg(_(e_printf));
1911 else
1912 {
1913 ++*idxp;
1914 if (tofree != NULL)
1915 s = (char *)echo_string(&tvs[idx], tofree, numbuf, get_copyID());
1916 else
1917 s = (char *)tv_get_string_chk(&tvs[idx]);
1918 }
1919 return s;
1920}
1921
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02001922/*
1923 * Get float argument from "idxp" entry in "tvs". First entry is 1.
1924 */
1925 static double
1926tv_float(typval_T *tvs, int *idxp)
1927{
1928 int idx = *idxp - 1;
1929 double f = 0;
1930
1931 if (tvs[idx].v_type == VAR_UNKNOWN)
1932 emsg(_(e_printf));
1933 else
1934 {
1935 ++*idxp;
1936 if (tvs[idx].v_type == VAR_FLOAT)
1937 f = tvs[idx].vval.v_float;
1938 else if (tvs[idx].v_type == VAR_NUMBER)
1939 f = (double)tvs[idx].vval.v_number;
1940 else
Bram Moolenaar9d00e4a2022-01-05 17:49:15 +00001941 emsg(_(e_expected_float_argument_for_printf));
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02001942 }
1943 return f;
1944}
Yegappan Lakshmananf973eeb2021-12-22 18:19:26 +00001945
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02001946#endif
1947
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02001948/*
1949 * Return the representation of infinity for printf() function:
1950 * "-inf", "inf", "+inf", " inf", "-INF", "INF", "+INF" or " INF".
1951 */
1952 static const char *
1953infinity_str(int positive,
1954 char fmt_spec,
1955 int force_sign,
1956 int space_for_positive)
1957{
1958 static const char *table[] =
1959 {
1960 "-inf", "inf", "+inf", " inf",
1961 "-INF", "INF", "+INF", " INF"
1962 };
1963 int idx = positive * (1 + force_sign + force_sign * space_for_positive);
1964
1965 if (ASCII_ISUPPER(fmt_spec))
1966 idx += 4;
1967 return table[idx];
1968}
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02001969
1970/*
1971 * This code was included to provide a portable vsnprintf() and snprintf().
1972 * Some systems may provide their own, but we always use this one for
1973 * consistency.
1974 *
1975 * This code is based on snprintf.c - a portable implementation of snprintf
1976 * by Mark Martinec <mark.martinec@ijs.si>, Version 2.2, 2000-10-06.
1977 * Included with permission. It was heavily modified to fit in Vim.
1978 * The original code, including useful comments, can be found here:
1979 * http://www.ijs.si/software/snprintf/
1980 *
1981 * This snprintf() only supports the following conversion specifiers:
1982 * s, c, d, u, o, x, X, p (and synonyms: i, D, U, O - see below)
1983 * with flags: '-', '+', ' ', '0' and '#'.
1984 * An asterisk is supported for field width as well as precision.
1985 *
1986 * Limited support for floating point was added: 'f', 'F', 'e', 'E', 'g', 'G'.
1987 *
1988 * Length modifiers 'h' (short int) and 'l' (long int) and 'll' (long long int)
1989 * are supported. NOTE: for 'll' the argument is varnumber_T or uvarnumber_T.
1990 *
1991 * The locale is not used, the string is used as a byte string. This is only
1992 * relevant for double-byte encodings where the second byte may be '%'.
1993 *
1994 * It is permitted for "str_m" to be zero, and it is permitted to specify NULL
1995 * pointer for resulting string argument if "str_m" is zero (as per ISO C99).
1996 *
1997 * The return value is the number of characters which would be generated
1998 * for the given input, excluding the trailing NUL. If this value
1999 * is greater or equal to "str_m", not all characters from the result
2000 * have been stored in str, output bytes beyond the ("str_m"-1) -th character
2001 * are discarded. If "str_m" is greater than zero it is guaranteed
2002 * the resulting string will be NUL-terminated.
2003 */
2004
2005/*
2006 * When va_list is not supported we only define vim_snprintf().
2007 *
2008 * vim_vsnprintf_typval() can be invoked with either "va_list" or a list of
2009 * "typval_T". When the latter is not used it must be NULL.
2010 */
2011
2012// When generating prototypes all of this is skipped, cproto doesn't
2013// understand this.
2014#ifndef PROTO
2015
2016// Like vim_vsnprintf() but append to the string.
2017 int
2018vim_snprintf_add(char *str, size_t str_m, const char *fmt, ...)
2019{
2020 va_list ap;
2021 int str_l;
2022 size_t len = STRLEN(str);
2023 size_t space;
2024
2025 if (str_m <= len)
2026 space = 0;
2027 else
2028 space = str_m - len;
2029 va_start(ap, fmt);
2030 str_l = vim_vsnprintf(str + len, space, fmt, ap);
2031 va_end(ap);
2032 return str_l;
2033}
2034
2035 int
2036vim_snprintf(char *str, size_t str_m, const char *fmt, ...)
2037{
2038 va_list ap;
2039 int str_l;
2040
2041 va_start(ap, fmt);
2042 str_l = vim_vsnprintf(str, str_m, fmt, ap);
2043 va_end(ap);
2044 return str_l;
2045}
2046
2047 int
2048vim_vsnprintf(
2049 char *str,
2050 size_t str_m,
2051 const char *fmt,
2052 va_list ap)
2053{
2054 return vim_vsnprintf_typval(str, str_m, fmt, ap, NULL);
2055}
2056
2057 int
2058vim_vsnprintf_typval(
2059 char *str,
2060 size_t str_m,
2061 const char *fmt,
2062 va_list ap,
2063 typval_T *tvs)
2064{
2065 size_t str_l = 0;
2066 const char *p = fmt;
2067 int arg_idx = 1;
2068
2069 if (p == NULL)
2070 p = "";
2071 while (*p != NUL)
2072 {
2073 if (*p != '%')
2074 {
2075 char *q = strchr(p + 1, '%');
2076 size_t n = (q == NULL) ? STRLEN(p) : (size_t)(q - p);
2077
2078 // Copy up to the next '%' or NUL without any changes.
2079 if (str_l < str_m)
2080 {
2081 size_t avail = str_m - str_l;
2082
2083 mch_memmove(str + str_l, p, n > avail ? avail : n);
2084 }
2085 p += n;
2086 str_l += n;
2087 }
2088 else
2089 {
2090 size_t min_field_width = 0, precision = 0;
2091 int zero_padding = 0, precision_specified = 0, justify_left = 0;
2092 int alternate_form = 0, force_sign = 0;
2093
2094 // If both the ' ' and '+' flags appear, the ' ' flag should be
2095 // ignored.
2096 int space_for_positive = 1;
2097
2098 // allowed values: \0, h, l, L
2099 char length_modifier = '\0';
2100
2101 // temporary buffer for simple numeric->string conversion
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002102# define TMP_LEN 350 // On my system 1e308 is the biggest number possible.
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002103 // That sounds reasonable to use as the maximum
2104 // printable.
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002105 char tmp[TMP_LEN];
2106
2107 // string address in case of string argument
2108 const char *str_arg = NULL;
2109
2110 // natural field width of arg without padding and sign
2111 size_t str_arg_l;
2112
2113 // unsigned char argument value - only defined for c conversion.
2114 // N.B. standard explicitly states the char argument for the c
2115 // conversion is unsigned
2116 unsigned char uchar_arg;
2117
2118 // number of zeros to be inserted for numeric conversions as
2119 // required by the precision or minimal field width
2120 size_t number_of_zeros_to_pad = 0;
2121
2122 // index into tmp where zero padding is to be inserted
2123 size_t zero_padding_insertion_ind = 0;
2124
2125 // current conversion specifier character
2126 char fmt_spec = '\0';
2127
2128 // buffer for 's' and 'S' specs
2129 char_u *tofree = NULL;
2130
2131
2132 p++; // skip '%'
2133
2134 // parse flags
2135 while (*p == '0' || *p == '-' || *p == '+' || *p == ' '
2136 || *p == '#' || *p == '\'')
2137 {
2138 switch (*p)
2139 {
2140 case '0': zero_padding = 1; break;
2141 case '-': justify_left = 1; break;
2142 case '+': force_sign = 1; space_for_positive = 0; break;
2143 case ' ': force_sign = 1;
2144 // If both the ' ' and '+' flags appear, the ' '
2145 // flag should be ignored
2146 break;
2147 case '#': alternate_form = 1; break;
2148 case '\'': break;
2149 }
2150 p++;
2151 }
2152 // If the '0' and '-' flags both appear, the '0' flag should be
2153 // ignored.
2154
2155 // parse field width
2156 if (*p == '*')
2157 {
2158 int j;
2159
2160 p++;
2161 j =
2162# if defined(FEAT_EVAL)
2163 tvs != NULL ? tv_nr(tvs, &arg_idx) :
2164# endif
2165 va_arg(ap, int);
2166 if (j >= 0)
2167 min_field_width = j;
2168 else
2169 {
2170 min_field_width = -j;
2171 justify_left = 1;
2172 }
2173 }
2174 else if (VIM_ISDIGIT((int)(*p)))
2175 {
2176 // size_t could be wider than unsigned int; make sure we treat
2177 // argument like common implementations do
2178 unsigned int uj = *p++ - '0';
2179
2180 while (VIM_ISDIGIT((int)(*p)))
2181 uj = 10 * uj + (unsigned int)(*p++ - '0');
2182 min_field_width = uj;
2183 }
2184
2185 // parse precision
2186 if (*p == '.')
2187 {
2188 p++;
2189 precision_specified = 1;
2190 if (*p == '*')
2191 {
2192 int j;
2193
2194 j =
2195# if defined(FEAT_EVAL)
2196 tvs != NULL ? tv_nr(tvs, &arg_idx) :
2197# endif
2198 va_arg(ap, int);
2199 p++;
2200 if (j >= 0)
2201 precision = j;
2202 else
2203 {
2204 precision_specified = 0;
2205 precision = 0;
2206 }
2207 }
2208 else if (VIM_ISDIGIT((int)(*p)))
2209 {
2210 // size_t could be wider than unsigned int; make sure we
2211 // treat argument like common implementations do
2212 unsigned int uj = *p++ - '0';
2213
2214 while (VIM_ISDIGIT((int)(*p)))
2215 uj = 10 * uj + (unsigned int)(*p++ - '0');
2216 precision = uj;
2217 }
2218 }
2219
2220 // parse 'h', 'l' and 'll' length modifiers
2221 if (*p == 'h' || *p == 'l')
2222 {
2223 length_modifier = *p;
2224 p++;
2225 if (length_modifier == 'l' && *p == 'l')
2226 {
2227 // double l = __int64 / varnumber_T
2228 length_modifier = 'L';
2229 p++;
2230 }
2231 }
2232 fmt_spec = *p;
2233
2234 // common synonyms:
2235 switch (fmt_spec)
2236 {
2237 case 'i': fmt_spec = 'd'; break;
2238 case 'D': fmt_spec = 'd'; length_modifier = 'l'; break;
2239 case 'U': fmt_spec = 'u'; length_modifier = 'l'; break;
2240 case 'O': fmt_spec = 'o'; length_modifier = 'l'; break;
2241 default: break;
2242 }
2243
2244# if defined(FEAT_EVAL)
2245 switch (fmt_spec)
2246 {
2247 case 'd': case 'u': case 'o': case 'x': case 'X':
2248 if (tvs != NULL && length_modifier == '\0')
2249 length_modifier = 'L';
2250 }
2251# endif
2252
2253 // get parameter value, do initial processing
2254 switch (fmt_spec)
2255 {
2256 // '%' and 'c' behave similar to 's' regarding flags and field
2257 // widths
2258 case '%':
2259 case 'c':
2260 case 's':
2261 case 'S':
2262 str_arg_l = 1;
2263 switch (fmt_spec)
2264 {
2265 case '%':
2266 str_arg = p;
2267 break;
2268
2269 case 'c':
2270 {
2271 int j;
2272
2273 j =
2274# if defined(FEAT_EVAL)
2275 tvs != NULL ? tv_nr(tvs, &arg_idx) :
2276# endif
2277 va_arg(ap, int);
2278 // standard demands unsigned char
2279 uchar_arg = (unsigned char)j;
2280 str_arg = (char *)&uchar_arg;
2281 break;
2282 }
2283
2284 case 's':
2285 case 'S':
2286 str_arg =
2287# if defined(FEAT_EVAL)
2288 tvs != NULL ? tv_str(tvs, &arg_idx, &tofree) :
2289# endif
2290 va_arg(ap, char *);
2291 if (str_arg == NULL)
2292 {
2293 str_arg = "[NULL]";
2294 str_arg_l = 6;
2295 }
2296 // make sure not to address string beyond the specified
2297 // precision !!!
2298 else if (!precision_specified)
2299 str_arg_l = strlen(str_arg);
2300 // truncate string if necessary as requested by precision
2301 else if (precision == 0)
2302 str_arg_l = 0;
2303 else
2304 {
2305 // Don't put the #if inside memchr(), it can be a
2306 // macro.
2307 // memchr on HP does not like n > 2^31 !!!
2308 char *q = memchr(str_arg, '\0',
2309 precision <= (size_t)0x7fffffffL ? precision
2310 : (size_t)0x7fffffffL);
presukud85fccd2021-11-20 19:38:31 +00002311
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002312 str_arg_l = (q == NULL) ? precision
2313 : (size_t)(q - str_arg);
2314 }
2315 if (fmt_spec == 'S')
2316 {
presuku1f2453f2021-11-24 15:32:57 +00002317 char_u *p1;
2318 size_t i;
2319 int cell;
presukud85fccd2021-11-20 19:38:31 +00002320
presuku1f2453f2021-11-24 15:32:57 +00002321 for (i = 0, p1 = (char_u *)str_arg; *p1;
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002322 p1 += mb_ptr2len(p1))
presuku1f2453f2021-11-24 15:32:57 +00002323 {
2324 cell = mb_ptr2cells(p1);
2325 if (precision_specified && i + cell > precision)
2326 break;
2327 i += cell;
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002328 }
presuku1f2453f2021-11-24 15:32:57 +00002329
2330 str_arg_l = p1 - (char_u *)str_arg;
presukud85fccd2021-11-20 19:38:31 +00002331 if (min_field_width != 0)
presuku1f2453f2021-11-24 15:32:57 +00002332 min_field_width += str_arg_l - i;
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002333 }
2334 break;
2335
2336 default:
2337 break;
2338 }
2339 break;
2340
2341 case 'd': case 'u':
2342 case 'b': case 'B':
2343 case 'o':
2344 case 'x': case 'X':
2345 case 'p':
2346 {
2347 // NOTE: the u, b, o, x, X and p conversion specifiers
2348 // imply the value is unsigned; d implies a signed
2349 // value
2350
2351 // 0 if numeric argument is zero (or if pointer is
2352 // NULL for 'p'), +1 if greater than zero (or nonzero
2353 // for unsigned arguments), -1 if negative (unsigned
2354 // argument is never negative)
2355 int arg_sign = 0;
2356
2357 // only set for length modifier h, or for no length
2358 // modifiers
2359 int int_arg = 0;
2360 unsigned int uint_arg = 0;
2361
2362 // only set for length modifier l
2363 long int long_arg = 0;
2364 unsigned long int ulong_arg = 0;
2365
2366 // only set for length modifier ll
2367 varnumber_T llong_arg = 0;
2368 uvarnumber_T ullong_arg = 0;
2369
2370 // only set for b conversion
2371 uvarnumber_T bin_arg = 0;
2372
2373 // pointer argument value -only defined for p
2374 // conversion
2375 void *ptr_arg = NULL;
2376
2377 if (fmt_spec == 'p')
2378 {
2379 length_modifier = '\0';
2380 ptr_arg =
2381# if defined(FEAT_EVAL)
2382 tvs != NULL ? (void *)tv_str(tvs, &arg_idx,
2383 NULL) :
2384# endif
2385 va_arg(ap, void *);
2386 if (ptr_arg != NULL)
2387 arg_sign = 1;
2388 }
2389 else if (fmt_spec == 'b' || fmt_spec == 'B')
2390 {
2391 bin_arg =
2392# if defined(FEAT_EVAL)
2393 tvs != NULL ?
2394 (uvarnumber_T)tv_nr(tvs, &arg_idx) :
2395# endif
2396 va_arg(ap, uvarnumber_T);
2397 if (bin_arg != 0)
2398 arg_sign = 1;
2399 }
2400 else if (fmt_spec == 'd')
2401 {
2402 // signed
2403 switch (length_modifier)
2404 {
2405 case '\0':
2406 case 'h':
2407 // char and short arguments are passed as int.
2408 int_arg =
2409# if defined(FEAT_EVAL)
2410 tvs != NULL ? tv_nr(tvs, &arg_idx) :
2411# endif
2412 va_arg(ap, int);
2413 if (int_arg > 0)
2414 arg_sign = 1;
2415 else if (int_arg < 0)
2416 arg_sign = -1;
2417 break;
2418 case 'l':
2419 long_arg =
2420# if defined(FEAT_EVAL)
2421 tvs != NULL ? tv_nr(tvs, &arg_idx) :
2422# endif
2423 va_arg(ap, long int);
2424 if (long_arg > 0)
2425 arg_sign = 1;
2426 else if (long_arg < 0)
2427 arg_sign = -1;
2428 break;
2429 case 'L':
2430 llong_arg =
2431# if defined(FEAT_EVAL)
2432 tvs != NULL ? tv_nr(tvs, &arg_idx) :
2433# endif
2434 va_arg(ap, varnumber_T);
2435 if (llong_arg > 0)
2436 arg_sign = 1;
2437 else if (llong_arg < 0)
2438 arg_sign = -1;
2439 break;
2440 }
2441 }
2442 else
2443 {
2444 // unsigned
2445 switch (length_modifier)
2446 {
2447 case '\0':
2448 case 'h':
2449 uint_arg =
2450# if defined(FEAT_EVAL)
2451 tvs != NULL ? (unsigned)
2452 tv_nr(tvs, &arg_idx) :
2453# endif
2454 va_arg(ap, unsigned int);
2455 if (uint_arg != 0)
2456 arg_sign = 1;
2457 break;
2458 case 'l':
2459 ulong_arg =
2460# if defined(FEAT_EVAL)
2461 tvs != NULL ? (unsigned long)
2462 tv_nr(tvs, &arg_idx) :
2463# endif
2464 va_arg(ap, unsigned long int);
2465 if (ulong_arg != 0)
2466 arg_sign = 1;
2467 break;
2468 case 'L':
2469 ullong_arg =
2470# if defined(FEAT_EVAL)
2471 tvs != NULL ? (uvarnumber_T)
2472 tv_nr(tvs, &arg_idx) :
2473# endif
2474 va_arg(ap, uvarnumber_T);
2475 if (ullong_arg != 0)
2476 arg_sign = 1;
2477 break;
2478 }
2479 }
2480
2481 str_arg = tmp;
2482 str_arg_l = 0;
2483
2484 // NOTE:
2485 // For d, i, u, o, x, and X conversions, if precision is
2486 // specified, the '0' flag should be ignored. This is so
2487 // with Solaris 2.6, Digital UNIX 4.0, HPUX 10, Linux,
2488 // FreeBSD, NetBSD; but not with Perl.
2489 if (precision_specified)
2490 zero_padding = 0;
2491 if (fmt_spec == 'd')
2492 {
2493 if (force_sign && arg_sign >= 0)
2494 tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
2495 // leave negative numbers for sprintf to handle, to
2496 // avoid handling tricky cases like (short int)-32768
2497 }
2498 else if (alternate_form)
2499 {
2500 if (arg_sign != 0
2501 && (fmt_spec == 'b' || fmt_spec == 'B'
2502 || fmt_spec == 'x' || fmt_spec == 'X') )
2503 {
2504 tmp[str_arg_l++] = '0';
2505 tmp[str_arg_l++] = fmt_spec;
2506 }
2507 // alternate form should have no effect for p
2508 // conversion, but ...
2509 }
2510
2511 zero_padding_insertion_ind = str_arg_l;
2512 if (!precision_specified)
2513 precision = 1; // default precision is 1
2514 if (precision == 0 && arg_sign == 0)
2515 {
2516 // When zero value is formatted with an explicit
2517 // precision 0, the resulting formatted string is
2518 // empty (d, i, u, b, B, o, x, X, p).
2519 }
2520 else
2521 {
2522 char f[6];
2523 int f_l = 0;
2524
2525 // construct a simple format string for sprintf
2526 f[f_l++] = '%';
2527 if (!length_modifier)
2528 ;
2529 else if (length_modifier == 'L')
2530 {
2531# ifdef MSWIN
2532 f[f_l++] = 'I';
2533 f[f_l++] = '6';
2534 f[f_l++] = '4';
2535# else
2536 f[f_l++] = 'l';
2537 f[f_l++] = 'l';
2538# endif
2539 }
2540 else
2541 f[f_l++] = length_modifier;
2542 f[f_l++] = fmt_spec;
2543 f[f_l++] = '\0';
2544
2545 if (fmt_spec == 'p')
2546 str_arg_l += sprintf(tmp + str_arg_l, f, ptr_arg);
2547 else if (fmt_spec == 'b' || fmt_spec == 'B')
2548 {
2549 char b[8 * sizeof(uvarnumber_T)];
2550 size_t b_l = 0;
2551 uvarnumber_T bn = bin_arg;
2552
2553 do
2554 {
2555 b[sizeof(b) - ++b_l] = '0' + (bn & 0x1);
2556 bn >>= 1;
2557 }
2558 while (bn != 0);
2559
2560 memcpy(tmp + str_arg_l, b + sizeof(b) - b_l, b_l);
2561 str_arg_l += b_l;
2562 }
2563 else if (fmt_spec == 'd')
2564 {
2565 // signed
2566 switch (length_modifier)
2567 {
2568 case '\0': str_arg_l += sprintf(
2569 tmp + str_arg_l, f,
2570 int_arg);
2571 break;
2572 case 'h': str_arg_l += sprintf(
2573 tmp + str_arg_l, f,
2574 (short)int_arg);
2575 break;
2576 case 'l': str_arg_l += sprintf(
2577 tmp + str_arg_l, f, long_arg);
2578 break;
2579 case 'L': str_arg_l += sprintf(
2580 tmp + str_arg_l, f, llong_arg);
2581 break;
2582 }
2583 }
2584 else
2585 {
2586 // unsigned
2587 switch (length_modifier)
2588 {
2589 case '\0': str_arg_l += sprintf(
2590 tmp + str_arg_l, f,
2591 uint_arg);
2592 break;
2593 case 'h': str_arg_l += sprintf(
2594 tmp + str_arg_l, f,
2595 (unsigned short)uint_arg);
2596 break;
2597 case 'l': str_arg_l += sprintf(
2598 tmp + str_arg_l, f, ulong_arg);
2599 break;
2600 case 'L': str_arg_l += sprintf(
2601 tmp + str_arg_l, f, ullong_arg);
2602 break;
2603 }
2604 }
2605
2606 // include the optional minus sign and possible
2607 // "0x" in the region before the zero padding
2608 // insertion point
2609 if (zero_padding_insertion_ind < str_arg_l
2610 && tmp[zero_padding_insertion_ind] == '-')
2611 zero_padding_insertion_ind++;
2612 if (zero_padding_insertion_ind + 1 < str_arg_l
2613 && tmp[zero_padding_insertion_ind] == '0'
2614 && (tmp[zero_padding_insertion_ind + 1] == 'x'
2615 || tmp[zero_padding_insertion_ind + 1] == 'X'))
2616 zero_padding_insertion_ind += 2;
2617 }
2618
2619 {
2620 size_t num_of_digits = str_arg_l
2621 - zero_padding_insertion_ind;
2622
2623 if (alternate_form && fmt_spec == 'o'
2624 // unless zero is already the first
2625 // character
2626 && !(zero_padding_insertion_ind < str_arg_l
2627 && tmp[zero_padding_insertion_ind] == '0'))
2628 {
2629 // assure leading zero for alternate-form
2630 // octal numbers
2631 if (!precision_specified
2632 || precision < num_of_digits + 1)
2633 {
2634 // precision is increased to force the
2635 // first character to be zero, except if a
2636 // zero value is formatted with an
2637 // explicit precision of zero
2638 precision = num_of_digits + 1;
2639 }
2640 }
2641 // zero padding to specified precision?
2642 if (num_of_digits < precision)
2643 number_of_zeros_to_pad = precision - num_of_digits;
2644 }
2645 // zero padding to specified minimal field width?
2646 if (!justify_left && zero_padding)
2647 {
2648 int n = (int)(min_field_width - (str_arg_l
2649 + number_of_zeros_to_pad));
2650 if (n > 0)
2651 number_of_zeros_to_pad += n;
2652 }
2653 break;
2654 }
2655
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002656 case 'f':
2657 case 'F':
2658 case 'e':
2659 case 'E':
2660 case 'g':
2661 case 'G':
2662 {
2663 // Floating point.
2664 double f;
2665 double abs_f;
2666 char format[40];
2667 int l;
2668 int remove_trailing_zeroes = FALSE;
2669
2670 f =
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002671# if defined(FEAT_EVAL)
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002672 tvs != NULL ? tv_float(tvs, &arg_idx) :
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002673# endif
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002674 va_arg(ap, double);
2675 abs_f = f < 0 ? -f : f;
2676
2677 if (fmt_spec == 'g' || fmt_spec == 'G')
2678 {
2679 // Would be nice to use %g directly, but it prints
2680 // "1.0" as "1", we don't want that.
2681 if ((abs_f >= 0.001 && abs_f < 10000000.0)
2682 || abs_f == 0.0)
2683 fmt_spec = ASCII_ISUPPER(fmt_spec) ? 'F' : 'f';
2684 else
2685 fmt_spec = fmt_spec == 'g' ? 'e' : 'E';
2686 remove_trailing_zeroes = TRUE;
2687 }
2688
2689 if ((fmt_spec == 'f' || fmt_spec == 'F') &&
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002690# ifdef VAX
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002691 abs_f > 1.0e38
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002692# else
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002693 abs_f > 1.0e307
Bram Moolenaar73e28dc2022-09-17 21:08:33 +01002694# endif
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002695 )
2696 {
2697 // Avoid a buffer overflow
2698 STRCPY(tmp, infinity_str(f > 0.0, fmt_spec,
2699 force_sign, space_for_positive));
2700 str_arg_l = STRLEN(tmp);
2701 zero_padding = 0;
2702 }
2703 else
2704 {
2705 if (isnan(f))
2706 {
2707 // Not a number: nan or NAN
2708 STRCPY(tmp, ASCII_ISUPPER(fmt_spec) ? "NAN"
2709 : "nan");
2710 str_arg_l = 3;
2711 zero_padding = 0;
2712 }
2713 else if (isinf(f))
2714 {
2715 STRCPY(tmp, infinity_str(f > 0.0, fmt_spec,
2716 force_sign, space_for_positive));
2717 str_arg_l = STRLEN(tmp);
2718 zero_padding = 0;
2719 }
2720 else
2721 {
2722 // Regular float number
2723 format[0] = '%';
2724 l = 1;
2725 if (force_sign)
2726 format[l++] = space_for_positive ? ' ' : '+';
2727 if (precision_specified)
2728 {
2729 size_t max_prec = TMP_LEN - 10;
2730
2731 // Make sure we don't get more digits than we
2732 // have room for.
2733 if ((fmt_spec == 'f' || fmt_spec == 'F')
2734 && abs_f > 1.0)
2735 max_prec -= (size_t)log10(abs_f);
2736 if (precision > max_prec)
2737 precision = max_prec;
2738 l += sprintf(format + l, ".%d", (int)precision);
2739 }
2740 format[l] = fmt_spec == 'F' ? 'f' : fmt_spec;
2741 format[l + 1] = NUL;
2742
2743 str_arg_l = sprintf(tmp, format, f);
2744 }
2745
2746 if (remove_trailing_zeroes)
2747 {
2748 int i;
2749 char *tp;
2750
2751 // Using %g or %G: remove superfluous zeroes.
2752 if (fmt_spec == 'f' || fmt_spec == 'F')
2753 tp = tmp + str_arg_l - 1;
2754 else
2755 {
2756 tp = (char *)vim_strchr((char_u *)tmp,
2757 fmt_spec == 'e' ? 'e' : 'E');
2758 if (tp != NULL)
2759 {
2760 // Remove superfluous '+' and leading
2761 // zeroes from the exponent.
2762 if (tp[1] == '+')
2763 {
2764 // Change "1.0e+07" to "1.0e07"
2765 STRMOVE(tp + 1, tp + 2);
2766 --str_arg_l;
2767 }
2768 i = (tp[1] == '-') ? 2 : 1;
2769 while (tp[i] == '0')
2770 {
2771 // Change "1.0e07" to "1.0e7"
2772 STRMOVE(tp + i, tp + i + 1);
2773 --str_arg_l;
2774 }
2775 --tp;
2776 }
2777 }
2778
2779 if (tp != NULL && !precision_specified)
2780 // Remove trailing zeroes, but keep the one
2781 // just after a dot.
2782 while (tp > tmp + 2 && *tp == '0'
2783 && tp[-1] != '.')
2784 {
2785 STRMOVE(tp, tp + 1);
2786 --tp;
2787 --str_arg_l;
2788 }
2789 }
2790 else
2791 {
2792 char *tp;
2793
2794 // Be consistent: some printf("%e") use 1.0e+12
2795 // and some 1.0e+012. Remove one zero in the last
2796 // case.
2797 tp = (char *)vim_strchr((char_u *)tmp,
2798 fmt_spec == 'e' ? 'e' : 'E');
2799 if (tp != NULL && (tp[1] == '+' || tp[1] == '-')
2800 && tp[2] == '0'
2801 && vim_isdigit(tp[3])
2802 && vim_isdigit(tp[4]))
2803 {
2804 STRMOVE(tp + 2, tp + 3);
2805 --str_arg_l;
2806 }
2807 }
2808 }
2809 if (zero_padding && min_field_width > str_arg_l
2810 && (tmp[0] == '-' || force_sign))
2811 {
2812 // padding 0's should be inserted after the sign
2813 number_of_zeros_to_pad = min_field_width - str_arg_l;
2814 zero_padding_insertion_ind = 1;
2815 }
2816 str_arg = tmp;
2817 break;
2818 }
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002819
2820 default:
2821 // unrecognized conversion specifier, keep format string
2822 // as-is
2823 zero_padding = 0; // turn zero padding off for non-numeric
2824 // conversion
2825 justify_left = 1;
2826 min_field_width = 0; // reset flags
2827
2828 // discard the unrecognized conversion, just keep *
2829 // the unrecognized conversion character
2830 str_arg = p;
2831 str_arg_l = 0;
2832 if (*p != NUL)
2833 str_arg_l++; // include invalid conversion specifier
2834 // unchanged if not at end-of-string
2835 break;
2836 }
2837
2838 if (*p != NUL)
2839 p++; // step over the just processed conversion specifier
2840
2841 // insert padding to the left as requested by min_field_width;
2842 // this does not include the zero padding in case of numerical
2843 // conversions
2844 if (!justify_left)
2845 {
2846 // left padding with blank or zero
2847 int pn = (int)(min_field_width - (str_arg_l + number_of_zeros_to_pad));
2848
2849 if (pn > 0)
2850 {
2851 if (str_l < str_m)
2852 {
2853 size_t avail = str_m - str_l;
2854
2855 vim_memset(str + str_l, zero_padding ? '0' : ' ',
2856 (size_t)pn > avail ? avail
2857 : (size_t)pn);
2858 }
2859 str_l += pn;
2860 }
2861 }
2862
2863 // zero padding as requested by the precision or by the minimal
2864 // field width for numeric conversions required?
2865 if (number_of_zeros_to_pad == 0)
2866 {
2867 // will not copy first part of numeric right now, *
2868 // force it to be copied later in its entirety
2869 zero_padding_insertion_ind = 0;
2870 }
2871 else
2872 {
2873 // insert first part of numerics (sign or '0x') before zero
2874 // padding
2875 int zn = (int)zero_padding_insertion_ind;
2876
2877 if (zn > 0)
2878 {
2879 if (str_l < str_m)
2880 {
2881 size_t avail = str_m - str_l;
2882
2883 mch_memmove(str + str_l, str_arg,
2884 (size_t)zn > avail ? avail
2885 : (size_t)zn);
2886 }
2887 str_l += zn;
2888 }
2889
2890 // insert zero padding as requested by the precision or min
2891 // field width
2892 zn = (int)number_of_zeros_to_pad;
2893 if (zn > 0)
2894 {
2895 if (str_l < str_m)
2896 {
2897 size_t avail = str_m - str_l;
2898
2899 vim_memset(str + str_l, '0',
2900 (size_t)zn > avail ? avail
2901 : (size_t)zn);
2902 }
2903 str_l += zn;
2904 }
2905 }
2906
2907 // insert formatted string
2908 // (or as-is conversion specifier for unknown conversions)
2909 {
2910 int sn = (int)(str_arg_l - zero_padding_insertion_ind);
2911
2912 if (sn > 0)
2913 {
2914 if (str_l < str_m)
2915 {
2916 size_t avail = str_m - str_l;
2917
2918 mch_memmove(str + str_l,
2919 str_arg + zero_padding_insertion_ind,
2920 (size_t)sn > avail ? avail : (size_t)sn);
2921 }
2922 str_l += sn;
2923 }
2924 }
2925
2926 // insert right padding
2927 if (justify_left)
2928 {
2929 // right blank padding to the field width
2930 int pn = (int)(min_field_width
2931 - (str_arg_l + number_of_zeros_to_pad));
2932
2933 if (pn > 0)
2934 {
2935 if (str_l < str_m)
2936 {
2937 size_t avail = str_m - str_l;
2938
2939 vim_memset(str + str_l, ' ',
2940 (size_t)pn > avail ? avail
2941 : (size_t)pn);
2942 }
2943 str_l += pn;
2944 }
2945 }
2946 vim_free(tofree);
2947 }
2948 }
2949
2950 if (str_m > 0)
2951 {
2952 // make sure the string is nul-terminated even at the expense of
2953 // overwriting the last character (shouldn't happen, but just in case)
2954 //
2955 str[str_l <= str_m - 1 ? str_l : str_m - 1] = '\0';
2956 }
2957
2958 if (tvs != NULL && tvs[arg_idx - 1].v_type != VAR_UNKNOWN)
Bram Moolenaar677658a2022-01-05 16:09:06 +00002959 emsg(_(e_too_many_arguments_to_printf));
Yegappan Lakshmanan8ee52af2021-08-09 19:59:06 +02002960
2961 // Return the number of characters formatted (excluding trailing nul
2962 // character), that is, the number of characters that would have been
2963 // written to the buffer if it were large enough.
2964 return (int)str_l;
2965}
2966
2967#endif // PROTO