Mercurial > vim
annotate src/strings.c @ 32381:8b7ba5c63996 v9.0.1522
patch 9.0.1522: some functions give two error messages
Commit: https://github.com/vim/vim/commit/e4098457ab9c94225b1b0e3c5e06b82b75587971
Author: Bram Moolenaar <Bram@vim.org>
Date: Sun May 7 18:53:49 2023 +0100
patch 9.0.1522: some functions give two error messages
Problem: Some functions give two error messages.
Solution: Do not give a second error message. (closes https://github.com/vim/vim/issues/12352)
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Sun, 07 May 2023 20:00:03 +0200 |
parents | d5e673b941cd |
children | 49a13ac4a1b1 |
rev | line source |
---|---|
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1 /* vi:set ts=8 sts=4 sw=4 noet: |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2 * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
3 * VIM - Vi IMproved by Bram Moolenaar |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
4 * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
5 * Do ":help uganda" in Vim to read copying and usage conditions. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
6 * Do ":help credits" in Vim to see a list of people who contributed. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
7 * See README.txt for an overview of the Vim source code. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
8 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
9 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
10 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
11 * strings.c: string manipulation functions |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
12 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
13 |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
14 #define USING_FLOAT_STUFF |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
15 #include "vim.h" |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
16 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
17 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
18 * Copy "string" into newly allocated memory. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
19 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
20 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
21 vim_strsave(char_u *string) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
22 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
23 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
24 size_t len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
25 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
26 len = STRLEN(string) + 1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
27 p = alloc(len); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
28 if (p != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
29 mch_memmove(p, string, len); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
30 return p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
31 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
32 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
33 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
34 * Copy up to "len" bytes of "string" into newly allocated memory and |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
35 * terminate with a NUL. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
36 * The allocated memory always has size "len + 1", also when "string" is |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
37 * shorter. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
38 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
39 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
40 vim_strnsave(char_u *string, size_t len) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
41 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
42 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
43 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
44 p = alloc(len + 1); |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
45 if (p == NULL) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
46 return NULL; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
47 |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
48 STRNCPY(p, string, len); |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
49 p[len] = NUL; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
50 return p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
51 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
52 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
53 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
54 * Same as vim_strsave(), but any characters found in esc_chars are preceded |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
55 * by a backslash. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
56 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
57 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
58 vim_strsave_escaped(char_u *string, char_u *esc_chars) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
59 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
60 return vim_strsave_escaped_ext(string, esc_chars, '\\', FALSE); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
61 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
62 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
63 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
64 * Same as vim_strsave_escaped(), but when "bsl" is TRUE also escape |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
65 * characters where rem_backslash() would remove the backslash. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
66 * Escape the characters with "cc". |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
67 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
68 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
69 vim_strsave_escaped_ext( |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
70 char_u *string, |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
71 char_u *esc_chars, |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
72 int cc, |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
73 int bsl) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
74 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
75 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
76 char_u *p2; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
77 char_u *escaped_string; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
78 unsigned length; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
79 int l; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
80 |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
81 // First count the number of backslashes required. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
82 // Then allocate the memory and insert them. |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
83 length = 1; // count the trailing NUL |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
84 for (p = string; *p; p++) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
85 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
86 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
87 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
88 length += l; // count a multibyte char |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
89 p += l - 1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
90 continue; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
91 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
92 if (vim_strchr(esc_chars, *p) != NULL || (bsl && rem_backslash(p))) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
93 ++length; // count a backslash |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
94 ++length; // count an ordinary char |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
95 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
96 escaped_string = alloc(length); |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
97 if (escaped_string == NULL) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
98 return NULL; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
99 p2 = escaped_string; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
100 for (p = string; *p; p++) |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
101 { |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
102 if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
103 { |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
104 mch_memmove(p2, p, (size_t)l); |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
105 p2 += l; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
106 p += l - 1; // skip multibyte char |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
107 continue; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
108 } |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
109 if (vim_strchr(esc_chars, *p) != NULL || (bsl && rem_backslash(p))) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
110 *p2++ = cc; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
111 *p2++ = *p; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
112 } |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
113 *p2 = NUL; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
114 return escaped_string; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
115 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
116 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
117 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
118 * Return TRUE when 'shell' has "csh" in the tail. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
119 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
120 int |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
121 csh_like_shell(void) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
122 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
123 return (strstr((char *)gettail(p_sh), "csh") != NULL); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
124 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
125 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
126 /* |
25698
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
127 * Return TRUE when 'shell' has "fish" in the tail. |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
128 */ |
25703
e9687a2f6fb3
patch 8.2.3387: compiler warning for non-static function
Bram Moolenaar <Bram@vim.org>
parents:
25698
diff
changeset
|
129 static int |
25698
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
130 fish_like_shell(void) |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
131 { |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
132 return (strstr((char *)gettail(p_sh), "fish") != NULL); |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
133 } |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
134 |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
135 /* |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
136 * Escape "string" for use as a shell argument with system(). |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
137 * This uses single quotes, except when we know we need to use double quotes |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
138 * (MS-DOS and MS-Windows not using PowerShell and without 'shellslash' set). |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
139 * PowerShell also uses a novel escaping for enclosed single quotes - double |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
140 * them up. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
141 * Escape a newline, depending on the 'shell' option. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
142 * When "do_special" is TRUE also replace "!", "%", "#" and things starting |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
143 * with "<" like "<cfile>". |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
144 * When "do_newline" is FALSE do not escape newline unless it is csh shell. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
145 * Returns the result in allocated memory, NULL if we have run out. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
146 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
147 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
148 vim_strsave_shellescape(char_u *string, int do_special, int do_newline) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
149 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
150 unsigned length; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
151 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
152 char_u *d; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
153 char_u *escaped_string; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
154 int l; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
155 int csh_like; |
25698
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
156 int fish_like; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
157 char_u *shname; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
158 int powershell; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
159 # ifdef MSWIN |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
160 int double_quotes; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
161 # endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
162 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
163 // Only csh and similar shells expand '!' within single quotes. For sh and |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
164 // the like we must not put a backslash before it, it will be taken |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
165 // literally. If do_special is set the '!' will be escaped twice. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
166 // Csh also needs to have "\n" escaped twice when do_special is set. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
167 csh_like = csh_like_shell(); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
168 |
25698
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
169 // Fish shell uses '\' as an escape character within single quotes, so '\' |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
170 // itself must be escaped to get a literal '\'. |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
171 fish_like = fish_like_shell(); |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
172 |
26771
fc859aea8cec
patch 8.2.3914: various spelling mistakes in comments
Bram Moolenaar <Bram@vim.org>
parents:
26759
diff
changeset
|
173 // PowerShell uses its own version for quoting single quotes |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
174 shname = gettail(p_sh); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
175 powershell = strstr((char *)shname, "pwsh") != NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
176 # ifdef MSWIN |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
177 powershell = powershell || strstr((char *)shname, "powershell") != NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
178 // PowerShell only accepts single quotes so override shellslash. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
179 double_quotes = !powershell && !p_ssl; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
180 # endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
181 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
182 // First count the number of extra bytes required. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
183 length = (unsigned)STRLEN(string) + 3; // two quotes and a trailing NUL |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
184 for (p = string; *p != NUL; MB_PTR_ADV(p)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
185 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
186 # ifdef MSWIN |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
187 if (double_quotes) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
188 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
189 if (*p == '"') |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
190 ++length; // " -> "" |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
191 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
192 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
193 # endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
194 if (*p == '\'') |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
195 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
196 if (powershell) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
197 length +=2; // ' => '' |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
198 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
199 length += 3; // ' => '\'' |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
200 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
201 if ((*p == '\n' && (csh_like || do_newline)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
202 || (*p == '!' && (csh_like || do_special))) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
203 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
204 ++length; // insert backslash |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
205 if (csh_like && do_special) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
206 ++length; // insert backslash |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
207 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
208 if (do_special && find_cmdline_var(p, &l) >= 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
209 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
210 ++length; // insert backslash |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
211 p += l - 1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
212 } |
25698
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
213 if (*p == '\\' && fish_like) |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
214 ++length; // insert backslash |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
215 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
216 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
217 // Allocate memory for the result and fill it. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
218 escaped_string = alloc(length); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
219 if (escaped_string != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
220 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
221 d = escaped_string; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
222 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
223 // add opening quote |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
224 # ifdef MSWIN |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
225 if (double_quotes) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
226 *d++ = '"'; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
227 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
228 # endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
229 *d++ = '\''; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
230 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
231 for (p = string; *p != NUL; ) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
232 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
233 # ifdef MSWIN |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
234 if (double_quotes) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
235 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
236 if (*p == '"') |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
237 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
238 *d++ = '"'; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
239 *d++ = '"'; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
240 ++p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
241 continue; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
242 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
243 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
244 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
245 # endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
246 if (*p == '\'') |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
247 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
248 if (powershell) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
249 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
250 *d++ = '\''; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
251 *d++ = '\''; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
252 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
253 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
254 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
255 *d++ = '\''; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
256 *d++ = '\\'; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
257 *d++ = '\''; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
258 *d++ = '\''; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
259 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
260 ++p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
261 continue; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
262 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
263 if ((*p == '\n' && (csh_like || do_newline)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
264 || (*p == '!' && (csh_like || do_special))) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
265 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
266 *d++ = '\\'; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
267 if (csh_like && do_special) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
268 *d++ = '\\'; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
269 *d++ = *p++; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
270 continue; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
271 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
272 if (do_special && find_cmdline_var(p, &l) >= 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
273 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
274 *d++ = '\\'; // insert backslash |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
275 while (--l >= 0) // copy the var |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
276 *d++ = *p++; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
277 continue; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
278 } |
25698
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
279 if (*p == '\\' && fish_like) |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
280 { |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
281 *d++ = '\\'; |
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
282 *d++ = *p++; |
25715
454cbc872368
patch 8.2.3393: escaping for fish shell is skipping some characters
Bram Moolenaar <Bram@vim.org>
parents:
25703
diff
changeset
|
283 continue; |
25698
000b37efd5fa
patch 8.2.3385: escaping for fish shell does not work properly
Bram Moolenaar <Bram@vim.org>
parents:
25567
diff
changeset
|
284 } |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
285 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
286 MB_COPY_CHAR(p, d); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
287 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
288 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
289 // add terminating quote and finish with a NUL |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
290 # ifdef MSWIN |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
291 if (double_quotes) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
292 *d++ = '"'; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
293 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
294 # endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
295 *d++ = '\''; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
296 *d = NUL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
297 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
298 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
299 return escaped_string; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
300 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
301 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
302 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
303 * Like vim_strsave(), but make all characters uppercase. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
304 * This uses ASCII lower-to-upper case translation, language independent. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
305 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
306 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
307 vim_strsave_up(char_u *string) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
308 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
309 char_u *p1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
310 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
311 p1 = vim_strsave(string); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
312 vim_strup(p1); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
313 return p1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
314 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
315 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
316 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
317 * Like vim_strnsave(), but make all characters uppercase. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
318 * This uses ASCII lower-to-upper case translation, language independent. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
319 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
320 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
321 vim_strnsave_up(char_u *string, size_t len) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
322 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
323 char_u *p1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
324 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
325 p1 = vim_strnsave(string, len); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
326 vim_strup(p1); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
327 return p1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
328 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
329 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
330 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
331 * ASCII lower-to-upper case translation, language independent. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
332 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
333 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
334 vim_strup( |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
335 char_u *p) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
336 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
337 char_u *p2; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
338 int c; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
339 |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
340 if (p == NULL) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
341 return; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
342 |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
343 p2 = p; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
344 while ((c = *p2) != NUL) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
345 *p2++ = (c < 'a' || c > 'z') ? c : (c - 0x20); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
346 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
347 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
348 #if defined(FEAT_EVAL) || defined(FEAT_SPELL) || defined(PROTO) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
349 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
350 * Make string "s" all upper-case and return it in allocated memory. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
351 * Handles multi-byte characters as well as possible. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
352 * Returns NULL when out of memory. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
353 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
354 static char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
355 strup_save(char_u *orig) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
356 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
357 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
358 char_u *res; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
359 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
360 res = p = vim_strsave(orig); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
361 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
362 if (res != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
363 while (*p != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
364 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
365 int l; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
366 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
367 if (enc_utf8) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
368 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
369 int c, uc; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
370 int newl; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
371 char_u *s; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
372 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
373 c = utf_ptr2char(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
374 l = utf_ptr2len(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
375 if (c == 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
376 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
377 // overlong sequence, use only the first byte |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
378 c = *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
379 l = 1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
380 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
381 uc = utf_toupper(c); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
382 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
383 // Reallocate string when byte count changes. This is rare, |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
384 // thus it's OK to do another malloc()/free(). |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
385 newl = utf_char2len(uc); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
386 if (newl != l) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
387 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
388 s = alloc(STRLEN(res) + 1 + newl - l); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
389 if (s == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
390 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
391 vim_free(res); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
392 return NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
393 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
394 mch_memmove(s, res, p - res); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
395 STRCPY(s + (p - res) + newl, p + l); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
396 p = s + (p - res); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
397 vim_free(res); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
398 res = s; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
399 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
400 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
401 utf_char2bytes(uc, p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
402 p += newl; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
403 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
404 else if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
405 p += l; // skip multi-byte character |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
406 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
407 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
408 *p = TOUPPER_LOC(*p); // note that toupper() can be a macro |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
409 p++; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
410 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
411 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
412 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
413 return res; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
414 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
415 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
416 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
417 * Make string "s" all lower-case and return it in allocated memory. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
418 * Handles multi-byte characters as well as possible. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
419 * Returns NULL when out of memory. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
420 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
421 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
422 strlow_save(char_u *orig) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
423 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
424 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
425 char_u *res; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
426 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
427 res = p = vim_strsave(orig); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
428 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
429 if (res != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
430 while (*p != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
431 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
432 int l; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
433 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
434 if (enc_utf8) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
435 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
436 int c, lc; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
437 int newl; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
438 char_u *s; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
439 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
440 c = utf_ptr2char(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
441 l = utf_ptr2len(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
442 if (c == 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
443 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
444 // overlong sequence, use only the first byte |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
445 c = *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
446 l = 1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
447 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
448 lc = utf_tolower(c); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
449 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
450 // Reallocate string when byte count changes. This is rare, |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
451 // thus it's OK to do another malloc()/free(). |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
452 newl = utf_char2len(lc); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
453 if (newl != l) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
454 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
455 s = alloc(STRLEN(res) + 1 + newl - l); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
456 if (s == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
457 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
458 vim_free(res); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
459 return NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
460 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
461 mch_memmove(s, res, p - res); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
462 STRCPY(s + (p - res) + newl, p + l); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
463 p = s + (p - res); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
464 vim_free(res); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
465 res = s; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
466 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
467 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
468 utf_char2bytes(lc, p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
469 p += newl; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
470 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
471 else if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
472 p += l; // skip multi-byte character |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
473 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
474 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
475 *p = TOLOWER_LOC(*p); // note that tolower() can be a macro |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
476 p++; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
477 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
478 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
479 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
480 return res; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
481 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
482 #endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
483 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
484 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
485 * delete spaces at the end of a string |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
486 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
487 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
488 del_trailing_spaces(char_u *ptr) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
489 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
490 char_u *q; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
491 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
492 q = ptr + STRLEN(ptr); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
493 while (--q > ptr && VIM_ISWHITE(q[0]) && q[-1] != '\\' && q[-1] != Ctrl_V) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
494 *q = NUL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
495 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
496 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
497 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
498 * Like strncpy(), but always terminate the result with one NUL. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
499 * "to" must be "len + 1" long! |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
500 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
501 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
502 vim_strncpy(char_u *to, char_u *from, size_t len) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
503 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
504 STRNCPY(to, from, len); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
505 to[len] = NUL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
506 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
507 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
508 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
509 * Like strcat(), but make sure the result fits in "tosize" bytes and is |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
510 * always NUL terminated. "from" and "to" may overlap. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
511 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
512 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
513 vim_strcat(char_u *to, char_u *from, size_t tosize) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
514 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
515 size_t tolen = STRLEN(to); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
516 size_t fromlen = STRLEN(from); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
517 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
518 if (tolen + fromlen + 1 > tosize) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
519 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
520 mch_memmove(to + tolen, from, tosize - tolen - 1); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
521 to[tosize - 1] = NUL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
522 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
523 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
524 mch_memmove(to + tolen, from, fromlen + 1); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
525 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
526 |
31624
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
527 /* |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
528 * A version of strlen() that has a maximum length. |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
529 */ |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
530 size_t |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
531 vim_strlen_maxlen(char *s, size_t maxlen) |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
532 { |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
533 size_t i; |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
534 for (i = 0; i < maxlen; ++i) |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
535 if (s[i] == NUL) |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
536 break; |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
537 return i; |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
538 } |
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
539 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
540 #if (!defined(HAVE_STRCASECMP) && !defined(HAVE_STRICMP)) || defined(PROTO) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
541 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
542 * Compare two strings, ignoring case, using current locale. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
543 * Doesn't work for multi-byte characters. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
544 * return 0 for match, < 0 for smaller, > 0 for bigger |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
545 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
546 int |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
547 vim_stricmp(char *s1, char *s2) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
548 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
549 int i; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
550 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
551 for (;;) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
552 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
553 i = (int)TOLOWER_LOC(*s1) - (int)TOLOWER_LOC(*s2); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
554 if (i != 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
555 return i; // this character different |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
556 if (*s1 == NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
557 break; // strings match until NUL |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
558 ++s1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
559 ++s2; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
560 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
561 return 0; // strings match |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
562 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
563 #endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
564 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
565 #if (!defined(HAVE_STRNCASECMP) && !defined(HAVE_STRNICMP)) || defined(PROTO) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
566 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
567 * Compare two strings, for length "len", ignoring case, using current locale. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
568 * Doesn't work for multi-byte characters. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
569 * return 0 for match, < 0 for smaller, > 0 for bigger |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
570 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
571 int |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
572 vim_strnicmp(char *s1, char *s2, size_t len) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
573 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
574 int i; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
575 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
576 while (len > 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
577 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
578 i = (int)TOLOWER_LOC(*s1) - (int)TOLOWER_LOC(*s2); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
579 if (i != 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
580 return i; // this character different |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
581 if (*s1 == NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
582 break; // strings match until NUL |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
583 ++s1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
584 ++s2; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
585 --len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
586 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
587 return 0; // strings match |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
588 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
589 #endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
590 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
591 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
592 * Search for first occurrence of "c" in "string". |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
593 * Version of strchr() that handles unsigned char strings with characters from |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
594 * 128 to 255 correctly. It also doesn't return a pointer to the NUL at the |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
595 * end of the string. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
596 */ |
31624
d605a50e7623
patch 9.0.1144: reading beyond text
Bram Moolenaar <Bram@vim.org>
parents:
30566
diff
changeset
|
597 char_u * |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
598 vim_strchr(char_u *string, int c) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
599 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
600 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
601 int b; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
602 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
603 p = string; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
604 if (enc_utf8 && c >= 0x80) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
605 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
606 while (*p != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
607 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
608 int l = utfc_ptr2len(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
609 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
610 // Avoid matching an illegal byte here. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
611 if (utf_ptr2char(p) == c && l > 1) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
612 return p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
613 p += l; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
614 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
615 return NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
616 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
617 if (enc_dbcs != 0 && c > 255) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
618 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
619 int n2 = c & 0xff; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
620 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
621 c = ((unsigned)c >> 8) & 0xff; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
622 while ((b = *p) != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
623 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
624 if (b == c && p[1] == n2) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
625 return p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
626 p += (*mb_ptr2len)(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
627 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
628 return NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
629 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
630 if (has_mbyte) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
631 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
632 while ((b = *p) != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
633 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
634 if (b == c) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
635 return p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
636 p += (*mb_ptr2len)(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
637 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
638 return NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
639 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
640 while ((b = *p) != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
641 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
642 if (b == c) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
643 return p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
644 ++p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
645 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
646 return NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
647 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
648 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
649 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
650 * Version of strchr() that only works for bytes and handles unsigned char |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
651 * strings with characters above 128 correctly. It also doesn't return a |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
652 * pointer to the NUL at the end of the string. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
653 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
654 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
655 vim_strbyte(char_u *string, int c) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
656 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
657 char_u *p = string; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
658 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
659 while (*p != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
660 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
661 if (*p == c) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
662 return p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
663 ++p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
664 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
665 return NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
666 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
667 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
668 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
669 * Search for last occurrence of "c" in "string". |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
670 * Version of strrchr() that handles unsigned char strings with characters from |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
671 * 128 to 255 correctly. It also doesn't return a pointer to the NUL at the |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
672 * end of the string. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
673 * Return NULL if not found. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
674 * Does not handle multi-byte char for "c"! |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
675 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
676 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
677 vim_strrchr(char_u *string, int c) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
678 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
679 char_u *retval = NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
680 char_u *p = string; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
681 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
682 while (*p) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
683 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
684 if (*p == c) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
685 retval = p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
686 MB_PTR_ADV(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
687 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
688 return retval; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
689 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
690 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
691 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
692 * Vim's version of strpbrk(), in case it's missing. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
693 * Don't generate a prototype for this, causes problems when it's not used. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
694 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
695 #ifndef PROTO |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
696 # ifndef HAVE_STRPBRK |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
697 # ifdef vim_strpbrk |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
698 # undef vim_strpbrk |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
699 # endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
700 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
701 vim_strpbrk(char_u *s, char_u *charset) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
702 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
703 while (*s) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
704 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
705 if (vim_strchr(charset, *s) != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
706 return s; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
707 MB_PTR_ADV(s); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
708 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
709 return NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
710 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
711 # endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
712 #endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
713 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
714 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
715 * Sort an array of strings. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
716 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
717 static int sort_compare(const void *s1, const void *s2); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
718 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
719 static int |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
720 sort_compare(const void *s1, const void *s2) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
721 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
722 return STRCMP(*(char **)s1, *(char **)s2); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
723 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
724 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
725 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
726 sort_strings( |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
727 char_u **files, |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
728 int count) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
729 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
730 qsort((void *)files, (size_t)count, sizeof(char_u *), sort_compare); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
731 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
732 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
733 #if defined(FEAT_QUICKFIX) || defined(FEAT_SPELL) || defined(PROTO) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
734 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
735 * Return TRUE if string "s" contains a non-ASCII character (128 or higher). |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
736 * When "s" is NULL FALSE is returned. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
737 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
738 int |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
739 has_non_ascii(char_u *s) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
740 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
741 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
742 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
743 if (s != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
744 for (p = s; *p != NUL; ++p) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
745 if (*p >= 128) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
746 return TRUE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
747 return FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
748 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
749 #endif |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
750 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
751 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
752 * Concatenate two strings and return the result in allocated memory. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
753 * Returns NULL when out of memory. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
754 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
755 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
756 concat_str(char_u *str1, char_u *str2) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
757 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
758 char_u *dest; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
759 size_t l = str1 == NULL ? 0 : STRLEN(str1); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
760 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
761 dest = alloc(l + (str2 == NULL ? 0 : STRLEN(str2)) + 1L); |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
762 if (dest == NULL) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
763 return NULL; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
764 if (str1 == NULL) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
765 *dest = NUL; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
766 else |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
767 STRCPY(dest, str1); |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
768 if (str2 != NULL) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
769 STRCPY(dest + l, str2); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
770 return dest; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
771 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
772 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
773 #if defined(FEAT_EVAL) || defined(PROTO) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
774 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
775 * Return string "str" in ' quotes, doubling ' characters. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
776 * If "str" is NULL an empty string is assumed. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
777 * If "function" is TRUE make it function('string'). |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
778 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
779 char_u * |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
780 string_quote(char_u *str, int function) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
781 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
782 unsigned len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
783 char_u *p, *r, *s; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
784 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
785 len = (function ? 13 : 3); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
786 if (str != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
787 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
788 len += (unsigned)STRLEN(str); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
789 for (p = str; *p != NUL; MB_PTR_ADV(p)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
790 if (*p == '\'') |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
791 ++len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
792 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
793 s = r = alloc(len); |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
794 if (r == NULL) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
795 return NULL; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
796 |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
797 if (function) |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
798 { |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
799 STRCPY(r, "function('"); |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
800 r += 10; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
801 } |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
802 else |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
803 *r++ = '\''; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
804 if (str != NULL) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
805 for (p = str; *p != NUL; ) |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
806 { |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
807 if (*p == '\'') |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
808 *r++ = '\''; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
809 MB_COPY_CHAR(p, r); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
810 } |
31809
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
811 *r++ = '\''; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
812 if (function) |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
813 *r++ = ')'; |
543153d582d5
patch 9.0.1237: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31624
diff
changeset
|
814 *r++ = NUL; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
815 return s; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
816 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
817 |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
818 /* |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
819 * Count the number of times "needle" occurs in string "haystack". Case is |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
820 * ignored if "ic" is TRUE. |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
821 */ |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
822 long |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
823 string_count(char_u *haystack, char_u *needle, int ic) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
824 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
825 long n = 0; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
826 char_u *p = haystack; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
827 char_u *next; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
828 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
829 if (p == NULL || needle == NULL || *needle == NUL) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
830 return 0; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
831 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
832 if (ic) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
833 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
834 size_t len = STRLEN(needle); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
835 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
836 while (*p != NUL) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
837 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
838 if (MB_STRNICMP(p, needle, len) == 0) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
839 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
840 ++n; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
841 p += len; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
842 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
843 else |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
844 MB_PTR_ADV(p); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
845 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
846 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
847 else |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
848 while ((next = (char_u *)strstr((char *)p, (char *)needle)) != NULL) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
849 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
850 ++n; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
851 p = next + STRLEN(needle); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
852 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
853 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
854 return n; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
855 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
856 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
857 /* |
32367
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
858 * Reverse the string in 'str' and set the result in 'rettv'. |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
859 */ |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
860 void |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
861 string_reverse(char_u *str, typval_T *rettv) |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
862 { |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
863 rettv->v_type = VAR_STRING; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
864 rettv->vval.v_string = NULL; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
865 if (str == NULL) |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
866 return; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
867 |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
868 char_u *rstr = vim_strsave(str); |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
869 rettv->vval.v_string = rstr; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
870 if (rstr == NULL || *str == NUL) |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
871 return; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
872 |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
873 size_t len = STRLEN(rstr); |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
874 if (has_mbyte) |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
875 { |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
876 char_u *src = str; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
877 char_u *dest = rstr + len; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
878 |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
879 while (src < str + len) |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
880 { |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
881 int clen = mb_ptr2len(src); |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
882 dest -= clen; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
883 mch_memmove(dest, src, (size_t)clen); |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
884 src += clen; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
885 } |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
886 } |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
887 else |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
888 { |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
889 for (size_t i = 0; i < len / 2; i++) |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
890 { |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
891 char tmp = rstr[len - i - 1]; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
892 rstr[len - i - 1] = rstr[i]; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
893 rstr[i] = tmp; |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
894 } |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
895 } |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
896 } |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
897 |
d5e673b941cd
patch 9.0.1515: reverse() does not work for a String
Bram Moolenaar <Bram@vim.org>
parents:
32307
diff
changeset
|
898 /* |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
899 * Make a typval_T of the first character of "input" and store it in "output". |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
900 * Return OK or FAIL. |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
901 */ |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
902 static int |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
903 copy_first_char_to_tv(char_u *input, typval_T *output) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
904 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
905 char_u buf[MB_MAXBYTES + 1]; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
906 int len; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
907 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
908 if (input == NULL || output == NULL) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
909 return FAIL; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
910 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
911 len = has_mbyte ? mb_ptr2len(input) : 1; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
912 STRNCPY(buf, input, len); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
913 buf[len] = NUL; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
914 output->v_type = VAR_STRING; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
915 output->vval.v_string = vim_strsave(buf); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
916 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
917 return output->vval.v_string == NULL ? FAIL : OK; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
918 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
919 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
920 /* |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
921 * Implementation of map() and filter() for a String. Apply "expr" to every |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
922 * character in string "str" and return the result in "rettv". |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
923 */ |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
924 void |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
925 string_filter_map( |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
926 char_u *str, |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
927 filtermap_T filtermap, |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
928 typval_T *expr, |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
929 typval_T *rettv) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
930 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
931 char_u *p; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
932 typval_T tv; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
933 garray_T ga; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
934 int len = 0; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
935 int idx = 0; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
936 int rem; |
30566
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
937 typval_T newtv; |
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
938 funccall_T *fc; |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
939 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
940 rettv->v_type = VAR_STRING; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
941 rettv->vval.v_string = NULL; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
942 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
943 // set_vim_var_nr() doesn't set the type |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
944 set_vim_var_type(VV_KEY, VAR_NUMBER); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
945 |
32256
252b06c87796
patch 9.0.1459: typo in name of type
Bram Moolenaar <Bram@vim.org>
parents:
32098
diff
changeset
|
946 // Create one funccall_T for all eval_expr_typval() calls. |
30566
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
947 fc = eval_expr_get_funccal(expr, &newtv); |
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
948 |
27028
c9474ae175f4
patch 8.2.4043: using int for second argument of ga_init2()
Bram Moolenaar <Bram@vim.org>
parents:
26962
diff
changeset
|
949 ga_init2(&ga, sizeof(char), 80); |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
950 for (p = str; *p != NUL; p += len) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
951 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
952 if (copy_first_char_to_tv(p, &tv) == FAIL) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
953 break; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
954 len = (int)STRLEN(tv.vval.v_string); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
955 |
28708
094a70434f90
patch 8.2.4878: valgrind warning for using uninitialized variable
Bram Moolenaar <Bram@vim.org>
parents:
27490
diff
changeset
|
956 newtv.v_type = VAR_UNKNOWN; |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
957 set_vim_var_nr(VV_KEY, idx); |
30566
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
958 if (filter_map_one(&tv, expr, filtermap, fc, &newtv, &rem) == FAIL |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
959 || did_emsg) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
960 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
961 clear_tv(&newtv); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
962 clear_tv(&tv); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
963 break; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
964 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
965 else if (filtermap != FILTERMAP_FILTER) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
966 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
967 if (newtv.v_type != VAR_STRING) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
968 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
969 clear_tv(&newtv); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
970 clear_tv(&tv); |
26879
da89514c3b72
patch 8.2.3968: build failure
Bram Moolenaar <Bram@vim.org>
parents:
26865
diff
changeset
|
971 emsg(_(e_string_required)); |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
972 break; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
973 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
974 else |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
975 ga_concat(&ga, newtv.vval.v_string); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
976 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
977 else if (!rem) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
978 ga_concat(&ga, tv.vval.v_string); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
979 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
980 clear_tv(&newtv); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
981 clear_tv(&tv); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
982 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
983 ++idx; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
984 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
985 ga_append(&ga, NUL); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
986 rettv->vval.v_string = ga.ga_data; |
30566
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
987 if (fc != NULL) |
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
988 remove_funccal(); |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
989 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
990 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
991 /* |
30425
6c2bbd7d9217
patch 9.0.0548: reduce() with a compiled lambda could be faster
Bram Moolenaar <Bram@vim.org>
parents:
30310
diff
changeset
|
992 * Implementation of reduce() for String "argvars[0]" using the function "expr" |
6c2bbd7d9217
patch 9.0.0548: reduce() with a compiled lambda could be faster
Bram Moolenaar <Bram@vim.org>
parents:
30310
diff
changeset
|
993 * starting with the optional initial value "argvars[2]" and return the result |
6c2bbd7d9217
patch 9.0.0548: reduce() with a compiled lambda could be faster
Bram Moolenaar <Bram@vim.org>
parents:
30310
diff
changeset
|
994 * in "rettv". |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
995 */ |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
996 void |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
997 string_reduce( |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
998 typval_T *argvars, |
30425
6c2bbd7d9217
patch 9.0.0548: reduce() with a compiled lambda could be faster
Bram Moolenaar <Bram@vim.org>
parents:
30310
diff
changeset
|
999 typval_T *expr, |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1000 typval_T *rettv) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1001 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1002 char_u *p = tv_get_string(&argvars[0]); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1003 int len; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1004 typval_T argv[3]; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1005 int r; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1006 int called_emsg_start = called_emsg; |
30566
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
1007 funccall_T *fc; |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1008 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1009 if (argvars[2].v_type == VAR_UNKNOWN) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1010 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1011 if (*p == NUL) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1012 { |
26879
da89514c3b72
patch 8.2.3968: build failure
Bram Moolenaar <Bram@vim.org>
parents:
26865
diff
changeset
|
1013 semsg(_(e_reduce_of_an_empty_str_with_no_initial_value), "String"); |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1014 return; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1015 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1016 if (copy_first_char_to_tv(p, rettv) == FAIL) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1017 return; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1018 p += STRLEN(rettv->vval.v_string); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1019 } |
30043
fd855ad74887
patch 9.0.0359: error message for wrong argument type is not specific
Bram Moolenaar <Bram@vim.org>
parents:
28708
diff
changeset
|
1020 else if (check_for_string_arg(argvars, 2) == FAIL) |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1021 return; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1022 else |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1023 copy_tv(&argvars[2], rettv); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1024 |
32256
252b06c87796
patch 9.0.1459: typo in name of type
Bram Moolenaar <Bram@vim.org>
parents:
32098
diff
changeset
|
1025 // Create one funccall_T for all eval_expr_typval() calls. |
30566
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
1026 fc = eval_expr_get_funccal(expr, rettv); |
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
1027 |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1028 for ( ; *p != NUL; p += len) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1029 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1030 argv[0] = *rettv; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1031 if (copy_first_char_to_tv(p, &argv[1]) == FAIL) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1032 break; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1033 len = (int)STRLEN(argv[1].vval.v_string); |
30425
6c2bbd7d9217
patch 9.0.0548: reduce() with a compiled lambda could be faster
Bram Moolenaar <Bram@vim.org>
parents:
30310
diff
changeset
|
1034 |
30566
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
1035 r = eval_expr_typval(expr, argv, 2, fc, rettv); |
30425
6c2bbd7d9217
patch 9.0.0548: reduce() with a compiled lambda could be faster
Bram Moolenaar <Bram@vim.org>
parents:
30310
diff
changeset
|
1036 |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1037 clear_tv(&argv[0]); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1038 clear_tv(&argv[1]); |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1039 if (r == FAIL || called_emsg != called_emsg_start) |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1040 return; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1041 } |
30566
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
1042 |
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
1043 if (fc != NULL) |
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
1044 remove_funccal(); |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1045 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1046 |
32381
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1047 /* |
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1048 * Implementation of "byteidx()" and "byteidxcomp()" functions |
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1049 */ |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1050 static void |
32381
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1051 byteidx_common(typval_T *argvars, typval_T *rettv, int comp UNUSED) |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1052 { |
25252
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1053 rettv->vval.v_number = -1; |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1054 |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1055 if (in_vim9script() |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1056 && (check_for_string_arg(argvars, 0) == FAIL |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1057 || check_for_number_arg(argvars, 1) == FAIL)) |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1058 return; |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1059 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1060 char_u *str = tv_get_string_chk(&argvars[0]); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1061 varnumber_T idx = tv_get_number_chk(&argvars[1], NULL); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1062 if (str == NULL || idx < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1063 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1064 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1065 varnumber_T utf16idx = FALSE; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1066 if (argvars[2].v_type != VAR_UNKNOWN) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1067 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1068 utf16idx = tv_get_bool(&argvars[2]); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1069 if (utf16idx < 0 || utf16idx > 1) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1070 { |
32381
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1071 if (utf16idx != -1) |
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1072 semsg(_(e_using_number_as_bool_nr), utf16idx); |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1073 return; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1074 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1075 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1076 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1077 int (*ptr2len)(char_u *); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1078 if (enc_utf8 && comp) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1079 ptr2len = utf_ptr2len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1080 else |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1081 ptr2len = mb_ptr2len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1082 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1083 char_u *t = str; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1084 for ( ; idx > 0; idx--) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1085 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1086 if (*t == NUL) // EOL reached |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1087 return; |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1088 if (utf16idx) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1089 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1090 int clen = ptr2len(t); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1091 int c = (clen > 1) ? utf_ptr2char(t) : *t; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1092 if (c > 0xFFFF) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1093 idx--; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1094 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1095 if (idx > 0) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1096 t += ptr2len(t); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1097 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1098 rettv->vval.v_number = (varnumber_T)(t - str); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1099 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1100 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1101 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1102 * "byteidx()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1103 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1104 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1105 f_byteidx(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1106 { |
32381
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1107 byteidx_common(argvars, rettv, FALSE); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1108 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1109 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1110 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1111 * "byteidxcomp()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1112 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1113 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1114 f_byteidxcomp(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1115 { |
32381
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1116 byteidx_common(argvars, rettv, TRUE); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1117 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1118 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1119 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1120 * "charidx()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1121 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1122 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1123 f_charidx(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1124 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1125 rettv->vval.v_number = -1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1126 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1127 if (check_for_string_arg(argvars, 0) == FAIL |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1128 || check_for_number_arg(argvars, 1) == FAIL |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1129 || check_for_opt_bool_arg(argvars, 2) == FAIL |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1130 || (argvars[2].v_type != VAR_UNKNOWN |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1131 && check_for_opt_bool_arg(argvars, 3) == FAIL)) |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1132 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1133 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1134 char_u *str = tv_get_string_chk(&argvars[0]); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1135 varnumber_T idx = tv_get_number_chk(&argvars[1], NULL); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1136 if (str == NULL || idx < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1137 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1138 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1139 varnumber_T countcc = FALSE; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1140 varnumber_T utf16idx = FALSE; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1141 if (argvars[2].v_type != VAR_UNKNOWN) |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1142 { |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1143 countcc = tv_get_bool(&argvars[2]); |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1144 if (argvars[3].v_type != VAR_UNKNOWN) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1145 utf16idx = tv_get_bool(&argvars[3]); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1146 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1147 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1148 int (*ptr2len)(char_u *); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1149 if (enc_utf8 && countcc) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1150 ptr2len = utf_ptr2len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1151 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1152 ptr2len = mb_ptr2len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1153 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1154 char_u *p; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1155 int len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1156 for (p = str, len = 0; utf16idx ? idx >= 0 : p <= str + idx; len++) |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1157 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1158 if (*p == NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1159 return; |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1160 if (utf16idx) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1161 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1162 idx--; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1163 int clen = ptr2len(p); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1164 int c = (clen > 1) ? utf_ptr2char(p) : *p; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1165 if (c > 0xFFFF) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1166 idx--; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1167 } |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1168 p += ptr2len(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1169 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1170 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1171 rettv->vval.v_number = len > 0 ? len - 1 : 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1172 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1173 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1174 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1175 * "str2list()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1176 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1177 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1178 f_str2list(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1179 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1180 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1181 int utf8 = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1182 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1183 if (rettv_list_alloc(rettv) == FAIL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1184 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1185 |
25272
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1186 if (in_vim9script() |
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1187 && (check_for_string_arg(argvars, 0) == FAIL |
25302
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1188 || check_for_opt_bool_arg(argvars, 1) == FAIL)) |
25272
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1189 return; |
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1190 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1191 if (argvars[1].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1192 utf8 = (int)tv_get_bool_chk(&argvars[1], NULL); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1193 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1194 p = tv_get_string(&argvars[0]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1195 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1196 if (has_mbyte || utf8) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1197 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1198 int (*ptr2len)(char_u *); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1199 int (*ptr2char)(char_u *); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1200 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1201 if (utf8 || enc_utf8) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1202 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1203 ptr2len = utf_ptr2len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1204 ptr2char = utf_ptr2char; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1205 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1206 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1207 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1208 ptr2len = mb_ptr2len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1209 ptr2char = mb_ptr2char; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1210 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1211 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1212 for ( ; *p != NUL; p += (*ptr2len)(p)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1213 list_append_number(rettv->vval.v_list, (*ptr2char)(p)); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1214 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1215 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1216 for ( ; *p != NUL; ++p) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1217 list_append_number(rettv->vval.v_list, *p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1218 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1219 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1220 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1221 * "str2nr()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1222 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1223 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1224 f_str2nr(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1225 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1226 int base = 10; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1227 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1228 varnumber_T n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1229 int what = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1230 int isneg; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1231 |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1232 if (in_vim9script() |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1233 && (check_for_string_arg(argvars, 0) == FAIL |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1234 || check_for_opt_number_arg(argvars, 1) == FAIL |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1235 || (argvars[1].v_type != VAR_UNKNOWN |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1236 && check_for_opt_bool_arg(argvars, 2) == FAIL))) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1237 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1238 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1239 if (argvars[1].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1240 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1241 base = (int)tv_get_number(&argvars[1]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1242 if (base != 2 && base != 8 && base != 10 && base != 16) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1243 { |
26865
bce848ec8b1b
patch 8.2.3961: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1244 emsg(_(e_invalid_argument)); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1245 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1246 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1247 if (argvars[2].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[2])) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1248 what |= STR2NR_QUOTE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1249 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1250 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1251 p = skipwhite(tv_get_string_strict(&argvars[0])); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1252 isneg = (*p == '-'); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1253 if (*p == '+' || *p == '-') |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1254 p = skipwhite(p + 1); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1255 switch (base) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1256 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1257 case 2: what |= STR2NR_BIN + STR2NR_FORCE; break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1258 case 8: what |= STR2NR_OCT + STR2NR_OOCT + STR2NR_FORCE; break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1259 case 16: what |= STR2NR_HEX + STR2NR_FORCE; break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1260 } |
32098
39f4126d2a0d
patch 9.0.1380: CTRL-X on 2**64 subtracts two
Bram Moolenaar <Bram@vim.org>
parents:
31809
diff
changeset
|
1261 vim_str2nr(p, NULL, NULL, what, &n, NULL, 0, FALSE, NULL); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1262 // Text after the number is silently ignored. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1263 if (isneg) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1264 rettv->vval.v_number = -n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1265 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1266 rettv->vval.v_number = n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1267 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1268 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1269 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1270 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1271 * "strgetchar()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1272 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1273 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1274 f_strgetchar(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1275 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1276 char_u *str; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1277 int len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1278 int error = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1279 int charidx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1280 int byteidx = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1281 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1282 rettv->vval.v_number = -1; |
25252
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1283 |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1284 if (in_vim9script() |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1285 && (check_for_string_arg(argvars, 0) == FAIL |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1286 || check_for_number_arg(argvars, 1) == FAIL)) |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1287 return; |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1288 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1289 str = tv_get_string_chk(&argvars[0]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1290 if (str == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1291 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1292 len = (int)STRLEN(str); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1293 charidx = (int)tv_get_number_chk(&argvars[1], &error); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1294 if (error) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1295 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1296 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1297 while (charidx >= 0 && byteidx < len) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1298 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1299 if (charidx == 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1300 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1301 rettv->vval.v_number = mb_ptr2char(str + byteidx); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1302 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1303 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1304 --charidx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1305 byteidx += MB_CPTR2LEN(str + byteidx); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1306 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1307 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1308 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1309 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1310 * "stridx()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1311 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1312 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1313 f_stridx(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1314 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1315 char_u buf[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1316 char_u *needle; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1317 char_u *haystack; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1318 char_u *save_haystack; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1319 char_u *pos; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1320 int start_idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1321 |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1322 if (in_vim9script() |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1323 && (check_for_string_arg(argvars, 0) == FAIL |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1324 || check_for_string_arg(argvars, 1) == FAIL |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1325 || check_for_opt_number_arg(argvars, 2) == FAIL)) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1326 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1327 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1328 needle = tv_get_string_chk(&argvars[1]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1329 save_haystack = haystack = tv_get_string_buf_chk(&argvars[0], buf); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1330 rettv->vval.v_number = -1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1331 if (needle == NULL || haystack == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1332 return; // type error; errmsg already given |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1333 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1334 if (argvars[2].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1335 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1336 int error = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1337 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1338 start_idx = (int)tv_get_number_chk(&argvars[2], &error); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1339 if (error || start_idx >= (int)STRLEN(haystack)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1340 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1341 if (start_idx >= 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1342 haystack += start_idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1343 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1344 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1345 pos = (char_u *)strstr((char *)haystack, (char *)needle); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1346 if (pos != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1347 rettv->vval.v_number = (varnumber_T)(pos - save_haystack); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1348 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1349 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1350 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1351 * "string()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1352 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1353 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1354 f_string(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1355 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1356 char_u *tofree; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1357 char_u numbuf[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1358 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1359 rettv->v_type = VAR_STRING; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1360 rettv->vval.v_string = tv2string(&argvars[0], &tofree, numbuf, |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1361 get_copyID()); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1362 // Make a copy if we have a value but it's not in allocated memory. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1363 if (rettv->vval.v_string != NULL && tofree == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1364 rettv->vval.v_string = vim_strsave(rettv->vval.v_string); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1365 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1366 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1367 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1368 * "strlen()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1369 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1370 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1371 f_strlen(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1372 { |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1373 if (in_vim9script() |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1374 && check_for_string_or_number_arg(argvars, 0) == FAIL) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1375 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1376 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1377 rettv->vval.v_number = (varnumber_T)(STRLEN( |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1378 tv_get_string(&argvars[0]))); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1379 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1380 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1381 static void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1382 strchar_common(typval_T *argvars, typval_T *rettv, int skipcc) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1383 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1384 char_u *s = tv_get_string(&argvars[0]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1385 varnumber_T len = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1386 int (*func_mb_ptr2char_adv)(char_u **pp); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1387 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1388 func_mb_ptr2char_adv = skipcc ? mb_ptr2char_adv : mb_cptr2char_adv; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1389 while (*s != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1390 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1391 func_mb_ptr2char_adv(&s); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1392 ++len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1393 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1394 rettv->vval.v_number = len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1395 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1396 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1397 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1398 * "strcharlen()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1399 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1400 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1401 f_strcharlen(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1402 { |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1403 if (in_vim9script() |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1404 && check_for_string_or_number_arg(argvars, 0) == FAIL) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1405 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1406 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1407 strchar_common(argvars, rettv, TRUE); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1408 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1409 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1410 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1411 * "strchars()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1412 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1413 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1414 f_strchars(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1415 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1416 varnumber_T skipcc = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1417 |
25272
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1418 if (in_vim9script() |
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1419 && (check_for_string_arg(argvars, 0) == FAIL |
25302
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1420 || check_for_opt_bool_arg(argvars, 1) == FAIL)) |
25272
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1421 return; |
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1422 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1423 if (argvars[1].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1424 skipcc = tv_get_bool(&argvars[1]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1425 if (skipcc < 0 || skipcc > 1) |
32381
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1426 { |
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1427 if (skipcc != -1) |
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1428 semsg(_(e_using_number_as_bool_nr), skipcc); |
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1429 } |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1430 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1431 strchar_common(argvars, rettv, skipcc); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1432 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1433 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1434 /* |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1435 * "strutf16len()" function |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1436 */ |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1437 void |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1438 f_strutf16len(typval_T *argvars, typval_T *rettv) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1439 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1440 rettv->vval.v_number = -1; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1441 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1442 if (check_for_string_arg(argvars, 0) == FAIL |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1443 || check_for_opt_bool_arg(argvars, 1) == FAIL) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1444 return; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1445 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1446 varnumber_T countcc = FALSE; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1447 if (argvars[1].v_type != VAR_UNKNOWN) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1448 countcc = tv_get_bool(&argvars[1]); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1449 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1450 char_u *s = tv_get_string(&argvars[0]); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1451 varnumber_T len = 0; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1452 int (*func_mb_ptr2char_adv)(char_u **pp); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1453 int ch; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1454 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1455 func_mb_ptr2char_adv = countcc ? mb_cptr2char_adv : mb_ptr2char_adv; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1456 while (*s != NUL) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1457 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1458 ch = func_mb_ptr2char_adv(&s); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1459 if (ch > 0xFFFF) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1460 ++len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1461 ++len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1462 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1463 rettv->vval.v_number = len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1464 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1465 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1466 /* |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1467 * "strdisplaywidth()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1468 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1469 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1470 f_strdisplaywidth(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1471 { |
25252
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1472 char_u *s; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1473 int col = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1474 |
25252
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1475 rettv->vval.v_number = -1; |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1476 |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1477 if (in_vim9script() |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1478 && (check_for_string_arg(argvars, 0) == FAIL |
25302
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1479 || check_for_opt_number_arg(argvars, 1) == FAIL)) |
25252
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1480 return; |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1481 |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1482 s = tv_get_string(&argvars[0]); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1483 if (argvars[1].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1484 col = (int)tv_get_number(&argvars[1]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1485 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1486 rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s) - col); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1487 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1488 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1489 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1490 * "strwidth()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1491 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1492 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1493 f_strwidth(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1494 { |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1495 char_u *s; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1496 |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1497 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1498 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1499 |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1500 s = tv_get_string_strict(&argvars[0]); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1501 rettv->vval.v_number = (varnumber_T)(mb_string2cells(s, -1)); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1502 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1503 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1504 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1505 * "strcharpart()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1506 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1507 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1508 f_strcharpart(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1509 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1510 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1511 int nchar; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1512 int nbyte = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1513 int charlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1514 int skipcc = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1515 int len = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1516 int slen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1517 int error = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1518 |
25302
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1519 if (in_vim9script() |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1520 && (check_for_string_arg(argvars, 0) == FAIL |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1521 || check_for_number_arg(argvars, 1) == FAIL |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1522 || check_for_opt_number_arg(argvars, 2) == FAIL |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1523 || (argvars[2].v_type != VAR_UNKNOWN |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1524 && check_for_opt_bool_arg(argvars, 3) == FAIL))) |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1525 return; |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1526 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1527 p = tv_get_string(&argvars[0]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1528 slen = (int)STRLEN(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1529 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1530 nchar = (int)tv_get_number_chk(&argvars[1], &error); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1531 if (!error) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1532 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1533 if (argvars[2].v_type != VAR_UNKNOWN |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1534 && argvars[3].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1535 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1536 skipcc = tv_get_bool(&argvars[3]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1537 if (skipcc < 0 || skipcc > 1) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1538 { |
32381
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1539 if (skipcc != -1) |
8b7ba5c63996
patch 9.0.1522: some functions give two error messages
Bram Moolenaar <Bram@vim.org>
parents:
32367
diff
changeset
|
1540 semsg(_(e_using_number_as_bool_nr), skipcc); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1541 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1542 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1543 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1544 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1545 if (nchar > 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1546 while (nchar > 0 && nbyte < slen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1547 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1548 if (skipcc) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1549 nbyte += mb_ptr2len(p + nbyte); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1550 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1551 nbyte += MB_CPTR2LEN(p + nbyte); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1552 --nchar; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1553 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1554 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1555 nbyte = nchar; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1556 if (argvars[2].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1557 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1558 charlen = (int)tv_get_number(&argvars[2]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1559 while (charlen > 0 && nbyte + len < slen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1560 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1561 int off = nbyte + len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1562 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1563 if (off < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1564 len += 1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1565 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1566 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1567 if (skipcc) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1568 len += mb_ptr2len(p + off); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1569 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1570 len += MB_CPTR2LEN(p + off); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1571 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1572 --charlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1573 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1574 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1575 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1576 len = slen - nbyte; // default: all bytes that are available. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1577 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1578 |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1579 // Only return the overlap between the specified part and the actual |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1580 // string. |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1581 if (nbyte < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1582 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1583 len += nbyte; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1584 nbyte = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1585 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1586 else if (nbyte > slen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1587 nbyte = slen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1588 if (len < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1589 len = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1590 else if (nbyte + len > slen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1591 len = slen - nbyte; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1592 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1593 rettv->v_type = VAR_STRING; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1594 rettv->vval.v_string = vim_strnsave(p + nbyte, len); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1595 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1596 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1597 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1598 * "strpart()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1599 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1600 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1601 f_strpart(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1602 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1603 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1604 int n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1605 int len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1606 int slen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1607 int error = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1608 |
25302
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1609 if (in_vim9script() |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1610 && (check_for_string_arg(argvars, 0) == FAIL |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1611 || check_for_number_arg(argvars, 1) == FAIL |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1612 || check_for_opt_number_arg(argvars, 2) == FAIL |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1613 || (argvars[2].v_type != VAR_UNKNOWN |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1614 && check_for_opt_bool_arg(argvars, 3) == FAIL))) |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1615 return; |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1616 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1617 p = tv_get_string(&argvars[0]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1618 slen = (int)STRLEN(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1619 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1620 n = (int)tv_get_number_chk(&argvars[1], &error); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1621 if (error) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1622 len = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1623 else if (argvars[2].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1624 len = (int)tv_get_number(&argvars[2]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1625 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1626 len = slen - n; // default len: all bytes that are available. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1627 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1628 // Only return the overlap between the specified part and the actual |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1629 // string. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1630 if (n < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1631 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1632 len += n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1633 n = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1634 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1635 else if (n > slen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1636 n = slen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1637 if (len < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1638 len = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1639 else if (n + len > slen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1640 len = slen - n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1641 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1642 if (argvars[2].v_type != VAR_UNKNOWN && argvars[3].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1643 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1644 int off; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1645 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1646 // length in characters |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1647 for (off = n; off < slen && len > 0; --len) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1648 off += mb_ptr2len(p + off); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1649 len = off - n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1650 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1651 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1652 rettv->v_type = VAR_STRING; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1653 rettv->vval.v_string = vim_strnsave(p + n, len); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1654 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1655 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1656 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1657 * "strridx()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1658 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1659 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1660 f_strridx(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1661 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1662 char_u buf[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1663 char_u *needle; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1664 char_u *haystack; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1665 char_u *rest; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1666 char_u *lastmatch = NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1667 int haystack_len, end_idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1668 |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1669 if (in_vim9script() |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1670 && (check_for_string_arg(argvars, 0) == FAIL |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1671 || check_for_string_arg(argvars, 1) == FAIL |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1672 || check_for_opt_number_arg(argvars, 2) == FAIL)) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1673 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1674 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1675 needle = tv_get_string_chk(&argvars[1]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1676 haystack = tv_get_string_buf_chk(&argvars[0], buf); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1677 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1678 rettv->vval.v_number = -1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1679 if (needle == NULL || haystack == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1680 return; // type error; errmsg already given |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1681 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1682 haystack_len = (int)STRLEN(haystack); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1683 if (argvars[2].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1684 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1685 // Third argument: upper limit for index |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1686 end_idx = (int)tv_get_number_chk(&argvars[2], NULL); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1687 if (end_idx < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1688 return; // can never find a match |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1689 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1690 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1691 end_idx = haystack_len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1692 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1693 if (*needle == NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1694 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1695 // Empty string matches past the end. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1696 lastmatch = haystack + end_idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1697 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1698 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1699 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1700 for (rest = haystack; *rest != '\0'; ++rest) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1701 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1702 rest = (char_u *)strstr((char *)rest, (char *)needle); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1703 if (rest == NULL || rest > haystack + end_idx) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1704 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1705 lastmatch = rest; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1706 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1707 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1708 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1709 if (lastmatch == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1710 rettv->vval.v_number = -1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1711 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1712 rettv->vval.v_number = (varnumber_T)(lastmatch - haystack); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1713 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1714 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1715 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1716 * "strtrans()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1717 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1718 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1719 f_strtrans(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1720 { |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1721 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1722 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1723 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1724 rettv->v_type = VAR_STRING; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1725 rettv->vval.v_string = transstr(tv_get_string(&argvars[0])); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1726 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1727 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1728 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1729 /* |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1730 * |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1731 * "utf16idx()" function |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1732 */ |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1733 void |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1734 f_utf16idx(typval_T *argvars, typval_T *rettv) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1735 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1736 rettv->vval.v_number = -1; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1737 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1738 if (check_for_string_arg(argvars, 0) == FAIL |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1739 || check_for_opt_number_arg(argvars, 1) == FAIL |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1740 || check_for_opt_bool_arg(argvars, 2) == FAIL |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1741 || (argvars[2].v_type != VAR_UNKNOWN |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1742 && check_for_opt_bool_arg(argvars, 3) == FAIL)) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1743 return; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1744 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1745 char_u *str = tv_get_string_chk(&argvars[0]); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1746 varnumber_T idx = tv_get_number_chk(&argvars[1], NULL); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1747 if (str == NULL || idx < 0) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1748 return; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1749 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1750 varnumber_T countcc = FALSE; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1751 varnumber_T charidx = FALSE; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1752 if (argvars[2].v_type != VAR_UNKNOWN) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1753 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1754 countcc = tv_get_bool(&argvars[2]); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1755 if (argvars[3].v_type != VAR_UNKNOWN) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1756 charidx = tv_get_bool(&argvars[3]); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1757 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1758 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1759 int (*ptr2len)(char_u *); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1760 if (enc_utf8 && countcc) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1761 ptr2len = utf_ptr2len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1762 else |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1763 ptr2len = mb_ptr2len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1764 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1765 char_u *p; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1766 int len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1767 for (p = str, len = 0; charidx ? idx >= 0 : p <= str + idx; len++) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1768 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1769 if (*p == NUL) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1770 return; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1771 int clen = ptr2len(p); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1772 int c = (clen > 1) ? utf_ptr2char(p) : *p; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1773 if (c > 0xFFFF) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1774 len++; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1775 p += ptr2len(p); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1776 if (charidx) |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1777 idx--; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1778 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1779 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1780 rettv->vval.v_number = len > 0 ? len - 1 : 0; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1781 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1782 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1783 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1784 * "tolower(string)" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1785 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1786 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1787 f_tolower(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1788 { |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1789 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1790 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1791 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1792 rettv->v_type = VAR_STRING; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1793 rettv->vval.v_string = strlow_save(tv_get_string(&argvars[0])); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1794 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1795 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1796 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1797 * "toupper(string)" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1798 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1799 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1800 f_toupper(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1801 { |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1802 if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1803 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1804 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1805 rettv->v_type = VAR_STRING; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1806 rettv->vval.v_string = strup_save(tv_get_string(&argvars[0])); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1807 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1808 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1809 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1810 * "tr(string, fromstr, tostr)" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1811 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1812 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1813 f_tr(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1814 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1815 char_u *in_str; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1816 char_u *fromstr; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1817 char_u *tostr; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1818 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1819 int inlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1820 int fromlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1821 int tolen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1822 int idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1823 char_u *cpstr; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1824 int cplen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1825 int first = TRUE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1826 char_u buf[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1827 char_u buf2[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1828 garray_T ga; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1829 |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1830 if (in_vim9script() |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1831 && (check_for_string_arg(argvars, 0) == FAIL |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1832 || check_for_string_arg(argvars, 1) == FAIL |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1833 || check_for_string_arg(argvars, 2) == FAIL)) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1834 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1835 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1836 in_str = tv_get_string(&argvars[0]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1837 fromstr = tv_get_string_buf_chk(&argvars[1], buf); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1838 tostr = tv_get_string_buf_chk(&argvars[2], buf2); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1839 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1840 // Default return value: empty string. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1841 rettv->v_type = VAR_STRING; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1842 rettv->vval.v_string = NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1843 if (fromstr == NULL || tostr == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1844 return; // type error; errmsg already given |
27028
c9474ae175f4
patch 8.2.4043: using int for second argument of ga_init2()
Bram Moolenaar <Bram@vim.org>
parents:
26962
diff
changeset
|
1845 ga_init2(&ga, sizeof(char), 80); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1846 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1847 if (!has_mbyte) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1848 // not multi-byte: fromstr and tostr must be the same length |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1849 if (STRLEN(fromstr) != STRLEN(tostr)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1850 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1851 error: |
26865
bce848ec8b1b
patch 8.2.3961: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1852 semsg(_(e_invalid_argument_str), fromstr); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1853 ga_clear(&ga); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1854 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1855 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1856 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1857 // fromstr and tostr have to contain the same number of chars |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1858 while (*in_str != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1859 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1860 if (has_mbyte) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1861 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1862 inlen = (*mb_ptr2len)(in_str); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1863 cpstr = in_str; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1864 cplen = inlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1865 idx = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1866 for (p = fromstr; *p != NUL; p += fromlen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1867 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1868 fromlen = (*mb_ptr2len)(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1869 if (fromlen == inlen && STRNCMP(in_str, p, inlen) == 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1870 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1871 for (p = tostr; *p != NUL; p += tolen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1872 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1873 tolen = (*mb_ptr2len)(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1874 if (idx-- == 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1875 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1876 cplen = tolen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1877 cpstr = p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1878 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1879 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1880 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1881 if (*p == NUL) // tostr is shorter than fromstr |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1882 goto error; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1883 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1884 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1885 ++idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1886 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1887 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1888 if (first && cpstr == in_str) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1889 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1890 // Check that fromstr and tostr have the same number of |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1891 // (multi-byte) characters. Done only once when a character |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1892 // of in_str doesn't appear in fromstr. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1893 first = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1894 for (p = tostr; *p != NUL; p += tolen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1895 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1896 tolen = (*mb_ptr2len)(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1897 --idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1898 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1899 if (idx != 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1900 goto error; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1901 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1902 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1903 (void)ga_grow(&ga, cplen); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1904 mch_memmove((char *)ga.ga_data + ga.ga_len, cpstr, (size_t)cplen); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1905 ga.ga_len += cplen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1906 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1907 in_str += inlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1908 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1909 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1910 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1911 // When not using multi-byte chars we can do it faster. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1912 p = vim_strchr(fromstr, *in_str); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1913 if (p != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1914 ga_append(&ga, tostr[p - fromstr]); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1915 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1916 ga_append(&ga, *in_str); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1917 ++in_str; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1918 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1919 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1920 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1921 // add a terminating NUL |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1922 (void)ga_grow(&ga, 1); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1923 ga_append(&ga, NUL); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1924 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1925 rettv->vval.v_string = ga.ga_data; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1926 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1927 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1928 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1929 * "trim({expr})" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1930 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1931 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1932 f_trim(typval_T *argvars, typval_T *rettv) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1933 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1934 char_u buf1[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1935 char_u buf2[NUMBUFLEN]; |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1936 char_u *head; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1937 char_u *mask = NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1938 char_u *tail; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1939 char_u *prev; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1940 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1941 int c1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1942 int dir = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1943 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1944 rettv->v_type = VAR_STRING; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1945 rettv->vval.v_string = NULL; |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1946 |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1947 if (in_vim9script() |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1948 && (check_for_string_arg(argvars, 0) == FAIL |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1949 || check_for_opt_string_arg(argvars, 1) == FAIL |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1950 || (argvars[1].v_type != VAR_UNKNOWN |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1951 && check_for_opt_number_arg(argvars, 2) == FAIL))) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1952 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1953 |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
1954 head = tv_get_string_buf_chk(&argvars[0], buf1); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1955 if (head == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1956 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1957 |
30043
fd855ad74887
patch 9.0.0359: error message for wrong argument type is not specific
Bram Moolenaar <Bram@vim.org>
parents:
28708
diff
changeset
|
1958 if (check_for_opt_string_arg(argvars, 1) == FAIL) |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1959 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1960 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1961 if (argvars[1].v_type == VAR_STRING) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1962 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1963 mask = tv_get_string_buf_chk(&argvars[1], buf2); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1964 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1965 if (argvars[2].v_type != VAR_UNKNOWN) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1966 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1967 int error = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1968 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1969 // leading or trailing characters to trim |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1970 dir = (int)tv_get_number_chk(&argvars[2], &error); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1971 if (error) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1972 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1973 if (dir < 0 || dir > 2) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1974 { |
26865
bce848ec8b1b
patch 8.2.3961: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1975 semsg(_(e_invalid_argument_str), tv_get_string(&argvars[2])); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1976 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1977 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1978 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1979 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1980 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1981 if (dir == 0 || dir == 1) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1982 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1983 // Trim leading characters |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1984 while (*head != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1985 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1986 c1 = PTR2CHAR(head); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1987 if (mask == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1988 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1989 if (c1 > ' ' && c1 != 0xa0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1990 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1991 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1992 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1993 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1994 for (p = mask; *p != NUL; MB_PTR_ADV(p)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1995 if (c1 == PTR2CHAR(p)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1996 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1997 if (*p == NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1998 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1999 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2000 MB_PTR_ADV(head); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2001 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2002 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2003 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2004 tail = head + STRLEN(head); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2005 if (dir == 0 || dir == 2) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2006 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2007 // Trim trailing characters |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2008 for (; tail > head; tail = prev) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2009 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2010 prev = tail; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2011 MB_PTR_BACK(head, prev); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2012 c1 = PTR2CHAR(prev); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2013 if (mask == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2014 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2015 if (c1 > ' ' && c1 != 0xa0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2016 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2017 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2018 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2019 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2020 for (p = mask; *p != NUL; MB_PTR_ADV(p)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2021 if (c1 == PTR2CHAR(p)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2022 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2023 if (*p == NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2024 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2025 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2026 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2027 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2028 rettv->vval.v_string = vim_strnsave(head, tail - head); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2029 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
2030 |
26958
d92e0d85923f
patch 8.2.4008: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26879
diff
changeset
|
2031 static char *e_printf = N_(e_insufficient_arguments_for_printf); |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2032 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2033 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2034 * Get number argument from "idxp" entry in "tvs". First entry is 1. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2035 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2036 static varnumber_T |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2037 tv_nr(typval_T *tvs, int *idxp) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2038 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2039 int idx = *idxp - 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2040 varnumber_T n = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2041 int err = FALSE; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2042 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2043 if (tvs[idx].v_type == VAR_UNKNOWN) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2044 emsg(_(e_printf)); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2045 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2046 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2047 ++*idxp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2048 n = tv_get_number_chk(&tvs[idx], &err); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2049 if (err) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2050 n = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2051 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2052 return n; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2053 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2054 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2055 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2056 * Get string argument from "idxp" entry in "tvs". First entry is 1. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2057 * If "tofree" is NULL tv_get_string_chk() is used. Some types (e.g. List) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2058 * are not converted to a string. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2059 * If "tofree" is not NULL echo_string() is used. All types are converted to |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2060 * a string with the same format as ":echo". The caller must free "*tofree". |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2061 * Returns NULL for an error. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2062 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2063 static char * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2064 tv_str(typval_T *tvs, int *idxp, char_u **tofree) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2065 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2066 int idx = *idxp - 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2067 char *s = NULL; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2068 static char_u numbuf[NUMBUFLEN]; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2069 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2070 if (tvs[idx].v_type == VAR_UNKNOWN) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2071 emsg(_(e_printf)); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2072 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2073 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2074 ++*idxp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2075 if (tofree != NULL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2076 s = (char *)echo_string(&tvs[idx], tofree, numbuf, get_copyID()); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2077 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2078 s = (char *)tv_get_string_chk(&tvs[idx]); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2079 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2080 return s; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2081 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2082 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2083 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2084 * Get float argument from "idxp" entry in "tvs". First entry is 1. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2085 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2086 static double |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2087 tv_float(typval_T *tvs, int *idxp) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2088 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2089 int idx = *idxp - 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2090 double f = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2091 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2092 if (tvs[idx].v_type == VAR_UNKNOWN) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2093 emsg(_(e_printf)); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2094 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2095 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2096 ++*idxp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2097 if (tvs[idx].v_type == VAR_FLOAT) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2098 f = tvs[idx].vval.v_float; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2099 else if (tvs[idx].v_type == VAR_NUMBER) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2100 f = (double)tvs[idx].vval.v_number; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2101 else |
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
2102 emsg(_(e_expected_float_argument_for_printf)); |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2103 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2104 return f; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2105 } |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
2106 |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2107 #endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2108 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2109 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2110 * Return the representation of infinity for printf() function: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2111 * "-inf", "inf", "+inf", " inf", "-INF", "INF", "+INF" or " INF". |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2112 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2113 static const char * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2114 infinity_str(int positive, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2115 char fmt_spec, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2116 int force_sign, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2117 int space_for_positive) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2118 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2119 static const char *table[] = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2120 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2121 "-inf", "inf", "+inf", " inf", |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2122 "-INF", "INF", "+INF", " INF" |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2123 }; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2124 int idx = positive * (1 + force_sign + force_sign * space_for_positive); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2125 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2126 if (ASCII_ISUPPER(fmt_spec)) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2127 idx += 4; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2128 return table[idx]; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2129 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2130 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2131 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2132 * This code was included to provide a portable vsnprintf() and snprintf(). |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2133 * Some systems may provide their own, but we always use this one for |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2134 * consistency. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2135 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2136 * This code is based on snprintf.c - a portable implementation of snprintf |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2137 * by Mark Martinec <mark.martinec@ijs.si>, Version 2.2, 2000-10-06. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2138 * Included with permission. It was heavily modified to fit in Vim. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2139 * The original code, including useful comments, can be found here: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2140 * http://www.ijs.si/software/snprintf/ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2141 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2142 * This snprintf() only supports the following conversion specifiers: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2143 * s, c, d, u, o, x, X, p (and synonyms: i, D, U, O - see below) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2144 * with flags: '-', '+', ' ', '0' and '#'. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2145 * An asterisk is supported for field width as well as precision. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2146 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2147 * Limited support for floating point was added: 'f', 'F', 'e', 'E', 'g', 'G'. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2148 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2149 * Length modifiers 'h' (short int) and 'l' (long int) and 'll' (long long int) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2150 * are supported. NOTE: for 'll' the argument is varnumber_T or uvarnumber_T. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2151 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2152 * The locale is not used, the string is used as a byte string. This is only |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2153 * relevant for double-byte encodings where the second byte may be '%'. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2154 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2155 * It is permitted for "str_m" to be zero, and it is permitted to specify NULL |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2156 * pointer for resulting string argument if "str_m" is zero (as per ISO C99). |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2157 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2158 * The return value is the number of characters which would be generated |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2159 * for the given input, excluding the trailing NUL. If this value |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2160 * is greater or equal to "str_m", not all characters from the result |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2161 * have been stored in str, output bytes beyond the ("str_m"-1) -th character |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2162 * are discarded. If "str_m" is greater than zero it is guaranteed |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2163 * the resulting string will be NUL-terminated. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2164 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2165 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2166 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2167 * When va_list is not supported we only define vim_snprintf(). |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2168 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2169 * vim_vsnprintf_typval() can be invoked with either "va_list" or a list of |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2170 * "typval_T". When the latter is not used it must be NULL. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2171 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2172 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2173 // When generating prototypes all of this is skipped, cproto doesn't |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2174 // understand this. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2175 #ifndef PROTO |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2176 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2177 // Like vim_vsnprintf() but append to the string. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2178 int |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2179 vim_snprintf_add(char *str, size_t str_m, const char *fmt, ...) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2180 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2181 va_list ap; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2182 int str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2183 size_t len = STRLEN(str); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2184 size_t space; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2185 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2186 if (str_m <= len) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2187 space = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2188 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2189 space = str_m - len; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2190 va_start(ap, fmt); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2191 str_l = vim_vsnprintf(str + len, space, fmt, ap); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2192 va_end(ap); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2193 return str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2194 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2195 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2196 int |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2197 vim_snprintf(char *str, size_t str_m, const char *fmt, ...) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2198 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2199 va_list ap; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2200 int str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2201 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2202 va_start(ap, fmt); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2203 str_l = vim_vsnprintf(str, str_m, fmt, ap); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2204 va_end(ap); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2205 return str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2206 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2207 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2208 int |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2209 vim_vsnprintf( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2210 char *str, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2211 size_t str_m, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2212 const char *fmt, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2213 va_list ap) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2214 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2215 return vim_vsnprintf_typval(str, str_m, fmt, ap, NULL); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2216 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2217 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2218 int |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2219 vim_vsnprintf_typval( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2220 char *str, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2221 size_t str_m, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2222 const char *fmt, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2223 va_list ap, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2224 typval_T *tvs) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2225 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2226 size_t str_l = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2227 const char *p = fmt; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2228 int arg_idx = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2229 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2230 if (p == NULL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2231 p = ""; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2232 while (*p != NUL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2233 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2234 if (*p != '%') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2235 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2236 char *q = strchr(p + 1, '%'); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2237 size_t n = (q == NULL) ? STRLEN(p) : (size_t)(q - p); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2238 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2239 // Copy up to the next '%' or NUL without any changes. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2240 if (str_l < str_m) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2241 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2242 size_t avail = str_m - str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2243 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2244 mch_memmove(str + str_l, p, n > avail ? avail : n); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2245 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2246 p += n; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2247 str_l += n; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2248 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2249 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2250 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2251 size_t min_field_width = 0, precision = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2252 int zero_padding = 0, precision_specified = 0, justify_left = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2253 int alternate_form = 0, force_sign = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2254 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2255 // If both the ' ' and '+' flags appear, the ' ' flag should be |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2256 // ignored. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2257 int space_for_positive = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2258 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2259 // allowed values: \0, h, l, L |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2260 char length_modifier = '\0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2261 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2262 // temporary buffer for simple numeric->string conversion |
30310
029c59bf78f1
patch 9.0.0491: no good reason to build without the float feature
Bram Moolenaar <Bram@vim.org>
parents:
30043
diff
changeset
|
2263 # define TMP_LEN 350 // On my system 1e308 is the biggest number possible. |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2264 // That sounds reasonable to use as the maximum |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2265 // printable. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2266 char tmp[TMP_LEN]; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2267 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2268 // string address in case of string argument |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2269 const char *str_arg = NULL; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2270 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2271 // natural field width of arg without padding and sign |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2272 size_t str_arg_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2273 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2274 // unsigned char argument value - only defined for c conversion. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2275 // N.B. standard explicitly states the char argument for the c |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2276 // conversion is unsigned |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2277 unsigned char uchar_arg; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2278 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2279 // number of zeros to be inserted for numeric conversions as |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2280 // required by the precision or minimal field width |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2281 size_t number_of_zeros_to_pad = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2282 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2283 // index into tmp where zero padding is to be inserted |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2284 size_t zero_padding_insertion_ind = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2285 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2286 // current conversion specifier character |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2287 char fmt_spec = '\0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2288 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2289 // buffer for 's' and 'S' specs |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2290 char_u *tofree = NULL; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2291 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2292 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2293 p++; // skip '%' |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2294 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2295 // parse flags |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2296 while (*p == '0' || *p == '-' || *p == '+' || *p == ' ' |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2297 || *p == '#' || *p == '\'') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2298 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2299 switch (*p) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2300 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2301 case '0': zero_padding = 1; break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2302 case '-': justify_left = 1; break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2303 case '+': force_sign = 1; space_for_positive = 0; break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2304 case ' ': force_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2305 // If both the ' ' and '+' flags appear, the ' ' |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2306 // flag should be ignored |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2307 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2308 case '#': alternate_form = 1; break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2309 case '\'': break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2310 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2311 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2312 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2313 // If the '0' and '-' flags both appear, the '0' flag should be |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2314 // ignored. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2315 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2316 // parse field width |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2317 if (*p == '*') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2318 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2319 int j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2320 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2321 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2322 j = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2323 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2324 tvs != NULL ? tv_nr(tvs, &arg_idx) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2325 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2326 va_arg(ap, int); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2327 if (j >= 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2328 min_field_width = j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2329 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2330 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2331 min_field_width = -j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2332 justify_left = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2333 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2334 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2335 else if (VIM_ISDIGIT((int)(*p))) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2336 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2337 // size_t could be wider than unsigned int; make sure we treat |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2338 // argument like common implementations do |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2339 unsigned int uj = *p++ - '0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2340 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2341 while (VIM_ISDIGIT((int)(*p))) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2342 uj = 10 * uj + (unsigned int)(*p++ - '0'); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2343 min_field_width = uj; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2344 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2345 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2346 // parse precision |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2347 if (*p == '.') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2348 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2349 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2350 precision_specified = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2351 if (*p == '*') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2352 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2353 int j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2354 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2355 j = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2356 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2357 tvs != NULL ? tv_nr(tvs, &arg_idx) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2358 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2359 va_arg(ap, int); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2360 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2361 if (j >= 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2362 precision = j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2363 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2364 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2365 precision_specified = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2366 precision = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2367 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2368 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2369 else if (VIM_ISDIGIT((int)(*p))) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2370 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2371 // size_t could be wider than unsigned int; make sure we |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2372 // treat argument like common implementations do |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2373 unsigned int uj = *p++ - '0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2374 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2375 while (VIM_ISDIGIT((int)(*p))) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2376 uj = 10 * uj + (unsigned int)(*p++ - '0'); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2377 precision = uj; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2378 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2379 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2380 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2381 // parse 'h', 'l' and 'll' length modifiers |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2382 if (*p == 'h' || *p == 'l') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2383 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2384 length_modifier = *p; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2385 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2386 if (length_modifier == 'l' && *p == 'l') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2387 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2388 // double l = __int64 / varnumber_T |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2389 length_modifier = 'L'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2390 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2391 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2392 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2393 fmt_spec = *p; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2394 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2395 // common synonyms: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2396 switch (fmt_spec) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2397 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2398 case 'i': fmt_spec = 'd'; break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2399 case 'D': fmt_spec = 'd'; length_modifier = 'l'; break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2400 case 'U': fmt_spec = 'u'; length_modifier = 'l'; break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2401 case 'O': fmt_spec = 'o'; length_modifier = 'l'; break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2402 default: break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2403 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2404 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2405 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2406 switch (fmt_spec) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2407 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2408 case 'd': case 'u': case 'o': case 'x': case 'X': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2409 if (tvs != NULL && length_modifier == '\0') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2410 length_modifier = 'L'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2411 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2412 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2413 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2414 // get parameter value, do initial processing |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2415 switch (fmt_spec) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2416 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2417 // '%' and 'c' behave similar to 's' regarding flags and field |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2418 // widths |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2419 case '%': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2420 case 'c': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2421 case 's': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2422 case 'S': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2423 str_arg_l = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2424 switch (fmt_spec) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2425 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2426 case '%': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2427 str_arg = p; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2428 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2429 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2430 case 'c': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2431 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2432 int j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2433 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2434 j = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2435 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2436 tvs != NULL ? tv_nr(tvs, &arg_idx) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2437 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2438 va_arg(ap, int); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2439 // standard demands unsigned char |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2440 uchar_arg = (unsigned char)j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2441 str_arg = (char *)&uchar_arg; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2442 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2443 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2444 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2445 case 's': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2446 case 'S': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2447 str_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2448 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2449 tvs != NULL ? tv_str(tvs, &arg_idx, &tofree) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2450 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2451 va_arg(ap, char *); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2452 if (str_arg == NULL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2453 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2454 str_arg = "[NULL]"; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2455 str_arg_l = 6; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2456 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2457 // make sure not to address string beyond the specified |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2458 // precision !!! |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2459 else if (!precision_specified) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2460 str_arg_l = strlen(str_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2461 // truncate string if necessary as requested by precision |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2462 else if (precision == 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2463 str_arg_l = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2464 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2465 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2466 // Don't put the #if inside memchr(), it can be a |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2467 // macro. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2468 // memchr on HP does not like n > 2^31 !!! |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2469 char *q = memchr(str_arg, '\0', |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2470 precision <= (size_t)0x7fffffffL ? precision |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2471 : (size_t)0x7fffffffL); |
26197
2093cc976da8
patch 8.2.3630: printf() with %S does not handle multi-byte correctly
Bram Moolenaar <Bram@vim.org>
parents:
25715
diff
changeset
|
2472 |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2473 str_arg_l = (q == NULL) ? precision |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2474 : (size_t)(q - str_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2475 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2476 if (fmt_spec == 'S') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2477 { |
26264
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2478 char_u *p1; |
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2479 size_t i; |
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2480 int cell; |
26197
2093cc976da8
patch 8.2.3630: printf() with %S does not handle multi-byte correctly
Bram Moolenaar <Bram@vim.org>
parents:
25715
diff
changeset
|
2481 |
26264
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2482 for (i = 0, p1 = (char_u *)str_arg; *p1; |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2483 p1 += mb_ptr2len(p1)) |
26264
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2484 { |
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2485 cell = mb_ptr2cells(p1); |
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2486 if (precision_specified && i + cell > precision) |
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2487 break; |
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2488 i += cell; |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2489 } |
26264
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2490 |
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2491 str_arg_l = p1 - (char_u *)str_arg; |
26197
2093cc976da8
patch 8.2.3630: printf() with %S does not handle multi-byte correctly
Bram Moolenaar <Bram@vim.org>
parents:
25715
diff
changeset
|
2492 if (min_field_width != 0) |
26264
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2493 min_field_width += str_arg_l - i; |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2494 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2495 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2496 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2497 default: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2498 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2499 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2500 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2501 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2502 case 'd': case 'u': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2503 case 'b': case 'B': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2504 case 'o': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2505 case 'x': case 'X': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2506 case 'p': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2507 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2508 // NOTE: the u, b, o, x, X and p conversion specifiers |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2509 // imply the value is unsigned; d implies a signed |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2510 // value |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2511 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2512 // 0 if numeric argument is zero (or if pointer is |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2513 // NULL for 'p'), +1 if greater than zero (or nonzero |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2514 // for unsigned arguments), -1 if negative (unsigned |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2515 // argument is never negative) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2516 int arg_sign = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2517 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2518 // only set for length modifier h, or for no length |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2519 // modifiers |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2520 int int_arg = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2521 unsigned int uint_arg = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2522 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2523 // only set for length modifier l |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2524 long int long_arg = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2525 unsigned long int ulong_arg = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2526 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2527 // only set for length modifier ll |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2528 varnumber_T llong_arg = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2529 uvarnumber_T ullong_arg = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2530 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2531 // only set for b conversion |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2532 uvarnumber_T bin_arg = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2533 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2534 // pointer argument value -only defined for p |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2535 // conversion |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2536 void *ptr_arg = NULL; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2537 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2538 if (fmt_spec == 'p') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2539 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2540 length_modifier = '\0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2541 ptr_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2542 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2543 tvs != NULL ? (void *)tv_str(tvs, &arg_idx, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2544 NULL) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2545 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2546 va_arg(ap, void *); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2547 if (ptr_arg != NULL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2548 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2549 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2550 else if (fmt_spec == 'b' || fmt_spec == 'B') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2551 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2552 bin_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2553 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2554 tvs != NULL ? |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2555 (uvarnumber_T)tv_nr(tvs, &arg_idx) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2556 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2557 va_arg(ap, uvarnumber_T); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2558 if (bin_arg != 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2559 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2560 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2561 else if (fmt_spec == 'd') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2562 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2563 // signed |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2564 switch (length_modifier) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2565 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2566 case '\0': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2567 case 'h': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2568 // char and short arguments are passed as int. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2569 int_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2570 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2571 tvs != NULL ? tv_nr(tvs, &arg_idx) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2572 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2573 va_arg(ap, int); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2574 if (int_arg > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2575 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2576 else if (int_arg < 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2577 arg_sign = -1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2578 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2579 case 'l': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2580 long_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2581 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2582 tvs != NULL ? tv_nr(tvs, &arg_idx) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2583 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2584 va_arg(ap, long int); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2585 if (long_arg > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2586 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2587 else if (long_arg < 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2588 arg_sign = -1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2589 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2590 case 'L': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2591 llong_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2592 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2593 tvs != NULL ? tv_nr(tvs, &arg_idx) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2594 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2595 va_arg(ap, varnumber_T); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2596 if (llong_arg > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2597 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2598 else if (llong_arg < 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2599 arg_sign = -1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2600 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2601 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2602 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2603 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2604 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2605 // unsigned |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2606 switch (length_modifier) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2607 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2608 case '\0': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2609 case 'h': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2610 uint_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2611 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2612 tvs != NULL ? (unsigned) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2613 tv_nr(tvs, &arg_idx) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2614 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2615 va_arg(ap, unsigned int); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2616 if (uint_arg != 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2617 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2618 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2619 case 'l': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2620 ulong_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2621 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2622 tvs != NULL ? (unsigned long) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2623 tv_nr(tvs, &arg_idx) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2624 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2625 va_arg(ap, unsigned long int); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2626 if (ulong_arg != 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2627 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2628 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2629 case 'L': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2630 ullong_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2631 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2632 tvs != NULL ? (uvarnumber_T) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2633 tv_nr(tvs, &arg_idx) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2634 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2635 va_arg(ap, uvarnumber_T); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2636 if (ullong_arg != 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2637 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2638 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2639 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2640 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2641 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2642 str_arg = tmp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2643 str_arg_l = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2644 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2645 // NOTE: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2646 // For d, i, u, o, x, and X conversions, if precision is |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2647 // specified, the '0' flag should be ignored. This is so |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2648 // with Solaris 2.6, Digital UNIX 4.0, HPUX 10, Linux, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2649 // FreeBSD, NetBSD; but not with Perl. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2650 if (precision_specified) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2651 zero_padding = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2652 if (fmt_spec == 'd') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2653 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2654 if (force_sign && arg_sign >= 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2655 tmp[str_arg_l++] = space_for_positive ? ' ' : '+'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2656 // leave negative numbers for sprintf to handle, to |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2657 // avoid handling tricky cases like (short int)-32768 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2658 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2659 else if (alternate_form) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2660 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2661 if (arg_sign != 0 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2662 && (fmt_spec == 'b' || fmt_spec == 'B' |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2663 || fmt_spec == 'x' || fmt_spec == 'X') ) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2664 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2665 tmp[str_arg_l++] = '0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2666 tmp[str_arg_l++] = fmt_spec; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2667 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2668 // alternate form should have no effect for p |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2669 // conversion, but ... |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2670 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2671 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2672 zero_padding_insertion_ind = str_arg_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2673 if (!precision_specified) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2674 precision = 1; // default precision is 1 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2675 if (precision == 0 && arg_sign == 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2676 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2677 // When zero value is formatted with an explicit |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2678 // precision 0, the resulting formatted string is |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2679 // empty (d, i, u, b, B, o, x, X, p). |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2680 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2681 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2682 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2683 char f[6]; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2684 int f_l = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2685 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2686 // construct a simple format string for sprintf |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2687 f[f_l++] = '%'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2688 if (!length_modifier) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2689 ; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2690 else if (length_modifier == 'L') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2691 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2692 # ifdef MSWIN |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2693 f[f_l++] = 'I'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2694 f[f_l++] = '6'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2695 f[f_l++] = '4'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2696 # else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2697 f[f_l++] = 'l'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2698 f[f_l++] = 'l'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2699 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2700 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2701 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2702 f[f_l++] = length_modifier; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2703 f[f_l++] = fmt_spec; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2704 f[f_l++] = '\0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2705 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2706 if (fmt_spec == 'p') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2707 str_arg_l += sprintf(tmp + str_arg_l, f, ptr_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2708 else if (fmt_spec == 'b' || fmt_spec == 'B') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2709 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2710 char b[8 * sizeof(uvarnumber_T)]; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2711 size_t b_l = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2712 uvarnumber_T bn = bin_arg; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2713 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2714 do |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2715 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2716 b[sizeof(b) - ++b_l] = '0' + (bn & 0x1); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2717 bn >>= 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2718 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2719 while (bn != 0); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2720 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2721 memcpy(tmp + str_arg_l, b + sizeof(b) - b_l, b_l); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2722 str_arg_l += b_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2723 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2724 else if (fmt_spec == 'd') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2725 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2726 // signed |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2727 switch (length_modifier) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2728 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2729 case '\0': str_arg_l += sprintf( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2730 tmp + str_arg_l, f, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2731 int_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2732 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2733 case 'h': str_arg_l += sprintf( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2734 tmp + str_arg_l, f, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2735 (short)int_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2736 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2737 case 'l': str_arg_l += sprintf( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2738 tmp + str_arg_l, f, long_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2739 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2740 case 'L': str_arg_l += sprintf( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2741 tmp + str_arg_l, f, llong_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2742 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2743 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2744 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2745 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2746 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2747 // unsigned |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2748 switch (length_modifier) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2749 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2750 case '\0': str_arg_l += sprintf( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2751 tmp + str_arg_l, f, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2752 uint_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2753 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2754 case 'h': str_arg_l += sprintf( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2755 tmp + str_arg_l, f, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2756 (unsigned short)uint_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2757 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2758 case 'l': str_arg_l += sprintf( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2759 tmp + str_arg_l, f, ulong_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2760 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2761 case 'L': str_arg_l += sprintf( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2762 tmp + str_arg_l, f, ullong_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2763 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2764 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2765 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2766 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2767 // include the optional minus sign and possible |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2768 // "0x" in the region before the zero padding |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2769 // insertion point |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2770 if (zero_padding_insertion_ind < str_arg_l |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2771 && tmp[zero_padding_insertion_ind] == '-') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2772 zero_padding_insertion_ind++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2773 if (zero_padding_insertion_ind + 1 < str_arg_l |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2774 && tmp[zero_padding_insertion_ind] == '0' |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2775 && (tmp[zero_padding_insertion_ind + 1] == 'x' |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2776 || tmp[zero_padding_insertion_ind + 1] == 'X')) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2777 zero_padding_insertion_ind += 2; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2778 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2779 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2780 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2781 size_t num_of_digits = str_arg_l |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2782 - zero_padding_insertion_ind; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2783 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2784 if (alternate_form && fmt_spec == 'o' |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2785 // unless zero is already the first |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2786 // character |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2787 && !(zero_padding_insertion_ind < str_arg_l |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2788 && tmp[zero_padding_insertion_ind] == '0')) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2789 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2790 // assure leading zero for alternate-form |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2791 // octal numbers |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2792 if (!precision_specified |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2793 || precision < num_of_digits + 1) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2794 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2795 // precision is increased to force the |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2796 // first character to be zero, except if a |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2797 // zero value is formatted with an |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2798 // explicit precision of zero |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2799 precision = num_of_digits + 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2800 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2801 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2802 // zero padding to specified precision? |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2803 if (num_of_digits < precision) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2804 number_of_zeros_to_pad = precision - num_of_digits; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2805 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2806 // zero padding to specified minimal field width? |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2807 if (!justify_left && zero_padding) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2808 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2809 int n = (int)(min_field_width - (str_arg_l |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2810 + number_of_zeros_to_pad)); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2811 if (n > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2812 number_of_zeros_to_pad += n; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2813 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2814 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2815 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2816 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2817 case 'f': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2818 case 'F': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2819 case 'e': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2820 case 'E': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2821 case 'g': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2822 case 'G': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2823 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2824 // Floating point. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2825 double f; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2826 double abs_f; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2827 char format[40]; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2828 int l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2829 int remove_trailing_zeroes = FALSE; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2830 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2831 f = |
30310
029c59bf78f1
patch 9.0.0491: no good reason to build without the float feature
Bram Moolenaar <Bram@vim.org>
parents:
30043
diff
changeset
|
2832 # if defined(FEAT_EVAL) |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2833 tvs != NULL ? tv_float(tvs, &arg_idx) : |
30310
029c59bf78f1
patch 9.0.0491: no good reason to build without the float feature
Bram Moolenaar <Bram@vim.org>
parents:
30043
diff
changeset
|
2834 # endif |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2835 va_arg(ap, double); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2836 abs_f = f < 0 ? -f : f; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2837 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2838 if (fmt_spec == 'g' || fmt_spec == 'G') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2839 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2840 // Would be nice to use %g directly, but it prints |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2841 // "1.0" as "1", we don't want that. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2842 if ((abs_f >= 0.001 && abs_f < 10000000.0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2843 || abs_f == 0.0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2844 fmt_spec = ASCII_ISUPPER(fmt_spec) ? 'F' : 'f'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2845 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2846 fmt_spec = fmt_spec == 'g' ? 'e' : 'E'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2847 remove_trailing_zeroes = TRUE; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2848 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2849 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2850 if ((fmt_spec == 'f' || fmt_spec == 'F') && |
30310
029c59bf78f1
patch 9.0.0491: no good reason to build without the float feature
Bram Moolenaar <Bram@vim.org>
parents:
30043
diff
changeset
|
2851 # ifdef VAX |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2852 abs_f > 1.0e38 |
30310
029c59bf78f1
patch 9.0.0491: no good reason to build without the float feature
Bram Moolenaar <Bram@vim.org>
parents:
30043
diff
changeset
|
2853 # else |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2854 abs_f > 1.0e307 |
30310
029c59bf78f1
patch 9.0.0491: no good reason to build without the float feature
Bram Moolenaar <Bram@vim.org>
parents:
30043
diff
changeset
|
2855 # endif |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2856 ) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2857 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2858 // Avoid a buffer overflow |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2859 STRCPY(tmp, infinity_str(f > 0.0, fmt_spec, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2860 force_sign, space_for_positive)); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2861 str_arg_l = STRLEN(tmp); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2862 zero_padding = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2863 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2864 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2865 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2866 if (isnan(f)) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2867 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2868 // Not a number: nan or NAN |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2869 STRCPY(tmp, ASCII_ISUPPER(fmt_spec) ? "NAN" |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2870 : "nan"); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2871 str_arg_l = 3; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2872 zero_padding = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2873 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2874 else if (isinf(f)) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2875 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2876 STRCPY(tmp, infinity_str(f > 0.0, fmt_spec, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2877 force_sign, space_for_positive)); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2878 str_arg_l = STRLEN(tmp); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2879 zero_padding = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2880 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2881 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2882 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2883 // Regular float number |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2884 format[0] = '%'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2885 l = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2886 if (force_sign) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2887 format[l++] = space_for_positive ? ' ' : '+'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2888 if (precision_specified) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2889 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2890 size_t max_prec = TMP_LEN - 10; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2891 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2892 // Make sure we don't get more digits than we |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2893 // have room for. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2894 if ((fmt_spec == 'f' || fmt_spec == 'F') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2895 && abs_f > 1.0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2896 max_prec -= (size_t)log10(abs_f); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2897 if (precision > max_prec) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2898 precision = max_prec; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2899 l += sprintf(format + l, ".%d", (int)precision); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2900 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2901 format[l] = fmt_spec == 'F' ? 'f' : fmt_spec; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2902 format[l + 1] = NUL; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2903 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2904 str_arg_l = sprintf(tmp, format, f); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2905 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2906 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2907 if (remove_trailing_zeroes) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2908 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2909 int i; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2910 char *tp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2911 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2912 // Using %g or %G: remove superfluous zeroes. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2913 if (fmt_spec == 'f' || fmt_spec == 'F') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2914 tp = tmp + str_arg_l - 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2915 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2916 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2917 tp = (char *)vim_strchr((char_u *)tmp, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2918 fmt_spec == 'e' ? 'e' : 'E'); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2919 if (tp != NULL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2920 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2921 // Remove superfluous '+' and leading |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2922 // zeroes from the exponent. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2923 if (tp[1] == '+') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2924 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2925 // Change "1.0e+07" to "1.0e07" |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2926 STRMOVE(tp + 1, tp + 2); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2927 --str_arg_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2928 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2929 i = (tp[1] == '-') ? 2 : 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2930 while (tp[i] == '0') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2931 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2932 // Change "1.0e07" to "1.0e7" |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2933 STRMOVE(tp + i, tp + i + 1); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2934 --str_arg_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2935 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2936 --tp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2937 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2938 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2939 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2940 if (tp != NULL && !precision_specified) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2941 // Remove trailing zeroes, but keep the one |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2942 // just after a dot. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2943 while (tp > tmp + 2 && *tp == '0' |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2944 && tp[-1] != '.') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2945 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2946 STRMOVE(tp, tp + 1); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2947 --tp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2948 --str_arg_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2949 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2950 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2951 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2952 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2953 char *tp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2954 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2955 // Be consistent: some printf("%e") use 1.0e+12 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2956 // and some 1.0e+012. Remove one zero in the last |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2957 // case. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2958 tp = (char *)vim_strchr((char_u *)tmp, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2959 fmt_spec == 'e' ? 'e' : 'E'); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2960 if (tp != NULL && (tp[1] == '+' || tp[1] == '-') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2961 && tp[2] == '0' |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2962 && vim_isdigit(tp[3]) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2963 && vim_isdigit(tp[4])) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2964 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2965 STRMOVE(tp + 2, tp + 3); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2966 --str_arg_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2967 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2968 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2969 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2970 if (zero_padding && min_field_width > str_arg_l |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2971 && (tmp[0] == '-' || force_sign)) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2972 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2973 // padding 0's should be inserted after the sign |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2974 number_of_zeros_to_pad = min_field_width - str_arg_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2975 zero_padding_insertion_ind = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2976 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2977 str_arg = tmp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2978 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2979 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2980 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2981 default: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2982 // unrecognized conversion specifier, keep format string |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2983 // as-is |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2984 zero_padding = 0; // turn zero padding off for non-numeric |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2985 // conversion |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2986 justify_left = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2987 min_field_width = 0; // reset flags |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2988 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2989 // discard the unrecognized conversion, just keep * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2990 // the unrecognized conversion character |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2991 str_arg = p; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2992 str_arg_l = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2993 if (*p != NUL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2994 str_arg_l++; // include invalid conversion specifier |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2995 // unchanged if not at end-of-string |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2996 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2997 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2998 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2999 if (*p != NUL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3000 p++; // step over the just processed conversion specifier |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3001 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3002 // insert padding to the left as requested by min_field_width; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3003 // this does not include the zero padding in case of numerical |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3004 // conversions |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3005 if (!justify_left) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3006 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3007 // left padding with blank or zero |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3008 int pn = (int)(min_field_width - (str_arg_l + number_of_zeros_to_pad)); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3009 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3010 if (pn > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3011 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3012 if (str_l < str_m) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3013 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3014 size_t avail = str_m - str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3015 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3016 vim_memset(str + str_l, zero_padding ? '0' : ' ', |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3017 (size_t)pn > avail ? avail |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3018 : (size_t)pn); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3019 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3020 str_l += pn; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3021 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3022 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3023 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3024 // zero padding as requested by the precision or by the minimal |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3025 // field width for numeric conversions required? |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3026 if (number_of_zeros_to_pad == 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3027 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3028 // will not copy first part of numeric right now, * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3029 // force it to be copied later in its entirety |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3030 zero_padding_insertion_ind = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3031 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3032 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3033 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3034 // insert first part of numerics (sign or '0x') before zero |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3035 // padding |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3036 int zn = (int)zero_padding_insertion_ind; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3037 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3038 if (zn > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3039 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3040 if (str_l < str_m) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3041 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3042 size_t avail = str_m - str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3043 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3044 mch_memmove(str + str_l, str_arg, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3045 (size_t)zn > avail ? avail |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3046 : (size_t)zn); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3047 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3048 str_l += zn; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3049 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3050 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3051 // insert zero padding as requested by the precision or min |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3052 // field width |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3053 zn = (int)number_of_zeros_to_pad; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3054 if (zn > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3055 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3056 if (str_l < str_m) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3057 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3058 size_t avail = str_m - str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3059 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3060 vim_memset(str + str_l, '0', |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3061 (size_t)zn > avail ? avail |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3062 : (size_t)zn); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3063 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3064 str_l += zn; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3065 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3066 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3067 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3068 // insert formatted string |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3069 // (or as-is conversion specifier for unknown conversions) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3070 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3071 int sn = (int)(str_arg_l - zero_padding_insertion_ind); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3072 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3073 if (sn > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3074 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3075 if (str_l < str_m) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3076 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3077 size_t avail = str_m - str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3078 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3079 mch_memmove(str + str_l, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3080 str_arg + zero_padding_insertion_ind, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3081 (size_t)sn > avail ? avail : (size_t)sn); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3082 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3083 str_l += sn; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3084 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3085 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3086 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3087 // insert right padding |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3088 if (justify_left) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3089 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3090 // right blank padding to the field width |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3091 int pn = (int)(min_field_width |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3092 - (str_arg_l + number_of_zeros_to_pad)); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3093 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3094 if (pn > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3095 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3096 if (str_l < str_m) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3097 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3098 size_t avail = str_m - str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3099 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3100 vim_memset(str + str_l, ' ', |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3101 (size_t)pn > avail ? avail |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3102 : (size_t)pn); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3103 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3104 str_l += pn; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3105 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3106 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3107 vim_free(tofree); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3108 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3109 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3110 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3111 if (str_m > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3112 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3113 // make sure the string is nul-terminated even at the expense of |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3114 // overwriting the last character (shouldn't happen, but just in case) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3115 // |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3116 str[str_l <= str_m - 1 ? str_l : str_m - 1] = '\0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3117 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3118 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3119 if (tvs != NULL && tvs[arg_idx - 1].v_type != VAR_UNKNOWN) |
26958
d92e0d85923f
patch 8.2.4008: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26879
diff
changeset
|
3120 emsg(_(e_too_many_arguments_to_printf)); |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3121 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3122 // Return the number of characters formatted (excluding trailing nul |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3123 // character), that is, the number of characters that would have been |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3124 // written to the buffer if it were large enough. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3125 return (int)str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3126 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3127 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3128 #endif // PROTO |