Debian Codegraph @

share/libc/argz.c

raw
1 /**************************************************************************/
2 /* */
3 /* This file is part of Frama-C. */
4 /* */
5 /* Copyright (C) 1995-2022 */
6 /* Free Software Foundation, Inc. */
7 /* Copyright (C) 2021-2022 */
8 /* CEA (Commissariat à l'énergie atomique et aux énergies */
9 /* alternatives) */
10 /* */
11 /* This file is derived from the GNU C Library. You can redistribute it */
12 /* and/or modify it under the terms of the GNU Lesser General Public */
13 /* License as published by the Free Software Foundation, version 2.1. */
14 /* */
15 /* you can redistribute it and/or modify it under the terms of the GNU */
16 /* Lesser General Public License as published by the Free Software */
17 /* Foundation, version 2.1. */
18 /* */
19 /* It is distributed in the hope that it will be useful, */
20 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
21 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
22 /* GNU Lesser General Public License for more details. */
23 /* */
24 /* See the GNU Lesser General Public License version 2.1 */
25 /* for more details (enclosed in the file licenses/LGPLv2.1). */
26 /* */
27 /**************************************************************************/
28
29 // Non-POSIX; this file is defined in the GNU libc.
30
31 #include "argz.h"
32
33 __PUSH_FC_STDLIB
34
35 void argz_stringify (char *argz, size_t len, int sep) {
36 if (len > 0)
37 while (1) {
38 size_t part_len = strnlen (argz, len);
39 argz += part_len;
40 len -= part_len;
41 if (len-- <= 1) break;
42 *argz++ = sep;
43 }
44 }
45
46 static void str_append (char **to, size_t *to_len, const char *buf,
47 const size_t buf_len) {
48 size_t new_len = *to_len + buf_len;
49 char *new_to = realloc (*to, new_len + 1);
50
51 if (new_to) {
52 *((char *) mempcpy (new_to + *to_len, buf, buf_len)) = '\0';
53 *to = new_to;
54 *to_len = new_len;
55 } else {
56 free (*to);
57 *to = 0;
58 }
59 }
60
61 error_t argz_replace (char **argz, size_t *argz_len, const char *str,
62 const char *with, unsigned *replace_count) {
63 error_t er = 0;
64
65 if (str && *str) {
66 char *arg = 0;
67 char *src = *argz;
68 size_t src_len = *argz_len;
69 char *dst = 0;
70 size_t dst_len = 0;
71 int delayed_copy = 1;
72 size_t str_len = strlen (str), with_len = strlen (with);
73
74 while (!er && (arg = argz_next (src, src_len, arg))) {
75 char *match = strstr (arg, str);
76 if (match) {
77 char *from = match + str_len;
78 size_t to_len = match - arg;
79 char *to = strndup (arg, to_len);
80
81 while (to && from) {
82 str_append (&to, &to_len, with, with_len);
83 if (to) {
84 match = strstr (from, str);
85 if (match) {
86 str_append (&to, &to_len, from, match - from);
87 from = match + str_len;
88 } else {
89 str_append (&to, &to_len, from, strlen (from));
90 from = 0;
91 }
92 }
93 }
94
95 if (to) {
96 if (delayed_copy) {
97 if (arg > src)
98 er = argz_append (&dst, &dst_len, src, (arg - src));
99 delayed_copy = 0;
100 }
101 if (! er)
102 er = argz_add (&dst, &dst_len, to);
103 free (to);
104 } else
105 er = ENOMEM;
106
107 if (replace_count)
108 (*replace_count)++;
109 } else if (! delayed_copy)
110 er = argz_add (&dst, &dst_len, arg);
111 }
112
113 if (! er) {
114 if (! delayed_copy) {
115 free (src);
116 *argz = dst;
117 *argz_len = dst_len;
118 }
119 } else if (dst_len > 0)
120 free (dst);
121 }
122
123 return er;
124 }
125
126 char * argz_next (const char *argz, size_t argz_len, const char *entry) {
127 if (entry) {
128 if (entry < argz + argz_len)
129 entry = strchr (entry, '\0') + 1;
130
131 return entry >= argz + argz_len ? NULL : (char *) entry;
132 } else
133 if (argz_len > 0)
134 return (char *) argz;
135 else
136 return NULL;
137 }
138
139 error_t argz_insert (char **argz, size_t *argz_len, char *before,
140 const char *entry) {
141 if (! before)
142 return argz_add (argz, argz_len, entry);
143
144 if (before < *argz || before >= *argz + *argz_len)
145 return EINVAL;
146
147 if (before > *argz)
148 while (before[-1])
149 before--;
150
151 {
152 size_t after_before = *argz_len - (before - *argz);
153 size_t entry_len = strlen (entry) + 1;
154 size_t new_argz_len = *argz_len + entry_len;
155 // before_offset must be computed before realloc, in case it will be used
156 ptrdiff_t before_offset = before - *argz;
157 char *new_argz = realloc (*argz, new_argz_len);
158
159 if (new_argz) {
160 before = new_argz + before_offset;
161 memmove (before + entry_len, before, after_before);
162 memmove (before, entry, entry_len);
163 *argz = new_argz;
164 *argz_len = new_argz_len;
165 return 0;
166 } else
167 return ENOMEM;
168 }
169 }
170
171 void argz_extract (const char *argz, size_t len, char **argv) {
172 while (len > 0) {
173 size_t part_len = strlen (argz);
174 *argv++ = (char *) argz;
175 argz += part_len + 1;
176 len -= part_len + 1;
177 }
178 *argv = 0;
179 }
180
181 void argz_delete (char **argz, size_t *argz_len, char *entry)
182 {
183 if (entry) {
184 size_t entry_len = strlen (entry) + 1;
185 *argz_len -= entry_len;
186 memmove (entry, entry + entry_len, *argz_len - (entry - *argz));
187 if (*argz_len == 0) {
188 free (*argz);
189 *argz = 0;
190 }
191 }
192 }
193
194 error_t argz_create_sep (const char *string, int delim, char **argz,
195 size_t *len) {
196 size_t nlen = strlen (string) + 1;
197
198 if (nlen > 1) {
199 const char *rp;
200 char *wp;
201
202 *argz = (char *) malloc (nlen);
203 if (*argz == NULL)
204 return ENOMEM;
205
206 rp = string;
207 wp = *argz;
208 do
209 if (*rp == delim) {
210 if (wp > *argz && wp[-1] != '\0')
211 *wp++ = '\0';
212 else
213 --nlen;
214 } else
215 *wp++ = *rp;
216 while (*rp++ != '\0');
217
218 if (nlen == 0) {
219 free (*argz);
220 *argz = NULL;
221 *len = 0;
222 }
223
224 *len = nlen;
225 } else {
226 *argz = NULL;
227 *len = 0;
228 }
229
230 return 0;
231 }
232
233 error_t argz_create (char *const argv[], char **argz, size_t *len) {
234 int argc;
235 size_t tlen = 0;
236 char *const *ap;
237 char *p;
238
239 for (argc = 0; argv[argc] != NULL; ++argc)
240 tlen += strlen (argv[argc]) + 1;
241
242 if (tlen == 0)
243 *argz = NULL;
244 else {
245 *argz = malloc (tlen);
246 if (*argz == NULL)
247 return ENOMEM;
248
249 for (p = *argz, ap = argv; *ap; ++ap, ++p)
250 p = stpcpy (p, *ap);
251 }
252 *len = tlen;
253
254 return 0;
255 }
256
257 size_t argz_count (const char *argz, size_t len) {
258 size_t count = 0;
259 while (len > 0) {
260 size_t part_len = strlen(argz);
261 argz += part_len + 1;
262 len -= part_len + 1;
263 count++;
264 }
265 return count;
266 }
267
268 error_t argz_append (char **argz, size_t *argz_len, const char *buf,
269 size_t buf_len) {
270 size_t new_argz_len = *argz_len + buf_len;
271 char *new_argz = realloc (*argz, new_argz_len);
272 if (new_argz) {
273 memcpy (new_argz + *argz_len, buf, buf_len);
274 *argz = new_argz;
275 *argz_len = new_argz_len;
276 return 0;
277 } else
278 return ENOMEM;
279 }
280
281 error_t argz_add (char **argz, size_t *argz_len, const char *str) {
282 return argz_append (argz, argz_len, str, strlen (str) + 1);
283 }
284
285 error_t argz_add_sep (char **argz, size_t *argz_len, const char *string,
286 int delim) {
287 size_t nlen = strlen (string) + 1;
288
289 if (nlen > 1) {
290 const char *rp;
291 char *wp;
292
293 *argz = (char *) realloc (*argz, *argz_len + nlen);
294 if (*argz == NULL)
295 return ENOMEM;
296
297 wp = *argz + *argz_len;
298 rp = string;
299 do
300 if (*rp == delim) {
301 if (wp > *argz && wp[-1] != '\0')
302 *wp++ = '\0';
303 else
304 --nlen;
305 }
306 else
307 *wp++ = *rp;
308 while (*rp++ != '\0');
309
310 *argz_len += nlen;
311 }
312
313 return 0;
314 }
315
316 __POP_FC_STDLIB