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, const char *label)
  16 {
  17         /* We have to let through NULL for take(). */
  18         return tal_dup_arr_label(ctx, char, p, p ? strlen(p) + 1: 1, 0, label);
  19 }
  20
  21 char *tal_strndup_(const tal_t *ctx, const char *p, size_t n, const char *label)
  22 {
  23         size_t len;
  24         char *ret;
  25
  26         /* We have to let through NULL for take(). */
  27         if (likely(p))
  28                 len = strnlen(p, n);
  29         else
  30                 len = n;
  31
  32         ret = tal_dup_arr_label(ctx, char, p, len, 1, label);
  33         if (ret)
  34                 ret[len] = '\0';
  35         return ret;
  36 }
  37
  38 char *tal_fmt_(const tal_t *ctx, const char *label, const char *fmt, ...)
  39 {
  40         va_list ap;
  41         char *ret;
  42
  43         va_start(ap, fmt);
  44         ret = tal_vfmt_(ctx, fmt, ap, label);
  45         va_end(ap);
  46
  47         return ret;
  48 }
  49
  50 static bool do_vfmt(char **buf, size_t off, const char *fmt, va_list ap)
  51 {
  52         /* A decent guess to start. */
  53         size_t max = strlen(fmt) * 2 + 1;
  54         bool ok;
  55
  56         for (;;) {
  57                 va_list ap2;
  58                 int ret;
  59
  60                 if (!tal_resize(buf, off + max)) {
  61                         ok = false;
  62                         break;
  63                 }
  64
  65                 va_copy(ap2, ap);
  66                 ret = vsnprintf(*buf + off, max, fmt, ap2);
  67                 va_end(ap2);
  68
  69                 if (ret < max) {
  70                         ok = true;
  71                         break;
  72                 }
  73                 max *= 2;
  74         }
  75
  76         if (taken(fmt))
  77                 tal_free(fmt);
  78         return ok;
  79 }
  80
  81 char *tal_vfmt_(const tal_t *ctx, const char *fmt, va_list ap, const char *label)
  82 {
  83         char *buf;
  84
  85         if (!fmt && taken(fmt))
  86                 return NULL;
  87
  88         /* A decent guess to start. */
  89         buf = tal_arr_label(ctx, char, strlen(fmt) * 2, label);
  90         if (!do_vfmt(&buf, 0, fmt, ap))
  91                 buf = tal_free(buf);
  92         return buf;
  93 }
  94
  95 bool tal_append_vfmt(char **baseptr, const char *fmt, va_list ap)
  96 {
  97         if (!fmt && taken(fmt))
  98                 return false;
  99
 100         return do_vfmt(baseptr, strlen(*baseptr), fmt, ap);
 101 }
 102
 103 bool tal_append_fmt(char **baseptr, const char *fmt, ...)
 104 {
 105         va_list ap;
 106         bool ret;
 107
 108         va_start(ap, fmt);
 109         ret = tal_append_vfmt(baseptr, fmt, ap);
 110         va_end(ap);
 111
 112         return ret;
 113 }
 114
 115 char *tal_strcat_(const tal_t *ctx, const char *s1, const char *s2,
 116                   const char *label)
 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         ret = tal_dup_arr_label(ctx, char, s1, len1, len2 + 1, label);
 131         if (likely(ret))
 132                 memcpy(ret + len1, s2, len2 + 1);
 133
 134         if (taken(s2))
 135                 tal_free(s2);
 136         return ret;
 137 }
 138
 139 char **tal_strsplit_(const tal_t *ctx,
 140                      const char *string, const char *delims, enum strsplit flags,
 141                      const char *label)
 142 {
 143         char **parts, *str;
 144         size_t max = 64, num = 0;
 145
 146         parts = tal_arr(ctx, char *, max + 1);
 147         if (unlikely(!parts)) {
 148                 if (taken(string))
 149                         tal_free(string);
 150                 if (taken(delims))
 151                         tal_free(delims);
 152                 return NULL;
 153         }
 154         str = tal_strdup(parts, string);
 155         if (unlikely(!str))
 156                 goto fail;
 157         if (unlikely(!delims) && is_taken(delims))
 158                 goto fail;
 159
 160         if (flags == STR_NO_EMPTY)
 161                 str += strspn(str, delims);
 162
 163         while (*str != '\0') {
 164                 size_t len = strcspn(str, delims), dlen;
 165
 166                 parts[num] = str;
 167                 dlen = strspn(str + len, delims);
 168                 parts[num][len] = '\0';
 169                 if (flags == STR_EMPTY_OK && dlen)
 170                         dlen = 1;
 171                 str += len + dlen;
 172                 if (++num == max && !tal_resize(&parts, max*=2 + 1))
 173                         goto fail;
 174         }
 175         parts[num] = NULL;
 176
 177         /* Ensure that tal_count() is correct. */
 178         if (unlikely(!tal_resize(&parts, num+1)))
 179                 goto fail;
 180
 181         if (taken(delims))
 182                 tal_free(delims);
 183         return parts;
 184
 185 fail:
 186         tal_free(parts);
 187         if (taken(delims))
 188                 tal_free(delims);
 189         return NULL;
 190 }
 191
 192 char *tal_strjoin_(const tal_t *ctx,
 193                    char *strings[], const char *delim, enum strjoin flags,
 194                    const char *label)
 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_label(ctx, char, dlen*2+1, label);
 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 *label,
 259                  const char *regex, ...)
 260 {
 261         size_t nmatch = 1 + count_open_braces(regex);
 262         regmatch_t matches[nmatch];
 263         regex_t r;
 264         bool ret = false;
 265         unsigned int i;
 266         va_list ap;
 267
 268         if (unlikely(!regex) && is_taken(regex))
 269                 goto fail_no_re;
 270
 271         if (regcomp(&r, regex, REG_EXTENDED) != 0)
 272                 goto fail_no_re;
 273
 274         if (unlikely(!string) && is_taken(string))
 275                 goto fail;
 276
 277         if (regexec(&r, string, nmatch, matches, 0) != 0)
 278                 goto fail;
 279
 280         ret = true;
 281         va_start(ap, regex);
 282         for (i = 1; i < nmatch; i++) {
 283                 char **arg = va_arg(ap, char **);
 284                 if (arg) {
 285                         /* eg. ([a-z])? can give "no match". */
 286                         if (matches[i].rm_so == -1)
 287                                 *arg = NULL;
 288                         else {
 289                                 *arg = tal_strndup_(ctx,
 290                                                     string + matches[i].rm_so,
 291                                                     matches[i].rm_eo
 292                                                     - matches[i].rm_so,
 293                                                     label);
 294                                 /* FIXME: If we fail, we set some and leak! */
 295                                 if (!*arg) {
 296                                         ret = false;
 297                                         break;
 298                                 }
 299                         }
 300                 }
 301         }
 302         va_end(ap);
 303 fail:
 304         regfree(&r);
 305 fail_no_re:
 306         if (taken(regex))
 307                 tal_free(regex);
 308         if (taken(string))
 309                 tal_free(string);
 310         return ret;
 311 }