4b3b11aa603cf23733ec9aa24251e602c2c7723f
[ccan] / ccan / tal / str / str.c
1 /* Licensed under BSD-MIT - see LICENSE file for details */
2 #include <unistd.h>
3 #include <stdint.h>
4 #include <string.h>
5 #include <limits.h>
6 #include <stdlib.h>
7 #include "str.h"
8 #include <sys/types.h>
9 #include <regex.h>
10 #include <stdarg.h>
11 #include <unistd.h>
12 #include <stdio.h>
13 #include <ccan/str/str.h>
14
15 char *tal_strdup(const tal_t *ctx, const char *p)
16 {
17         /* We have to let through NULL for take(). */
18         return tal_dup_(ctx, p, 1, p ? strlen(p) + 1: 1, 0, false,
19                         TAL_LABEL(char, "[]"));
20 }
21
22 char *tal_strndup(const tal_t *ctx, const char *p, size_t n)
23 {
24         size_t len;
25         char *ret;
26
27         /* We have to let through NULL for take(). */
28         if (likely(p))
29                 len = strnlen(p, n);
30         else
31                 len = n;
32
33         ret = tal_dup_(ctx, p, 1, len, 1, false, TAL_LABEL(char, "[]"));
34         if (ret)
35                 ret[len] = '\0';
36         return ret;
37 }
38
39 char *tal_fmt(const tal_t *ctx, const char *fmt, ...)
40 {
41         va_list ap;
42         char *ret;
43
44         va_start(ap, fmt);
45         ret = tal_vfmt(ctx, fmt, ap);
46         va_end(ap);
47
48         return ret;
49 }
50
51 static bool do_vfmt(char **buf, size_t off, const char *fmt, va_list ap)
52 {
53         /* A decent guess to start. */
54         size_t max = strlen(fmt) * 2 + 1;
55         bool ok;
56
57         for (;;) {
58                 va_list ap2;
59                 int ret;
60
61                 if (!tal_resize(buf, off + max)) {
62                         ok = false;
63                         break;
64                 }
65
66                 va_copy(ap2, ap);
67                 ret = vsnprintf(*buf + off, max, fmt, ap2);
68                 va_end(ap2);
69
70                 if (ret < max) {
71                         ok = true;
72                         break;
73                 }
74                 max *= 2;
75         }
76
77         if (taken(fmt))
78                 tal_free(fmt);
79         return ok;
80 }
81
82 char *tal_vfmt(const tal_t *ctx, const char *fmt, va_list ap)
83 {
84         char *buf;
85
86         if (!fmt && taken(fmt))
87                 return NULL;
88
89         /* A decent guess to start. */
90         buf = tal_arr(ctx, char, strlen(fmt) * 2);
91         if (!do_vfmt(&buf, 0, fmt, ap))
92                 buf = tal_free(buf);
93         return buf;
94 }
95
96 bool tal_append_vfmt(char **baseptr, const char *fmt, va_list ap)
97 {
98         if (!fmt && taken(fmt))
99                 return false;
100
101         return do_vfmt(baseptr, strlen(*baseptr), fmt, ap);
102 }
103
104 bool tal_append_fmt(char **baseptr, const char *fmt, ...)
105 {
106         va_list ap;
107         bool ret;
108
109         va_start(ap, fmt);
110         ret = tal_append_vfmt(baseptr, fmt, ap);
111         va_end(ap);
112
113         return ret;
114 }
115
116 char *tal_strcat(const tal_t *ctx, const char *s1, const char *s2)
117 {
118         size_t len1, len2;
119         char *ret;
120
121         if (unlikely(!s2) && taken(s2)) {
122                 if (taken(s1))
123                         tal_free(s1);
124                 return NULL;
125         }
126         /* We have to let through NULL for take(). */
127         len1 = s1 ? strlen(s1) : 0;
128         len2 = strlen(s2);
129
130         /* We use tal_dup_ here to avoid attaching a length property. */
131         ret = tal_dup_(ctx, s1, 1, len1, len2 + 1, false,
132                        TAL_LABEL(char, "[]"));
133         if (likely(ret))
134                 memcpy(ret + len1, s2, len2 + 1);
135
136         if (taken(s2))
137                 tal_free(s2);
138         return ret;
139 }
140
141 char **tal_strsplit(const tal_t *ctx,
142                     const char *string, const char *delims, enum strsplit flags)
143 {
144         char **parts, *str;
145         size_t max = 64, num = 0;
146
147         parts = tal_arr(ctx, char *, max + 1);
148         if (unlikely(!parts)) {
149                 if (taken(string))
150                         tal_free(string);
151                 if (taken(delims))
152                         tal_free(delims);
153                 return NULL;
154         }
155         str = tal_strdup(parts, string);
156         if (unlikely(!str))
157                 goto fail;
158         if (unlikely(!delims) && is_taken(delims))
159                 goto fail;
160
161         if (flags == STR_NO_EMPTY)
162                 str += strspn(str, delims);
163
164         while (*str != '\0') {
165                 size_t len = strcspn(str, delims), dlen;
166
167                 parts[num] = str;
168                 dlen = strspn(str + len, delims);
169                 parts[num][len] = '\0';
170                 if (flags == STR_EMPTY_OK && dlen)
171                         dlen = 1;
172                 str += len + dlen;
173                 if (++num == max && !tal_resize(&parts, max*=2 + 1))
174                         goto fail;
175         }
176         parts[num] = NULL;
177
178         /* Ensure that tal_count() is correct. */
179         if (unlikely(!tal_resize(&parts, num+1)))
180                 goto fail;
181
182         if (taken(delims))
183                 tal_free(delims);
184         return parts;
185
186 fail:
187         tal_free(parts);
188         if (taken(delims))
189                 tal_free(delims);
190         return NULL;
191 }
192
193 char *tal_strjoin(const tal_t *ctx,
194                   char *strings[], const char *delim, enum strjoin flags)
195 {
196         unsigned int i;
197         char *ret = NULL;
198         size_t totlen = 0, dlen;
199
200         if (unlikely(!strings) && is_taken(strings))
201                 goto fail;
202
203         if (unlikely(!delim) && is_taken(delim))
204                 goto fail;
205
206         dlen = strlen(delim);
207         ret = tal_arr(ctx, char, dlen*2+1);
208         if (!ret)
209                 goto fail;
210
211         ret[0] = '\0';
212         for (i = 0; strings[i]; i++) {
213                 size_t len = strlen(strings[i]);
214
215                 if (flags == STR_NO_TRAIL && !strings[i+1])
216                         dlen = 0;
217                 if (!tal_resize(&ret, totlen + len + dlen + 1))
218                         goto fail;
219                 memcpy(ret + totlen, strings[i], len);
220                 totlen += len;
221                 memcpy(ret + totlen, delim, dlen);
222                 totlen += dlen;
223         }
224         ret[totlen] = '\0';
225 out:
226         if (taken(strings))
227                 tal_free(strings);
228         if (taken(delim))
229                 tal_free(delim);
230         return ret;
231 fail:
232         ret = tal_free(ret);
233         goto out;
234 }
235
236 static size_t count_open_braces(const char *string)
237 {
238 #if 1
239         size_t num = 0, esc = 0;
240
241         while (*string) {
242                 if (*string == '\\')
243                         esc++;
244                 else {
245                         /* An odd number of \ means it's escaped. */
246                         if (*string == '(' && (esc & 1) == 0)
247                                 num++;
248                         esc = 0;
249                 }
250                 string++;
251         }
252         return num;
253 #else
254         return strcount(string, "(");
255 #endif
256 }
257
258 bool tal_strreg(const tal_t *ctx, const char *string, const char *regex, ...)
259 {
260         size_t nmatch = 1 + count_open_braces(regex);
261         regmatch_t matches[nmatch];
262         regex_t r;
263         bool ret = false;
264         unsigned int i;
265         va_list ap;
266
267         if (unlikely(!regex) && is_taken(regex))
268                 goto fail_no_re;
269
270         if (regcomp(&r, regex, REG_EXTENDED) != 0)
271                 goto fail_no_re;
272
273         if (unlikely(!string) && is_taken(string))
274                 goto fail;
275
276         if (regexec(&r, string, nmatch, matches, 0) != 0)
277                 goto fail;
278
279         ret = true;
280         va_start(ap, regex);
281         for (i = 1; i < nmatch; i++) {
282                 char **arg = va_arg(ap, char **);
283                 if (arg) {
284                         /* eg. ([a-z])? can give "no match". */
285                         if (matches[i].rm_so == -1)
286                                 *arg = NULL;
287                         else {
288                                 *arg = tal_strndup(ctx,
289                                                    string + matches[i].rm_so,
290                                                    matches[i].rm_eo
291                                                    - matches[i].rm_so);
292                                 /* FIXME: If we fail, we set some and leak! */
293                                 if (!*arg) {
294                                         ret = false;
295                                         break;
296                                 }
297                         }
298                 }
299         }
300         va_end(ap);
301 fail:
302         regfree(&r);
303 fail_no_re:
304         if (taken(regex))
305                 tal_free(regex);
306         if (taken(string))
307                 tal_free(string);
308         return ret;
309 }