src/util-string.c

   1 /*
   2     Copyright (C) 2012, 2013, 2014, 2015, 2016, 2017
   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
  32 string_free (struct string_s *s, int with_data)
  33 {
  34   if (!s)
  35     return;
  36
  37   if (with_data)
  38     xfree (s->str);
  39
  40   xfree (s);
  41 }
  42
  43 struct string_s *
  44 string_erase (struct string_s *s, ssize_t pos, ssize_t len)
  45 {
  46   if (pos > s->len)
  47     return s;
  48
  49   if (len == -1)
  50     {
  51       s->str[pos] = 0;
  52       s->len = s->len - pos;
  53       return s;
  54     }
  55
  56   int n = s->len - pos;
  57   n -= len;
  58   memmove (&s->str[pos], &s->str[pos + len], n);
  59   s->len -= len;
  60   s->str[s->len] = 0;
  61   return s;
  62 }
  63
  64 /* Be careful about allocations since other string_ functions may
  65  * realloc the 'str' pointer. */
  66 struct string_s *
  67 string_new_content (char *str)
  68 {
  69   struct string_s *s = xcalloc (1, sizeof (struct string_s));
  70
  71   s->str = str;
  72   s->len = strlen (s->str);
  73   s->allocated = s->len + 1;
  74   return s;
  75 }
  76
  77 struct string_s *
  78 string_new (const char *str)
  79 {
  80   struct string_s *s = xcalloc (1, sizeof (struct string_s));
  81
  82   if (str)
  83     {
  84       s->str = str_dup (str);
  85       if (!s->str)
  86         {
  87           xfree (s);
  88           return NULL;
  89         }
  90
  91       s->len = strlen (s->str);
  92       s->allocated = s->len + 1;
  93     }
  94
  95   return s;
  96 }
  97
  98 struct string_s *
  99 string_append (struct string_s *s, const char *str)
 100 {
 101   size_t len = strlen (str);
 102
 103   if (s->allocated < len + s->len + 1)
 104     {
 105       char *p = xrealloc (s->str, (len + s->len + 1) * sizeof (char));
 106
 107       if (!p)
 108         return NULL;
 109
 110       s->str = p;
 111       s->allocated = s->len + len + 1;
 112     }
 113
 114   memcpy (&s->str[s->len], str, len);
 115   s->len += len;
 116   s->str[s->len] = 0;
 117   return s;
 118 }
 119
 120 struct string_s *
 121 string_truncate (struct string_s *s, size_t n)
 122 {
 123   if (!s->str)
 124     return s;
 125
 126   if (s->len < n)
 127     return s;
 128
 129   s->str[n] = 0;
 130   s->len = n;
 131   return s;
 132 }
 133
 134 struct string_s *
 135 string_prepend (struct string_s *s, const char *str)
 136 {
 137   size_t len = strlen (str);
 138
 139   if (s->allocated < s->len + len + 1)
 140     {
 141       char *p = xrealloc (s->str, (len + s->len + 1) * sizeof (char));
 142
 143       if (!p)
 144         return NULL;
 145
 146       s->str = p;
 147       s->allocated = s->len + len + 1;
 148     }
 149
 150   memmove (&s->str[len], s->str, s->len);
 151   memcpy (s->str, str, len);
 152   s->len += len;
 153   s->str[s->len] = 0;
 154   return s;
 155 }
 156
 157 struct string_s *
 158 string_append_printf (struct string_s *s, const char *fmt, ...)
 159 {
 160   va_list ap;
 161   char *buf = NULL;
 162   size_t len;
 163
 164   va_start (ap, fmt);
 165   len = str_vasprintf (&buf, fmt, ap);
 166   va_end (ap);
 167
 168   if (len == -1)
 169     return NULL;
 170
 171   s = string_append (s, buf);
 172   xfree (buf);
 173   return s;
 174 }
 175
 176 struct string_s *
 177 string_insert_c (struct string_s *s, ssize_t pos, char c)
 178 {
 179   size_t len = s->len + 2;
 180
 181   if (pos >= s->allocated)
 182     len = pos + 2;
 183
 184   if (s->allocated < len)
 185     {
 186       char *p = xrealloc (s->str, len * sizeof (char));
 187
 188       if (!p)
 189         return NULL;
 190
 191       s->str = p;
 192       s->allocated = len;
 193     }
 194
 195   memmove (&s->str[pos + 1], &s->str[pos], s->len - pos);
 196   s->str[pos] = c;
 197   s->len = pos + 1 == s->allocated ? pos + 1 : s->len + 1;
 198   s->str[s->len] = 0;
 199   return s;
 200 }
 201
 202 int
 203 strv_length (char **a)
 204 {
 205   int n = 0;
 206
 207   while (a && *a++)
 208     n++;
 209
 210   return n;
 211 }
 212
 213 /* 'str' must already be allocated. */
 214 char **
 215 strv_cat (char **a, char *str)
 216 {
 217   int len = a ? strv_length (a) : 0;
 218   char **dst;
 219
 220   dst = xrealloc (a, (len + 2) * sizeof (char *));
 221   if (!dst)
 222     return NULL;
 223
 224   dst[len++] = str;
 225   dst[len] = NULL;
 226   return dst;
 227 }
 228
 229 int
 230 strv_printf (char ***array, const char *fmt, ...)
 231 {
 232   char **a;
 233   va_list ap;
 234   char *buf;
 235   int ret;
 236
 237   va_start (ap, fmt);
 238   ret = str_vasprintf (&buf, fmt, ap);
 239   va_end (ap);
 240
 241   if (ret == -1)
 242     return 0;
 243
 244   a = strv_cat (*array, buf);
 245   if (!a)
 246     {
 247       xfree (buf);
 248       return 0;
 249     }
 250
 251   *array = a;
 252   return 1;
 253 }
 254
 255 void
 256 strv_free (char **a)
 257 {
 258   char **p;
 259
 260   for (p = a; p && *p; p++)
 261     xfree (*p);
 262
 263   xfree (a);
 264 }
 265
 266 char **
 267 strv_dup (char **src)
 268 {
 269   char **dst = NULL;
 270   char **p;
 271
 272   for (p = src; p && *p; p++)
 273     {
 274       char **tmp;
 275       char *xp = str_dup (*p);
 276
 277       if (!xp)
 278         {
 279           strv_free (dst);
 280           return NULL;
 281         }
 282
 283       tmp = strv_cat (dst, xp);
 284       if (!tmp)
 285         {
 286           xfree (xp);
 287           strv_free (dst);
 288           return NULL;
 289         }
 290
 291       dst = tmp;
 292     }
 293
 294   return dst;
 295 }
 296
 297 char **
 298 strv_catv (char **dst, char **src)
 299 {
 300   char **p;
 301   char **d = NULL;
 302
 303   if (dst && *dst)
 304     {
 305       d = strv_dup (dst);
 306       if (!d)
 307         return NULL;
 308     }
 309
 310   for (p = src; p && *p; p++)
 311     {
 312       char **tmp;
 313       char *xp = str_dup (*p);
 314
 315       if (!xp)
 316         {
 317           strv_free (d);
 318           return NULL;
 319         }
 320
 321       tmp = strv_cat (d, xp);
 322       if (!tmp)
 323         {
 324           xfree (xp);
 325           strv_free (d);
 326           return NULL;
 327         }
 328
 329       d = tmp;
 330     }
 331
 332   return d;
 333 }
 334
 335 static char *
 336 trim (char *str)
 337 {
 338   size_t len;
 339   char *p = str;
 340
 341   if (!str || !*str)
 342     return str;
 343
 344   len = strlen (str);
 345   while (len && isspace (str[--len]))
 346     str[len] = 0;
 347
 348   while (p && *p && isspace (*p))
 349     p++;
 350
 351   return p;
 352 }
 353
 354 static char **
 355 str_split_common (const char *src, const char *delim, int count, int ws)
 356 {
 357   char **dst = NULL;
 358   int index = 0;
 359   const char *dp = delim;
 360   char *str = str_dup (src);
 361   char *p = str;
 362   size_t dlen = strlen (delim);
 363   size_t pos = 0, lastpos = 0;
 364
 365   if (!str || !*str)
 366     {
 367       xfree (str);
 368       return NULL;
 369     }
 370
 371   for (; *p; p++)
 372     {
 373       if (*p == *dp++)
 374         {
 375           if (!*dp)
 376             {
 377               char **tmp;
 378               char *xp, *s;
 379               size_t len = pos - lastpos - dlen + 1;
 380
 381               index++;
 382               xp = xmalloc (len + 1);
 383               if (!xp)
 384                 {
 385                   strv_free (dst);
 386                   xfree (str);
 387                   return NULL;
 388                 }
 389
 390               memcpy (xp, &str[lastpos], len);
 391               xp[len] = 0;
 392               s = xp;
 393
 394               if (ws)
 395                 s = trim (xp);
 396
 397               tmp = strv_cat (dst, s);
 398               if (!tmp)
 399                 {
 400                   xfree (xp);
 401                   strv_free (dst);
 402                   xfree (str);
 403                   return NULL;
 404                 }
 405
 406               dst = tmp;
 407               lastpos = pos + 1;
 408
 409               if (count > 0 && index+1 == count && *(p + 1))
 410                 {
 411                   if (!strv_printf (&dst, "%s", p + 1))
 412                     {
 413                       strv_free (dst);
 414                       xfree (str);
 415                       return NULL;
 416                     }
 417
 418                   xfree (str);
 419                   return dst;
 420                 }
 421
 422               dp = delim;
 423             }
 424
 425           pos++;
 426           continue;
 427         }
 428
 429       pos++;
 430       dp = delim;
 431     }
 432
 433   p = str + lastpos;
 434   if (ws)
 435     p = trim (p);
 436
 437   if (!strv_printf (&dst, "%s", p))
 438     {
 439       strv_free (dst);
 440       xfree (str);
 441       return NULL;
 442     }
 443
 444   xfree (str);
 445   return dst;
 446 }
 447
 448 /* Like str_split() but trims whitespace between 'delim'. */
 449 char **
 450 str_split_ws (const char *str, const char *delim, int count)
 451 {
 452   return str_split_common (str, delim, count, 1);
 453 }
 454
 455 char **
 456 str_split (const char *str, const char *delim, int count)
 457 {
 458   return str_split_common (str, delim, count, 0);
 459 }
 460
 461 char *
 462 strv_join (const char *delim, char **a)
 463 {
 464   char **p;
 465   char *dst = NULL;
 466   struct string_s *s = string_new ("");
 467
 468   if (!s)
 469     return NULL;
 470
 471   for (p = a; p && *p; p++)
 472     {
 473       struct string_s *sp;
 474
 475       sp = string_append_printf (s, "%s%s", *p, delim
 476                                  && *(p + 1) ? delim : "");
 477       if (!sp)
 478         {
 479           string_free (s, 1);
 480           return NULL;
 481         }
 482
 483       s = sp;
 484     }
 485
 486   dst = s->str;
 487   string_free (s, 0);
 488   return dst;
 489 }
 490
 491 char *
 492 str_down (char *str)
 493 {
 494   char *p;
 495
 496   for (p = str; *p; p++)
 497     {
 498       if (isascii (*p))
 499         *p = tolower (*p);
 500     }
 501
 502   return str;
 503 }
 504
 505 char *
 506 str_chomp (char *str)
 507 {
 508   int len = strlen (str);
 509   char *p = str + len - 1;
 510
 511   while (len && isspace (*p))
 512     {
 513       *p-- = 0;
 514       len--;
 515     }
 516
 517   p = str;
 518   while (isspace (*p))
 519     {
 520       p++;
 521       len--;
 522     }
 523
 524   memmove (str, p, len);
 525   str[len] = 0;
 526   return str;
 527 }
 528
 529 char *
 530 str_dup (const char *str)
 531 {
 532   char *t;
 533   size_t len;
 534   register size_t c;
 535
 536   len = strlen (str);
 537   t = xmalloc ((len + 1) * sizeof (char));
 538   if (!t)
 539     return NULL;
 540
 541   for (c = 0; c < len; c++)
 542     t[c] = str[c];
 543
 544   t[c] = 0;
 545   return t;
 546 }
 547
 548 char *
 549 str_asprintf (const char *fmt, ...)
 550 {
 551   va_list ap;
 552   char *result;
 553   int len;
 554
 555   va_start (ap, fmt);
 556   len = str_vasprintf (&result, fmt, ap);
 557   va_end (ap);
 558   return len == -1 ? NULL : result;
 559 }
 560
 561 int
 562 str_vasprintf (char **result, const char *fmt, va_list ap)
 563 {
 564   char *buf = NULL;
 565   int len;
 566   va_list cp;
 567
 568   va_copy (cp, ap);
 569   len = vsnprintf (NULL, 0, fmt, cp);
 570   va_end (cp);
 571
 572   buf = xmalloc (++len);
 573   if (!buf)
 574     return -1;
 575
 576   va_copy (cp, ap);
 577   len = vsnprintf (buf, len, fmt, cp);
 578   va_end (cp);
 579   if (len == -1)
 580     {
 581       xfree (buf);
 582       return len;
 583     }
 584   *result = buf;
 585   return len;
 586 }