src/util-string.c

   1 /*
   2     Copyright (C) 2012
   3     Ben Kibbey <bjk@luxsci.net>
   4
   5     This file is part of pwmd.
   6
   7     Pwmd is free software: you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation, either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     Pwmd is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with Pwmd.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27
  28 #include "util-string.h"
  29 #include "mem.h"
  30
  31 void string_free(struct string_s *s, int with_data)
  32 {
  33     if (!s)
  34         return;
  35
  36     if (with_data)
  37         xfree(s->str);
  38
  39     xfree(s);
  40 }
  41
  42 struct string_s *string_erase(struct string_s *s, ssize_t pos, ssize_t len)
  43 {
  44     if (pos > s->len)
  45         return s;
  46
  47     if (len == -1) {
  48         s->str[pos] = 0;
  49         s->len = s->len - pos;
  50         return s;
  51     }
  52
  53     int n = s->len - pos;
  54     n -= len;
  55     memmove(&s->str[pos], &s->str[pos+len], n);
  56     s->len -= len;
  57     s->str[s->len] = 0;
  58     return s;
  59 }
  60
  61 struct string_s *string_new(const char *str)
  62 {
  63     struct string_s *s = xcalloc(1, sizeof(struct string_s));
  64
  65     if (str) {
  66         s->str = str_dup(str);
  67         if (!s->str) {
  68             xfree(s);
  69             return NULL;
  70         }
  71
  72         s->len = strlen(s->str);
  73         s->allocated = s->len + 1;
  74     }
  75
  76     return s;
  77 }
  78
  79 struct string_s *string_append(struct string_s *s, const char *str)
  80 {
  81     size_t len = strlen(str);
  82
  83     if (s->allocated < len + s->len + 1) {
  84         char *p = xrealloc(s->str, (len + s->len + 1)*sizeof(char));
  85
  86         if (!p)
  87             return NULL;
  88
  89         s->str = p;
  90         s->allocated = s->len + len + 1;
  91     }
  92
  93     memcpy(&s->str[s->len], str, len);
  94     s->len += len;
  95     s->str[s->len] = 0;
  96     return s;
  97 }
  98
  99 struct string_s *string_truncate(struct string_s *s, size_t n)
 100 {
 101     if (s->len < n)
 102         return s;
 103
 104     s->str[n] = 0;
 105     s->len = n;
 106     return s;
 107 }
 108
 109 struct string_s *string_prepend(struct string_s *s, const char *str)
 110 {
 111     size_t len = strlen(str);
 112
 113     if (s->allocated < s->len + len + 1) {
 114         char *p = xrealloc(s->str, (len + s->len + 1)*sizeof(char));
 115
 116         if (!p)
 117             return NULL;
 118
 119         s->str = p;
 120         s->allocated = s->len + len + 1;
 121     }
 122
 123     memmove(&s->str[len], s->str, s->len);
 124     memcpy(s->str, str, len);
 125     s->len += len;
 126     s->str[s->len] = 0;
 127     return s;
 128 }
 129
 130 struct string_s *string_append_printf(struct string_s *s, const char *fmt, ...)
 131 {
 132     va_list ap;
 133     char *buf = NULL;
 134     size_t len;
 135
 136     va_start(ap, fmt);
 137     len = str_vasprintf(&buf, fmt, ap);
 138     va_end(ap);
 139
 140     if (len == -1)
 141         return NULL;
 142
 143     s = string_append(s, buf);
 144     xfree(buf);
 145     return s;
 146 }
 147
 148 struct string_s *string_insert_c(struct string_s *s, ssize_t pos, char c)
 149 {
 150     size_t len = s->len + 2;
 151
 152     if (pos >= s->allocated)
 153         len = pos+2;
 154
 155     if (s->allocated < len) {
 156         char *p = xrealloc(s->str, len*sizeof(char));
 157
 158         if (!p)
 159             return NULL;
 160
 161         s->str = p;
 162         s->allocated = len;
 163     }
 164
 165     memmove(&s->str[pos+1], &s->str[pos], s->len - pos);
 166     s->str[pos] = c;
 167     s->len = pos+1 == s->allocated ? pos+1 : s->len+1;
 168     s->str[s->len] = 0;
 169     return s;
 170 }
 171
 172 int strv_length(char **a)
 173 {
 174     int n = 0;
 175
 176     while (a && *a++)
 177         n++;
 178
 179     return n;
 180 }
 181
 182 /* 'str' must already be allocated. */
 183 char **strv_cat(char **a, char *str)
 184 {
 185     int len = a ? strv_length(a) : 0;
 186     char **dst;
 187
 188     dst = xrealloc(a, (len+2)*sizeof(char **));
 189     if (!dst)
 190         return NULL;
 191
 192     dst[len++] = str;
 193     dst[len] = NULL;
 194     return dst;
 195 }
 196
 197 int strv_printf(char ***array, const char *fmt, ...)
 198 {
 199     char **a;
 200     va_list ap;
 201     char *buf;
 202     int ret;
 203
 204     va_start(ap, fmt);
 205     ret = str_vasprintf(&buf, fmt, ap);
 206     va_end(ap);
 207
 208     if (ret == -1)
 209         return 0;
 210
 211     a = strv_cat(*array, buf);
 212     if (!a) {
 213         xfree(buf);
 214         return 0;
 215     }
 216
 217     *array = a;
 218     return 1;
 219 }
 220
 221 void strv_free(char **a)
 222 {
 223     char **p;
 224
 225     for (p = a; p && *p; p++)
 226         xfree(*p);
 227
 228     xfree(a);
 229 }
 230
 231 char **strv_dup(char **src)
 232 {
 233     char **dst = NULL;
 234     char **p;
 235
 236     for (p = src; p && *p; p++) {
 237         char **tmp;
 238         char *xp = str_dup(*p);
 239
 240         if (!xp) {
 241             strv_free(dst);
 242             return NULL;
 243         }
 244
 245         tmp = strv_cat(dst, xp);
 246         if (!tmp) {
 247             xfree(xp);
 248             strv_free(dst);
 249             return NULL;
 250         }
 251
 252         dst = tmp;
 253     }
 254
 255     return dst;
 256 }
 257
 258 char **strv_catv(char **dst, char **src)
 259 {
 260     char **p;
 261     char **d = NULL;
 262
 263     if (dst && *dst) {
 264         d = strv_dup(dst);
 265         if (!d)
 266             return NULL;
 267     }
 268
 269     for (p = src; p && *p; p++) {
 270         char **tmp;
 271         char *xp = str_dup(*p);
 272
 273         if (!xp) {
 274             strv_free(d);
 275             return NULL;
 276         }
 277
 278         tmp = strv_cat(d, xp);
 279         if (!tmp) {
 280             xfree(xp);
 281             strv_free(d);
 282             return NULL;
 283         }
 284
 285         d = tmp;
 286     }
 287
 288     return d;
 289 }
 290
 291 char **str_split(const char *str, const char *delim, int count)
 292 {
 293     char **dst = NULL;
 294     int index = 0;
 295     const char *dp = delim, *p;
 296     size_t dlen = strlen(delim);
 297     size_t pos = 0, lastpos = 0;
 298
 299     if (!str || !*str)
 300         return NULL;
 301
 302     for (p = str; *p; p++) {
 303         if (*p == *dp++) {
 304             if (!*dp) {
 305                 char **tmp;
 306                 char *xp;
 307                 size_t len = pos - lastpos - dlen + 1;
 308
 309                 xp = xmalloc(len+1);
 310                 if (!xp) {
 311                     strv_free(dst);
 312                     return NULL;
 313                 }
 314
 315                 memcpy(xp, &str[lastpos], len);
 316                 xp[len] = 0;
 317
 318                 tmp = strv_cat(dst, xp);
 319                 if (!tmp) {
 320                     xfree(xp);
 321                     strv_free(dst);
 322                     return NULL;
 323                 }
 324
 325                 dst = tmp;
 326                 lastpos = pos+1;
 327
 328                 if (count > 0 && index == count && *(p+1)) {
 329                     if (!strv_printf(&dst, "%s", p+1)) {
 330                         strv_free(dst);
 331                         return NULL;
 332                     }
 333
 334                     return dst;
 335                 }
 336
 337                 dp = delim;
 338             }
 339
 340             pos++;
 341             continue;
 342         }
 343
 344         pos++;
 345         dp = delim;
 346     }
 347
 348     p = str+lastpos;
 349     if (!strv_printf(&dst, "%s", p)) {
 350         strv_free(dst);
 351         return NULL;
 352     }
 353
 354     return dst;
 355 }
 356
 357 char *strv_join(char *delim, char **a)
 358 {
 359     char **p;
 360     char *dst = NULL;
 361     struct string_s *s = string_new("");
 362
 363     if (!s)
 364         return NULL;
 365
 366     for (p = a; *p; p++) {
 367         struct string_s *sp;
 368
 369         sp = string_append_printf(s, "%s%s", *p, delim && *(p+1) ? delim : "");
 370         if (!sp) {
 371             string_free(s, 1);
 372             return NULL;
 373         }
 374
 375         s = sp;
 376     }
 377
 378     dst = s->str;
 379     string_free(s, 0);
 380     return dst;
 381 }
 382
 383 char *str_down(char *str)
 384 {
 385     char *p;
 386
 387     for (p = str; *p; p++) {
 388         if (isascii(*p))
 389             *p = tolower(*p);
 390     }
 391
 392     return str;
 393 }
 394
 395 char *str_chomp(char *str)
 396 {
 397     int len = strlen(str);
 398     char *p = str+len-1;
 399
 400     while (len && isspace(*p)) {
 401         *p-- = 0;
 402         len--;
 403     }
 404
 405     p = str;
 406     while (isspace(*p)) {
 407         p++;
 408         len--;
 409     }
 410
 411     memmove(str, p, len);
 412     str[len] = 0;
 413     return str;
 414 }
 415
 416 char *str_dup(const char *str)
 417 {
 418     char *t;
 419     size_t len;
 420     register size_t c;
 421
 422     len = strlen(str);
 423     t = xmalloc((len+1)*sizeof(char));
 424     if (!t)
 425         return NULL;
 426
 427     for (c = 0; c < len; c++)
 428         t[c] = str[c];
 429
 430     t[c] = 0;
 431     return t;
 432 }
 433
 434 char *str_asprintf(const char *fmt, ...)
 435 {
 436     va_list ap;
 437     char *result;
 438     int len;
 439
 440     va_start(ap, fmt);
 441     len = str_vasprintf(&result, fmt, ap);
 442     va_end(ap);
 443     return len == -1 ? NULL : result;
 444 }
 445
 446 #define BUFSIZE 128
 447 int str_vasprintf(char **result, const char *fmt, va_list ap)
 448 {
 449     size_t alloc = BUFSIZE;
 450     char *buf = NULL;
 451     int len;
 452
 453     for (;;) {
 454         char *p = xrealloc(buf, alloc*sizeof(char));
 455         va_list cp;
 456
 457         if (!p) {
 458             xfree(buf);
 459             return -1;
 460         }
 461
 462         buf = p;
 463         va_copy(cp, ap);
 464         len = vsnprintf(buf, alloc, fmt, cp);
 465         va_end(cp);
 466
 467         if (len >= alloc) {
 468             alloc = len+1;
 469             continue;
 470         }
 471
 472         break;
 473     }
 474
 475     *result = buf;
 476     return len;
 477 }