Mercurial > vim
annotate src/strings.c @ 32307:8d6f53a07ffd v9.0.1485
patch 9.0.1485: no functions for converting from/to UTF-16 index
Commit: https://github.com/vim/vim/commit/67672ef097dd708244ff042a8364994da2b91e75
Author: Christian Brabandt <cb@256bit.org>
Date: Mon Apr 24 21:09:54 2023 +0100
patch 9.0.1485: no functions for converting from/to UTF-16 index
Problem: no functions for converting from/to UTF-16 index.
Solution: Add UTF-16 flag to existing funtions and add strutf16len() and
utf16idx(). (Yegappan Lakshmanan, closes #12216)
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Mon, 24 Apr 2023 22:15:05 +0200 |
parents | 252b06c87796 |
children | d5e673b941cd |
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 /* |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
858 * 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
|
859 * 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
|
860 */ |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
861 static int |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
862 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
|
863 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
864 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
|
865 int len; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
866 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
867 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
|
868 return FAIL; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
869 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
870 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
|
871 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
|
872 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
|
873 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
|
874 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
|
875 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
876 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
|
877 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
878 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
879 /* |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
880 * 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
|
881 * 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
|
882 */ |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
883 void |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
884 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
|
885 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
|
886 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
|
887 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
|
888 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
|
889 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
890 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
|
891 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
|
892 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
|
893 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
|
894 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
|
895 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
|
896 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
|
897 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
|
898 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
899 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
|
900 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
|
901 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
902 // 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
|
903 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
|
904 |
32256
252b06c87796
patch 9.0.1459: typo in name of type
Bram Moolenaar <Bram@vim.org>
parents:
32098
diff
changeset
|
905 // 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
|
906 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
|
907 |
27028
c9474ae175f4
patch 8.2.4043: using int for second argument of ga_init2()
Bram Moolenaar <Bram@vim.org>
parents:
26962
diff
changeset
|
908 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
|
909 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
|
910 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
911 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
|
912 break; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
913 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
|
914 |
28708
094a70434f90
patch 8.2.4878: valgrind warning for using uninitialized variable
Bram Moolenaar <Bram@vim.org>
parents:
27490
diff
changeset
|
915 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
|
916 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
|
917 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
|
918 || did_emsg) |
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 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
|
921 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
|
922 break; |
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 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
|
925 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
926 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
|
927 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
928 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
|
929 clear_tv(&tv); |
26879
da89514c3b72
patch 8.2.3968: build failure
Bram Moolenaar <Bram@vim.org>
parents:
26865
diff
changeset
|
930 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
|
931 break; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
932 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
933 else |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
934 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
|
935 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
936 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
|
937 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
|
938 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
939 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
|
940 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
|
941 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
942 ++idx; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
943 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
944 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
|
945 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
|
946 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
|
947 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
|
948 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
949 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
950 /* |
30425
6c2bbd7d9217
patch 9.0.0548: reduce() with a compiled lambda could be faster
Bram Moolenaar <Bram@vim.org>
parents:
30310
diff
changeset
|
951 * 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
|
952 * 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
|
953 * 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
|
954 */ |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
955 void |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
956 string_reduce( |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
957 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
|
958 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
|
959 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
|
960 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
961 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
|
962 int len; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
963 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
|
964 int r; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
965 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
|
966 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
|
967 |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
968 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
|
969 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
970 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
|
971 { |
26879
da89514c3b72
patch 8.2.3968: build failure
Bram Moolenaar <Bram@vim.org>
parents:
26865
diff
changeset
|
972 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
|
973 return; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
974 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
975 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
|
976 return; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
977 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
|
978 } |
30043
fd855ad74887
patch 9.0.0359: error message for wrong argument type is not specific
Bram Moolenaar <Bram@vim.org>
parents:
28708
diff
changeset
|
979 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
|
980 return; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
981 else |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
982 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
|
983 |
32256
252b06c87796
patch 9.0.1459: typo in name of type
Bram Moolenaar <Bram@vim.org>
parents:
32098
diff
changeset
|
984 // 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
|
985 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
|
986 |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
987 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
|
988 { |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
989 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
|
990 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
|
991 break; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
992 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
|
993 |
30566
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
994 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
|
995 |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
996 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
|
997 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
|
998 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
|
999 return; |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1000 } |
30566
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
1001 |
b3de17181c19
patch 9.0.0618: calling function for reduce() has too much overhead
Bram Moolenaar <Bram@vim.org>
parents:
30425
diff
changeset
|
1002 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
|
1003 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
|
1004 } |
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
1005 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1006 static void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1007 byteidx(typval_T *argvars, typval_T *rettv, int comp UNUSED) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1008 { |
25252
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1009 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
|
1010 |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1011 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
|
1012 && (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
|
1013 || 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
|
1014 return; |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1015 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1016 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
|
1017 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
|
1018 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
|
1019 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1020 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1021 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
|
1022 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
|
1023 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1024 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
|
1025 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
|
1026 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1027 semsg(_(e_using_number_as_bool_nr), utf16idx); |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1028 return; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1029 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1030 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1031 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1032 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
|
1033 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
|
1034 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
|
1035 else |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1036 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
|
1037 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1038 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
|
1039 for ( ; idx > 0; idx--) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1040 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1041 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
|
1042 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
|
1043 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
|
1044 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1045 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
|
1046 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
|
1047 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
|
1048 idx--; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1049 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1050 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
|
1051 t += ptr2len(t); |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1052 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1053 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
|
1054 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1055 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1056 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1057 * "byteidx()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1058 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1059 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1060 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
|
1061 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1062 byteidx(argvars, rettv, FALSE); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1063 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1064 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1065 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1066 * "byteidxcomp()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1067 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1068 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1069 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
|
1070 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1071 byteidx(argvars, rettv, TRUE); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1072 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1073 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1074 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1075 * "charidx()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1076 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1077 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1078 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
|
1079 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1080 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
|
1081 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1082 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
|
1083 || 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
|
1084 || 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
|
1085 || (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
|
1086 && 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
|
1087 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
|
1088 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1089 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
|
1090 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
|
1091 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
|
1092 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1093 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1094 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
|
1095 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
|
1096 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
|
1097 { |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1098 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
|
1099 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
|
1100 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
|
1101 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1102 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1103 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
|
1104 if (enc_utf8 && countcc) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1105 ptr2len = utf_ptr2len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1106 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1107 ptr2len = mb_ptr2len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1108 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1109 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
|
1110 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
|
1111 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
|
1112 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1113 if (*p == NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1114 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
|
1115 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
|
1116 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1117 idx--; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1118 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
|
1119 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
|
1120 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
|
1121 idx--; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1122 } |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1123 p += ptr2len(p); |
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 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1126 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
|
1127 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1128 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1129 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1130 * "str2list()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1131 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1132 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1133 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
|
1134 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1135 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1136 int utf8 = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1137 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1138 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
|
1139 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1140 |
25272
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1141 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
|
1142 && (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
|
1143 || 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
|
1144 return; |
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1145 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1146 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
|
1147 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
|
1148 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1149 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
|
1150 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1151 if (has_mbyte || utf8) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1152 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1153 int (*ptr2len)(char_u *); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1154 int (*ptr2char)(char_u *); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1155 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1156 if (utf8 || enc_utf8) |
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 ptr2len = utf_ptr2len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1159 ptr2char = utf_ptr2char; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1160 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1161 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1162 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1163 ptr2len = mb_ptr2len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1164 ptr2char = mb_ptr2char; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1165 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1166 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1167 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
|
1168 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
|
1169 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1170 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1171 for ( ; *p != NUL; ++p) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1172 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
|
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 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1176 * "str2nr()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1177 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1178 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1179 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
|
1180 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1181 int base = 10; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1182 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1183 varnumber_T n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1184 int what = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1185 int isneg; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1186 |
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
|
1187 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
|
1188 && (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
|
1189 || 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
|
1190 || (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
|
1191 && 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
|
1192 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
|
1193 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1194 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
|
1195 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1196 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
|
1197 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
|
1198 { |
26865
bce848ec8b1b
patch 8.2.3961: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1199 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
|
1200 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1201 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1202 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
|
1203 what |= STR2NR_QUOTE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1204 } |
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 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
|
1207 isneg = (*p == '-'); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1208 if (*p == '+' || *p == '-') |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1209 p = skipwhite(p + 1); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1210 switch (base) |
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 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
|
1213 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
|
1214 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
|
1215 } |
32098
39f4126d2a0d
patch 9.0.1380: CTRL-X on 2**64 subtracts two
Bram Moolenaar <Bram@vim.org>
parents:
31809
diff
changeset
|
1216 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
|
1217 // 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
|
1218 if (isneg) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1219 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
|
1220 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1221 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
|
1222 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1223 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1224 |
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 * "strgetchar()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1227 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1228 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1229 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
|
1230 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1231 char_u *str; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1232 int len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1233 int error = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1234 int charidx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1235 int byteidx = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1236 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1237 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
|
1238 |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1239 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
|
1240 && (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
|
1241 || 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
|
1242 return; |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1243 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1244 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
|
1245 if (str == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1246 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1247 len = (int)STRLEN(str); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1248 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
|
1249 if (error) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1250 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1251 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1252 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
|
1253 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1254 if (charidx == 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1255 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1256 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
|
1257 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1258 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1259 --charidx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1260 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
|
1261 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1262 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1263 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1264 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1265 * "stridx()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1266 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1267 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1268 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
|
1269 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1270 char_u buf[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1271 char_u *needle; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1272 char_u *haystack; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1273 char_u *save_haystack; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1274 char_u *pos; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1275 int start_idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1276 |
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
|
1277 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
|
1278 && (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
|
1279 || 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
|
1280 || 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
|
1281 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
|
1282 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1283 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
|
1284 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
|
1285 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
|
1286 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
|
1287 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
|
1288 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1289 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
|
1290 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1291 int error = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1292 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1293 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
|
1294 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
|
1295 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1296 if (start_idx >= 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1297 haystack += start_idx; |
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 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1300 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
|
1301 if (pos != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1302 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
|
1303 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1304 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1305 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1306 * "string()" function |
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 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1309 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
|
1310 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1311 char_u *tofree; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1312 char_u numbuf[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1313 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1314 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
|
1315 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
|
1316 get_copyID()); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1317 // 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
|
1318 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
|
1319 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
|
1320 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1321 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1322 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1323 * "strlen()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1324 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1325 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1326 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
|
1327 { |
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
|
1328 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
|
1329 && 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
|
1330 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
|
1331 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1332 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
|
1333 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
|
1334 } |
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 static void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1337 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
|
1338 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1339 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
|
1340 varnumber_T len = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1341 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
|
1342 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1343 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
|
1344 while (*s != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1345 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1346 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
|
1347 ++len; |
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 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
|
1350 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1351 |
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 * "strcharlen()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1354 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1355 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1356 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
|
1357 { |
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
|
1358 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
|
1359 && 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
|
1360 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
|
1361 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1362 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
|
1363 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1364 |
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 * "strchars()" function |
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 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1369 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
|
1370 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1371 varnumber_T skipcc = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1372 |
25272
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1373 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
|
1374 && (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
|
1375 || 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
|
1376 return; |
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25252
diff
changeset
|
1377 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1378 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
|
1379 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
|
1380 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
|
1381 semsg(_(e_using_number_as_bool_nr), skipcc); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1382 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1383 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
|
1384 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1385 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1386 /* |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1387 * "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
|
1388 */ |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1389 void |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1390 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
|
1391 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1392 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
|
1393 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1394 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
|
1395 || 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
|
1396 return; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1397 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1398 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
|
1399 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
|
1400 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
|
1401 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1402 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
|
1403 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
|
1404 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
|
1405 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
|
1406 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1407 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
|
1408 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
|
1409 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1410 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
|
1411 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
|
1412 ++len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1413 ++len; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1414 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1415 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
|
1416 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1417 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1418 /* |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1419 * "strdisplaywidth()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1420 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1421 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1422 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
|
1423 { |
25252
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1424 char_u *s; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1425 int col = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1426 |
25252
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1427 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
|
1428 |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1429 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
|
1430 && (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
|
1431 || 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
|
1432 return; |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1433 |
acda780ffc3e
patch 8.2.3162: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25206
diff
changeset
|
1434 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
|
1435 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
|
1436 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
|
1437 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1438 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
|
1439 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1440 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1441 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1442 * "strwidth()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1443 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1444 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1445 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
|
1446 { |
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
|
1447 char_u *s; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1448 |
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
|
1449 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
|
1450 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
|
1451 |
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
|
1452 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
|
1453 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
|
1454 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1455 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1456 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1457 * "strcharpart()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1458 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1459 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1460 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
|
1461 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1462 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1463 int nchar; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1464 int nbyte = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1465 int charlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1466 int skipcc = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1467 int len = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1468 int slen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1469 int error = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1470 |
25302
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1471 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
|
1472 && (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
|
1473 || 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
|
1474 || 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
|
1475 || (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
|
1476 && 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
|
1477 return; |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1478 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1479 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
|
1480 slen = (int)STRLEN(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1481 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1482 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
|
1483 if (!error) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1484 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1485 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
|
1486 && 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
|
1487 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1488 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
|
1489 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
|
1490 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1491 semsg(_(e_using_number_as_bool_nr), skipcc); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1492 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1493 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1494 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1495 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1496 if (nchar > 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1497 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
|
1498 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1499 if (skipcc) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1500 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
|
1501 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1502 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
|
1503 --nchar; |
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 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1506 nbyte = nchar; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1507 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
|
1508 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1509 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
|
1510 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
|
1511 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1512 int off = nbyte + len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1513 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1514 if (off < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1515 len += 1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1516 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1517 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1518 if (skipcc) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1519 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
|
1520 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1521 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
|
1522 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1523 --charlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1524 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1525 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1526 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1527 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
|
1528 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1529 |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1530 // 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
|
1531 // string. |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1532 if (nbyte < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1533 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1534 len += nbyte; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1535 nbyte = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1536 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1537 else if (nbyte > slen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1538 nbyte = slen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1539 if (len < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1540 len = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1541 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
|
1542 len = slen - nbyte; |
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 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
|
1545 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
|
1546 } |
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 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1549 * "strpart()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1550 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1551 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1552 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
|
1553 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1554 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1555 int n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1556 int len; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1557 int slen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1558 int error = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1559 |
25302
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1560 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
|
1561 && (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
|
1562 || 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
|
1563 || 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
|
1564 || (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
|
1565 && 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
|
1566 return; |
4d3c68196d05
patch 8.2.3188: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25272
diff
changeset
|
1567 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1568 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
|
1569 slen = (int)STRLEN(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1570 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1571 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
|
1572 if (error) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1573 len = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1574 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
|
1575 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
|
1576 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1577 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
|
1578 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1579 // 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
|
1580 // string. |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1581 if (n < 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 += n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1584 n = 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 (n > slen) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1587 n = 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 (n + 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 - n; |
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 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
|
1594 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1595 int off; |
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 // length in characters |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1598 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
|
1599 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
|
1600 len = off - n; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1601 } |
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 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
|
1604 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
|
1605 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1606 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1607 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1608 * "strridx()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1609 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1610 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1611 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
|
1612 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1613 char_u buf[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1614 char_u *needle; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1615 char_u *haystack; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1616 char_u *rest; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1617 char_u *lastmatch = NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1618 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
|
1619 |
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
|
1620 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
|
1621 && (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
|
1622 || 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
|
1623 || 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
|
1624 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
|
1625 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1626 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
|
1627 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
|
1628 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1629 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
|
1630 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
|
1631 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
|
1632 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1633 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
|
1634 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
|
1635 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1636 // 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
|
1637 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
|
1638 if (end_idx < 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1639 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
|
1640 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1641 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1642 end_idx = haystack_len; |
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 if (*needle == NUL) |
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 // 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
|
1647 lastmatch = haystack + end_idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1648 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1649 else |
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 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
|
1652 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1653 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
|
1654 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
|
1655 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1656 lastmatch = rest; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1657 } |
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 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1660 if (lastmatch == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1661 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
|
1662 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1663 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
|
1664 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1665 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1666 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1667 * "strtrans()" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1668 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1669 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1670 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
|
1671 { |
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
|
1672 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
|
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 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
|
1676 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
|
1677 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1678 |
32307
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1679 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1680 /* |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1681 * |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1682 * "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
|
1683 */ |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1684 void |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1685 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
|
1686 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1687 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
|
1688 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1689 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
|
1690 || 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
|
1691 || 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
|
1692 || (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
|
1693 && 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
|
1694 return; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1695 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1696 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
|
1697 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
|
1698 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
|
1699 return; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1700 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1701 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
|
1702 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
|
1703 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
|
1704 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1705 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
|
1706 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
|
1707 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
|
1708 } |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1709 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1710 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
|
1711 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
|
1712 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
|
1713 else |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1714 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
|
1715 |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1716 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
|
1717 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
|
1718 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
|
1719 { |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1720 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
|
1721 return; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1722 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
|
1723 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
|
1724 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
|
1725 len++; |
8d6f53a07ffd
patch 9.0.1485: no functions for converting from/to UTF-16 index
Bram Moolenaar <Bram@vim.org>
parents:
32256
diff
changeset
|
1726 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
|
1727 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
|
1728 idx--; |
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 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
|
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 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1734 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1735 * "tolower(string)" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1736 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1737 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1738 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
|
1739 { |
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
|
1740 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
|
1741 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
|
1742 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1743 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
|
1744 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
|
1745 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1746 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1747 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1748 * "toupper(string)" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1749 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1750 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1751 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
|
1752 { |
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
|
1753 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
|
1754 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
|
1755 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1756 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
|
1757 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
|
1758 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1759 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1760 /* |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1761 * "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
|
1762 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1763 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1764 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
|
1765 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1766 char_u *in_str; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1767 char_u *fromstr; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1768 char_u *tostr; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1769 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1770 int inlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1771 int fromlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1772 int tolen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1773 int idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1774 char_u *cpstr; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1775 int cplen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1776 int first = TRUE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1777 char_u buf[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1778 char_u buf2[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1779 garray_T ga; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1780 |
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
|
1781 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
|
1782 && (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
|
1783 || 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
|
1784 || 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
|
1785 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
|
1786 |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1787 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
|
1788 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
|
1789 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
|
1790 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1791 // 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
|
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 = NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1794 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
|
1795 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
|
1796 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
|
1797 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1798 if (!has_mbyte) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1799 // 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
|
1800 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
|
1801 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1802 error: |
26865
bce848ec8b1b
patch 8.2.3961: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1803 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
|
1804 ga_clear(&ga); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1805 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1806 } |
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 // 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
|
1809 while (*in_str != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1810 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1811 if (has_mbyte) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1812 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1813 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
|
1814 cpstr = in_str; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1815 cplen = inlen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1816 idx = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1817 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
|
1818 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1819 fromlen = (*mb_ptr2len)(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1820 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
|
1821 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1822 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
|
1823 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1824 tolen = (*mb_ptr2len)(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1825 if (idx-- == 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1826 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1827 cplen = tolen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1828 cpstr = p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1829 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1830 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1831 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1832 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
|
1833 goto error; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1834 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1835 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1836 ++idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1837 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1838 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1839 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
|
1840 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1841 // 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
|
1842 // (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
|
1843 // 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
|
1844 first = FALSE; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1845 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
|
1846 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1847 tolen = (*mb_ptr2len)(p); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1848 --idx; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1849 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1850 if (idx != 0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1851 goto error; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1852 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1853 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1854 (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
|
1855 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
|
1856 ga.ga_len += cplen; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1857 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1858 in_str += inlen; |
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 else |
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 // 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
|
1863 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
|
1864 if (p != NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1865 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
|
1866 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1867 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
|
1868 ++in_str; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1869 } |
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 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1872 // add a terminating NUL |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1873 (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
|
1874 ga_append(&ga, NUL); |
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 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
|
1877 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1878 |
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 * "trim({expr})" function |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1881 */ |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1882 void |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1883 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
|
1884 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1885 char_u buf1[NUMBUFLEN]; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1886 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
|
1887 char_u *head; |
25206
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1888 char_u *mask = NULL; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1889 char_u *tail; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1890 char_u *prev; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1891 char_u *p; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1892 int c1; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1893 int dir = 0; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1894 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1895 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
|
1896 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
|
1897 |
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
|
1898 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
|
1899 && (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
|
1900 || 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
|
1901 || (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
|
1902 && 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
|
1903 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
|
1904 |
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
|
1905 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
|
1906 if (head == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1907 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1908 |
30043
fd855ad74887
patch 9.0.0359: error message for wrong argument type is not specific
Bram Moolenaar <Bram@vim.org>
parents:
28708
diff
changeset
|
1909 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
|
1910 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1911 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1912 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
|
1913 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1914 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
|
1915 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1916 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
|
1917 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1918 int error = 0; |
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 // 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
|
1921 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
|
1922 if (error) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1923 return; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1924 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
|
1925 { |
26865
bce848ec8b1b
patch 8.2.3961: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1926 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
|
1927 return; |
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 } |
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 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1932 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
|
1933 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1934 // Trim leading characters |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1935 while (*head != NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1936 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1937 c1 = PTR2CHAR(head); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1938 if (mask == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1939 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1940 if (c1 > ' ' && c1 != 0xa0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1941 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1942 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1943 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1944 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1945 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
|
1946 if (c1 == PTR2CHAR(p)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1947 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1948 if (*p == NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1949 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1950 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1951 MB_PTR_ADV(head); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1952 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1953 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1954 |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1955 tail = head + STRLEN(head); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1956 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
|
1957 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1958 // Trim trailing characters |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1959 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
|
1960 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1961 prev = tail; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1962 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
|
1963 c1 = PTR2CHAR(prev); |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1964 if (mask == NULL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1965 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1966 if (c1 > ' ' && c1 != 0xa0) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1967 break; |
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 else |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1970 { |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1971 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
|
1972 if (c1 == PTR2CHAR(p)) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1973 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1974 if (*p == NUL) |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1975 break; |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1976 } |
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 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
|
1980 } |
dc66d0284518
patch 8.2.3139: functions for string manipulation are spread out
Bram Moolenaar <Bram@vim.org>
parents:
diff
changeset
|
1981 |
26958
d92e0d85923f
patch 8.2.4008: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26879
diff
changeset
|
1982 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
|
1983 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1984 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1985 * 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
|
1986 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1987 static varnumber_T |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1988 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
|
1989 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1990 int idx = *idxp - 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1991 varnumber_T n = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1992 int err = FALSE; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1993 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1994 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
|
1995 emsg(_(e_printf)); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1996 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1997 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1998 ++*idxp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
1999 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
|
2000 if (err) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2001 n = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2002 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2003 return n; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2004 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2005 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2006 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2007 * 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
|
2008 * 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
|
2009 * 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
|
2010 * 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
|
2011 * 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
|
2012 * 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
|
2013 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2014 static char * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2015 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
|
2016 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2017 int idx = *idxp - 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2018 char *s = NULL; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2019 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
|
2020 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2021 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
|
2022 emsg(_(e_printf)); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2023 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2024 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2025 ++*idxp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2026 if (tofree != NULL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2027 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
|
2028 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2029 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
|
2030 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2031 return s; |
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 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2035 * 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
|
2036 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2037 static double |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2038 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
|
2039 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2040 int idx = *idxp - 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2041 double f = 0; |
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 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
|
2049 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
|
2050 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
|
2051 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
|
2052 else |
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
2053 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
|
2054 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2055 return f; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2056 } |
26684
2126feddeda6
patch 8.2.3871: list.c contains code for dict and blob
Bram Moolenaar <Bram@vim.org>
parents:
26264
diff
changeset
|
2057 |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2058 #endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2059 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2060 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2061 * 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
|
2062 * "-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
|
2063 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2064 static const char * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2065 infinity_str(int positive, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2066 char fmt_spec, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2067 int force_sign, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2068 int space_for_positive) |
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 static const char *table[] = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2071 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2072 "-inf", "inf", "+inf", " inf", |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2073 "-INF", "INF", "+INF", " INF" |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2074 }; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2075 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
|
2076 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2077 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
|
2078 idx += 4; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2079 return table[idx]; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2080 } |
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 * 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
|
2084 * 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
|
2085 * consistency. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2086 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2087 * 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
|
2088 * 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
|
2089 * 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
|
2090 * 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
|
2091 * 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
|
2092 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2093 * 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
|
2094 * 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
|
2095 * with flags: '-', '+', ' ', '0' and '#'. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2096 * 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
|
2097 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2098 * 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
|
2099 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2100 * 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
|
2101 * 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
|
2102 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2103 * 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
|
2104 * 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
|
2105 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2106 * 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
|
2107 * 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
|
2108 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2109 * 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
|
2110 * 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
|
2111 * 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
|
2112 * 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
|
2113 * 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
|
2114 * 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
|
2115 */ |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2116 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2117 /* |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2118 * 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
|
2119 * |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2120 * 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
|
2121 * "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
|
2122 */ |
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 // 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
|
2125 // understand this. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2126 #ifndef PROTO |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2127 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2128 // 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
|
2129 int |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2130 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
|
2131 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2132 va_list ap; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2133 int str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2134 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
|
2135 size_t space; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2136 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2137 if (str_m <= len) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2138 space = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2139 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2140 space = str_m - len; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2141 va_start(ap, fmt); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2142 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
|
2143 va_end(ap); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2144 return str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2145 } |
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 int |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2148 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
|
2149 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2150 va_list ap; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2151 int str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2152 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2153 va_start(ap, fmt); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2154 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
|
2155 va_end(ap); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2156 return str_l; |
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 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2159 int |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2160 vim_vsnprintf( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2161 char *str, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2162 size_t str_m, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2163 const char *fmt, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2164 va_list ap) |
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 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
|
2167 } |
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 int |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2170 vim_vsnprintf_typval( |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2171 char *str, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2172 size_t str_m, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2173 const char *fmt, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2174 va_list ap, |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2175 typval_T *tvs) |
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 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
|
2178 const char *p = fmt; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2179 int arg_idx = 1; |
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 if (p == NULL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2182 p = ""; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2183 while (*p != NUL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2184 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2185 if (*p != '%') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2186 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2187 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
|
2188 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
|
2189 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2190 // 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
|
2191 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
|
2192 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2193 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
|
2194 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2195 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
|
2196 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2197 p += n; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2198 str_l += n; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2199 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2200 else |
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 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
|
2203 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
|
2204 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
|
2205 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2206 // 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
|
2207 // ignored. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2208 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
|
2209 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2210 // 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
|
2211 char length_modifier = '\0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2212 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2213 // 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
|
2214 # 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
|
2215 // 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
|
2216 // printable. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2217 char tmp[TMP_LEN]; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2218 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2219 // 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
|
2220 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
|
2221 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2222 // 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
|
2223 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
|
2224 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2225 // 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
|
2226 // 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
|
2227 // conversion is unsigned |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2228 unsigned char uchar_arg; |
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 // 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
|
2231 // 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
|
2232 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
|
2233 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2234 // 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
|
2235 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
|
2236 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2237 // current conversion specifier character |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2238 char fmt_spec = '\0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2239 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2240 // 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
|
2241 char_u *tofree = NULL; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2242 |
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 p++; // skip '%' |
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 // parse flags |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2247 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
|
2248 || *p == '#' || *p == '\'') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2249 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2250 switch (*p) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2251 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2252 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
|
2253 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
|
2254 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
|
2255 case ' ': force_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2256 // 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
|
2257 // flag should be ignored |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2258 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2259 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
|
2260 case '\'': break; |
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 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2263 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2264 // 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
|
2265 // ignored. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2266 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2267 // parse field width |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2268 if (*p == '*') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2269 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2270 int j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2271 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2272 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2273 j = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2274 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2275 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
|
2276 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2277 va_arg(ap, int); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2278 if (j >= 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2279 min_field_width = j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2280 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2281 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2282 min_field_width = -j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2283 justify_left = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2284 } |
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 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
|
2287 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2288 // 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
|
2289 // 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
|
2290 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
|
2291 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2292 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
|
2293 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
|
2294 min_field_width = uj; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2295 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2296 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2297 // parse precision |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2298 if (*p == '.') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2299 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2300 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2301 precision_specified = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2302 if (*p == '*') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2303 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2304 int j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2305 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2306 j = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2307 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2308 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
|
2309 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2310 va_arg(ap, int); |
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 if (j >= 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2313 precision = j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2314 else |
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 precision_specified = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2317 precision = 0; |
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 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2320 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
|
2321 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2322 // 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
|
2323 // 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
|
2324 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
|
2325 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2326 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
|
2327 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
|
2328 precision = uj; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2329 } |
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 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2332 // 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
|
2333 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
|
2334 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2335 length_modifier = *p; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2336 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2337 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
|
2338 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2339 // 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
|
2340 length_modifier = 'L'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2341 p++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2342 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2343 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2344 fmt_spec = *p; |
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 // common synonyms: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2347 switch (fmt_spec) |
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 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
|
2350 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
|
2351 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
|
2352 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
|
2353 default: break; |
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 |
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 switch (fmt_spec) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2358 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2359 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
|
2360 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
|
2361 length_modifier = 'L'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2362 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2363 # endif |
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 // 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
|
2366 switch (fmt_spec) |
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 // '%' 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
|
2369 // widths |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2370 case '%': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2371 case 'c': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2372 case 's': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2373 case 'S': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2374 str_arg_l = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2375 switch (fmt_spec) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2376 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2377 case '%': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2378 str_arg = p; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2379 break; |
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 case 'c': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2382 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2383 int j; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2384 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2385 j = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2386 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2387 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
|
2388 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2389 va_arg(ap, int); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2390 // standard demands unsigned char |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2391 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
|
2392 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
|
2393 break; |
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 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2396 case 's': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2397 case 'S': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2398 str_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2399 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2400 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
|
2401 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2402 va_arg(ap, char *); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2403 if (str_arg == NULL) |
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 str_arg = "[NULL]"; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2406 str_arg_l = 6; |
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 // 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
|
2409 // precision !!! |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2410 else if (!precision_specified) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2411 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
|
2412 // 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
|
2413 else if (precision == 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2414 str_arg_l = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2415 else |
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 // 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
|
2418 // macro. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2419 // 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
|
2420 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
|
2421 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
|
2422 : (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
|
2423 |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2424 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
|
2425 : (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
|
2426 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2427 if (fmt_spec == 'S') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2428 { |
26264
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2429 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
|
2430 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
|
2431 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
|
2432 |
26264
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2433 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
|
2434 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
|
2435 { |
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2436 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
|
2437 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
|
2438 break; |
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2439 i += cell; |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2440 } |
26264
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2441 |
ce6490cd6282
patch 8.2.3663: using %S in printf() does not work correctly
Bram Moolenaar <Bram@vim.org>
parents:
26197
diff
changeset
|
2442 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
|
2443 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
|
2444 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
|
2445 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2446 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2447 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2448 default: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2449 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2450 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2451 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2452 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2453 case 'd': case 'u': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2454 case 'b': case 'B': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2455 case 'o': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2456 case 'x': case 'X': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2457 case 'p': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2458 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2459 // 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
|
2460 // 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
|
2461 // value |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2462 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2463 // 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
|
2464 // 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
|
2465 // 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
|
2466 // argument is never negative) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2467 int arg_sign = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2468 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2469 // 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
|
2470 // modifiers |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2471 int int_arg = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2472 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
|
2473 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2474 // 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
|
2475 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
|
2476 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
|
2477 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2478 // 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
|
2479 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
|
2480 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
|
2481 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2482 // 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
|
2483 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
|
2484 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2485 // 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
|
2486 // conversion |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2487 void *ptr_arg = NULL; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2488 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2489 if (fmt_spec == 'p') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2490 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2491 length_modifier = '\0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2492 ptr_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2493 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2494 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
|
2495 NULL) : |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2496 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2497 va_arg(ap, void *); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2498 if (ptr_arg != NULL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2499 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2500 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2501 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
|
2502 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2503 bin_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2504 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2505 tvs != NULL ? |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2506 (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
|
2507 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2508 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
|
2509 if (bin_arg != 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2510 arg_sign = 1; |
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 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
|
2513 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2514 // signed |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2515 switch (length_modifier) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2516 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2517 case '\0': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2518 case 'h': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2519 // 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
|
2520 int_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2521 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2522 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
|
2523 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2524 va_arg(ap, int); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2525 if (int_arg > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2526 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2527 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
|
2528 arg_sign = -1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2529 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2530 case 'l': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2531 long_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2532 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2533 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
|
2534 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2535 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
|
2536 if (long_arg > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2537 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2538 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
|
2539 arg_sign = -1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2540 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2541 case 'L': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2542 llong_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2543 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2544 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
|
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, varnumber_T); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2547 if (llong_arg > 0) |
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 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
|
2550 arg_sign = -1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2551 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2552 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2553 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2554 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2555 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2556 // unsigned |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2557 switch (length_modifier) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2558 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2559 case '\0': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2560 case 'h': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2561 uint_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2562 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2563 tvs != NULL ? (unsigned) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2564 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
|
2565 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2566 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
|
2567 if (uint_arg != 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2568 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2569 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2570 case 'l': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2571 ulong_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2572 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2573 tvs != NULL ? (unsigned long) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2574 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
|
2575 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2576 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
|
2577 if (ulong_arg != 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2578 arg_sign = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2579 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2580 case 'L': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2581 ullong_arg = |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2582 # if defined(FEAT_EVAL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2583 tvs != NULL ? (uvarnumber_T) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2584 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
|
2585 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2586 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
|
2587 if (ullong_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 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2591 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2592 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2593 str_arg = tmp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2594 str_arg_l = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2595 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2596 // NOTE: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2597 // 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
|
2598 // 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
|
2599 // 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
|
2600 // 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
|
2601 if (precision_specified) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2602 zero_padding = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2603 if (fmt_spec == 'd') |
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 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
|
2606 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
|
2607 // 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
|
2608 // 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
|
2609 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2610 else if (alternate_form) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2611 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2612 if (arg_sign != 0 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2613 && (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
|
2614 || 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
|
2615 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2616 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
|
2617 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
|
2618 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2619 // 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
|
2620 // conversion, but ... |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2621 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2622 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2623 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
|
2624 if (!precision_specified) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2625 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
|
2626 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
|
2627 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2628 // 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
|
2629 // 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
|
2630 // 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
|
2631 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2632 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2633 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2634 char f[6]; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2635 int f_l = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2636 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2637 // 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
|
2638 f[f_l++] = '%'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2639 if (!length_modifier) |
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 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
|
2642 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2643 # ifdef MSWIN |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2644 f[f_l++] = 'I'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2645 f[f_l++] = '6'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2646 f[f_l++] = '4'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2647 # else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2648 f[f_l++] = 'l'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2649 f[f_l++] = 'l'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2650 # endif |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2651 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2652 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2653 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
|
2654 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
|
2655 f[f_l++] = '\0'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2656 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2657 if (fmt_spec == 'p') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2658 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
|
2659 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
|
2660 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2661 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
|
2662 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
|
2663 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
|
2664 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2665 do |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2666 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2667 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
|
2668 bn >>= 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2669 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2670 while (bn != 0); |
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 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
|
2673 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
|
2674 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2675 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
|
2676 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2677 // signed |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2678 switch (length_modifier) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2679 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2680 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
|
2681 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
|
2682 int_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2683 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2684 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
|
2685 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
|
2686 (short)int_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2687 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2688 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
|
2689 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
|
2690 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2691 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
|
2692 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
|
2693 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2694 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2695 } |
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 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2698 // unsigned |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2699 switch (length_modifier) |
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 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
|
2702 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
|
2703 uint_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2704 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2705 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
|
2706 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
|
2707 (unsigned short)uint_arg); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2708 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2709 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
|
2710 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
|
2711 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2712 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
|
2713 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
|
2714 break; |
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 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2717 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2718 // 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
|
2719 // "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
|
2720 // insertion point |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2721 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
|
2722 && 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
|
2723 zero_padding_insertion_ind++; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2724 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
|
2725 && 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
|
2726 && (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
|
2727 || 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
|
2728 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
|
2729 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2730 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2731 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2732 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
|
2733 - zero_padding_insertion_ind; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2734 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2735 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
|
2736 // 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
|
2737 // character |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2738 && !(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
|
2739 && 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
|
2740 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2741 // 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
|
2742 // octal numbers |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2743 if (!precision_specified |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2744 || 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
|
2745 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2746 // 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
|
2747 // 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
|
2748 // 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
|
2749 // explicit precision of zero |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2750 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
|
2751 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2752 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2753 // 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
|
2754 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
|
2755 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
|
2756 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2757 // 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
|
2758 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
|
2759 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2760 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
|
2761 + 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
|
2762 if (n > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2763 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
|
2764 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2765 break; |
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 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2768 case 'f': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2769 case 'F': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2770 case 'e': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2771 case 'E': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2772 case 'g': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2773 case 'G': |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2774 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2775 // Floating point. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2776 double f; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2777 double abs_f; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2778 char format[40]; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2779 int l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2780 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
|
2781 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2782 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
|
2783 # 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
|
2784 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
|
2785 # endif |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2786 va_arg(ap, double); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2787 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
|
2788 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2789 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
|
2790 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2791 // 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
|
2792 // "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
|
2793 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
|
2794 || abs_f == 0.0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2795 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
|
2796 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2797 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
|
2798 remove_trailing_zeroes = TRUE; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2799 } |
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 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
|
2802 # ifdef VAX |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2803 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
|
2804 # else |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2805 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
|
2806 # endif |
25567
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2807 ) |
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 // Avoid a buffer overflow |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2810 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
|
2811 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
|
2812 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
|
2813 zero_padding = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2814 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2815 else |
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 if (isnan(f)) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2818 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2819 // 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
|
2820 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
|
2821 : "nan"); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2822 str_arg_l = 3; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2823 zero_padding = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2824 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2825 else if (isinf(f)) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2826 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2827 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
|
2828 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
|
2829 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
|
2830 zero_padding = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2831 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2832 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2833 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2834 // Regular float number |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2835 format[0] = '%'; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2836 l = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2837 if (force_sign) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2838 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
|
2839 if (precision_specified) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2840 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2841 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
|
2842 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2843 // 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
|
2844 // have room for. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2845 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
|
2846 && abs_f > 1.0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2847 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
|
2848 if (precision > max_prec) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2849 precision = max_prec; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2850 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
|
2851 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2852 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
|
2853 format[l + 1] = NUL; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2854 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2855 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
|
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 if (remove_trailing_zeroes) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2859 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2860 int i; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2861 char *tp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2862 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2863 // 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
|
2864 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
|
2865 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
|
2866 else |
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 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
|
2869 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
|
2870 if (tp != NULL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2871 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2872 // Remove superfluous '+' and leading |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2873 // zeroes from the exponent. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2874 if (tp[1] == '+') |
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 // 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
|
2877 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
|
2878 --str_arg_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2879 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2880 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
|
2881 while (tp[i] == '0') |
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 // 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
|
2884 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
|
2885 --str_arg_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2886 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2887 --tp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2888 } |
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 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2891 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
|
2892 // 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
|
2893 // just after a dot. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2894 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
|
2895 && tp[-1] != '.') |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2896 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2897 STRMOVE(tp, tp + 1); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2898 --tp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2899 --str_arg_l; |
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 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2902 else |
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 char *tp; |
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 // 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
|
2907 // 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
|
2908 // case. |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2909 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
|
2910 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
|
2911 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
|
2912 && tp[2] == '0' |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2913 && vim_isdigit(tp[3]) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2914 && vim_isdigit(tp[4])) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2915 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2916 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
|
2917 --str_arg_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2918 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2919 } |
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 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
|
2922 && (tmp[0] == '-' || force_sign)) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2923 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2924 // 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
|
2925 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
|
2926 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
|
2927 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2928 str_arg = tmp; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2929 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2930 } |
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 default: |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2933 // 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
|
2934 // as-is |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2935 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
|
2936 // conversion |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2937 justify_left = 1; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2938 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
|
2939 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2940 // 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
|
2941 // the unrecognized conversion character |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2942 str_arg = p; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2943 str_arg_l = 0; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2944 if (*p != NUL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2945 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
|
2946 // 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
|
2947 break; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2948 } |
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 if (*p != NUL) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2951 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
|
2952 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2953 // 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
|
2954 // 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
|
2955 // conversions |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2956 if (!justify_left) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2957 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2958 // 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
|
2959 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
|
2960 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2961 if (pn > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2962 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2963 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
|
2964 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2965 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
|
2966 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2967 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
|
2968 (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
|
2969 : (size_t)pn); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2970 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2971 str_l += pn; |
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 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2974 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2975 // 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
|
2976 // 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
|
2977 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
|
2978 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2979 // 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
|
2980 // 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
|
2981 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
|
2982 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2983 else |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2984 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2985 // 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
|
2986 // padding |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2987 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
|
2988 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2989 if (zn > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2990 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2991 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
|
2992 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2993 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
|
2994 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
2995 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
|
2996 (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
|
2997 : (size_t)zn); |
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 str_l += zn; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3000 } |
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 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
|
3003 // field width |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3004 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
|
3005 if (zn > 0) |
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 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
|
3008 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3009 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
|
3010 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3011 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
|
3012 (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
|
3013 : (size_t)zn); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3014 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3015 str_l += zn; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3016 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3017 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3018 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3019 // insert formatted string |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3020 // (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
|
3021 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3022 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
|
3023 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3024 if (sn > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3025 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3026 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
|
3027 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3028 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
|
3029 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3030 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
|
3031 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
|
3032 (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
|
3033 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3034 str_l += sn; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3035 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3036 } |
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 // insert right padding |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3039 if (justify_left) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3040 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3041 // 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
|
3042 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
|
3043 - (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
|
3044 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3045 if (pn > 0) |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3046 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3047 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
|
3048 { |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3049 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
|
3050 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3051 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
|
3052 (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
|
3053 : (size_t)pn); |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3054 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3055 str_l += pn; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3056 } |
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 vim_free(tofree); |
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 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3061 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3062 if (str_m > 0) |
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 // 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
|
3065 // 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
|
3066 // |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3067 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
|
3068 } |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3069 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3070 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
|
3071 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
|
3072 |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3073 // 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
|
3074 // 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
|
3075 // 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
|
3076 return (int)str_l; |
0082503ff2ff
patch 8.2.3320: some local functions are not static
Bram Moolenaar <Bram@vim.org>
parents:
25384
diff
changeset
|
3077 } |
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 #endif // PROTO |