git.ozlabs.org Git - ccan/blob - 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 }