771c07c24ee69ddd2bac49c408f62766768f4c67
[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 #include <ccan/tal/tal.h>
15 #include <ccan/take/take.h>
16
17 char *tal_strdup(const tal_t *ctx, const char *p)
18 {
19         /* We have to let through NULL for take(). */
20         return tal_dup_(ctx, p, 1, p ? strlen(p) + 1: 1, 0, false,
21                         TAL_LABEL(char, "[]"));
22 }
23
24 char *tal_strndup(const tal_t *ctx, const char *p, size_t n)
25 {
26         size_t len;
27         char *ret;
28
29         /* We have to let through NULL for take(). */
30         if (likely(p)) {
31                 len = strlen(p);
32                 if (len > n)
33                         len = n;
34         } else
35                 len = n;
36
37         ret = tal_dup_(ctx, p, 1, len, 1, false, TAL_LABEL(char, "[]"));
38         if (ret)
39                 ret[len] = '\0';
40         return ret;
41 }
42
43 char *tal_fmt(const tal_t *ctx, const char *fmt, ...)
44 {
45         va_list ap;
46         char *ret;
47
48         va_start(ap, fmt);
49         ret = tal_vfmt(ctx, fmt, ap);
50         va_end(ap);
51
52         return ret;
53 }
54
55 char *tal_vfmt(const tal_t *ctx, const char *fmt, va_list ap)
56 {
57         size_t max;
58         char *buf;
59         int ret;
60
61         if (!fmt && taken(fmt))
62                 return NULL;
63
64         /* A decent guess to start. */
65         max = strlen(fmt) * 2;
66         buf = tal_arr(ctx, char, max);
67         while (buf) {
68                 va_list ap2;
69
70                 va_copy(ap2, ap);
71                 ret = vsnprintf(buf, max, fmt, ap2);
72                 va_end(ap2);
73
74                 if (ret < max)
75                         break;
76                 if (!tal_resize(&buf, max *= 2))
77                         buf = tal_free(buf);
78         }
79         if (taken(fmt))
80                 tal_free(fmt);
81         return buf;
82 }
83
84 char *tal_strcat(const tal_t *ctx, const char *s1, const char *s2)
85 {
86         size_t len1, len2;
87         char *ret;
88
89         if (unlikely(!s2) && taken(s2)) {
90                 if (taken(s1))
91                         tal_free(s1);
92                 return NULL;
93         }
94         /* We have to let through NULL for take(). */
95         len1 = s1 ? strlen(s1) : 0;
96         len2 = strlen(s2);
97
98         /* We use tal_dup_ here to avoid attaching a length property. */
99         ret = tal_dup_(ctx, s1, 1, len1, len2 + 1, false,
100                        TAL_LABEL(char, "[]"));
101         if (likely(ret))
102                 memcpy(ret + len1, s2, len2 + 1);
103
104         if (taken(s2))
105                 tal_free(s2);
106         return ret;
107 }
108
109 char **tal_strsplit(const tal_t *ctx,
110                     const char *string, const char *delims, enum strsplit flags)
111 {
112         char **parts, *str;
113         size_t max = 64, num = 0;
114
115         parts = tal_arr(ctx, char *, max + 1);
116         if (unlikely(!parts)) {
117                 if (taken(string))
118                         tal_free(string);
119                 if (taken(delims))
120                         tal_free(delims);
121                 return NULL;
122         }
123         str = tal_strdup(parts, string);
124         if (unlikely(!str))
125                 goto fail;
126         if (unlikely(!delims) && is_taken(delims))
127                 goto fail;
128
129         if (flags == STR_NO_EMPTY)
130                 str += strspn(str, delims);
131
132         while (*str != '\0') {
133                 size_t len = strcspn(str, delims), dlen;
134
135                 parts[num] = str;
136                 dlen = strspn(str + len, delims);
137                 parts[num][len] = '\0';
138                 if (flags == STR_EMPTY_OK && dlen)
139                         dlen = 1;
140                 str += len + dlen;
141                 if (++num == max && !tal_resize(&parts, max*=2 + 1))
142                         goto fail;
143         }
144         parts[num] = NULL;
145
146         /* Ensure that tal_count() is correct. */
147         if (unlikely(!tal_resize(&parts, num+1)))
148                 goto fail;
149
150         if (taken(delims))
151                 tal_free(delims);
152         return parts;
153
154 fail:
155         tal_free(parts);
156         if (taken(delims))
157                 tal_free(delims);
158         return NULL;
159 }
160
161 char *tal_strjoin(const tal_t *ctx,
162                   char *strings[], const char *delim, enum strjoin flags)
163 {
164         unsigned int i;
165         char *ret = NULL;
166         size_t totlen = 0, dlen;
167
168         if (unlikely(!strings) && is_taken(strings))
169                 goto fail;
170
171         if (unlikely(!delim) && is_taken(delim))
172                 goto fail;
173
174         dlen = strlen(delim);
175         ret = tal_arr(ctx, char, dlen*2+1);
176         if (!ret)
177                 goto fail;
178
179         ret[0] = '\0';
180         for (i = 0; strings[i]; i++) {
181                 size_t len = strlen(strings[i]);
182
183                 if (flags == STR_NO_TRAIL && !strings[i+1])
184                         dlen = 0;
185                 if (!tal_resize(&ret, totlen + len + dlen + 1))
186                         goto fail;
187                 memcpy(ret + totlen, strings[i], len);
188                 totlen += len;
189                 memcpy(ret + totlen, delim, dlen);
190                 totlen += dlen;
191         }
192         ret[totlen] = '\0';
193 out:
194         if (taken(strings))
195                 tal_free(strings);
196         if (taken(delim))
197                 tal_free(delim);
198         return ret;
199 fail:
200         ret = tal_free(ret);
201         goto out;
202 }
203
204 bool tal_strreg(const tal_t *ctx, const char *string, const char *regex, ...)
205 {
206         size_t nmatch = 1 + strcount(regex, "(");
207         regmatch_t matches[nmatch];
208         regex_t r;
209         bool ret = false;
210         unsigned int i;
211         va_list ap;
212
213         if (unlikely(!regex) && is_taken(regex))
214                 goto fail_no_re;
215
216         if (regcomp(&r, regex, REG_EXTENDED) != 0)
217                 goto fail_no_re;
218
219         if (unlikely(!string) && is_taken(string))
220                 goto fail;
221
222         if (regexec(&r, string, nmatch, matches, 0) != 0)
223                 goto fail;
224
225         ret = true;
226         va_start(ap, regex);
227         for (i = 1; i < nmatch; i++) {
228                 char **arg = va_arg(ap, char **);
229                 if (arg) {
230                         /* eg. ([a-z])? can give "no match". */
231                         if (matches[i].rm_so == -1)
232                                 *arg = NULL;
233                         else {
234                                 *arg = tal_strndup(ctx,
235                                                    string + matches[i].rm_so,
236                                                    matches[i].rm_eo
237                                                    - matches[i].rm_so);
238                                 /* FIXME: If we fail, we set some and leak! */
239                                 if (!*arg) {
240                                         ret = false;
241                                         break;
242                                 }
243                         }
244                 }
245         }
246         va_end(ap);
247 fail:
248         regfree(&r);
249 fail_no_re:
250         if (taken(regex))
251                 tal_free(regex);
252         if (taken(string))
253                 tal_free(string);
254         return ret;
255 }