subversion/libsvn_subr/svn_string.c

   1 /*
   2  * svn_string.h:  routines to manipulate counted-length strings
   3  *                (svn_stringbuf_t and svn_string_t) and C strings.
   4  *
   5  *
   6  * ====================================================================
   7  * Copyright (c) 2000-2007 CollabNet.  All rights reserved.
   8  *
   9  * This software is licensed as described in the file COPYING, which
  10  * you should have received as part of this distribution.  The terms
  11  * are also available at http://subversion.tigris.org/license-1.html.
  12  * If newer versions of this license are posted there, you may use a
  13  * newer version instead, at your option.
  14  *
  15  * This software consists of voluntary contributions made by many
  16  * individuals.  For exact contribution history, see the revision
  17  * history and logs, available at http://subversion.tigris.org/.
  18  * ====================================================================
  19  */
  20
  21
  22 \f
  23 #include <string.h>      /* for memcpy(), memcmp(), strlen() */
  24 #include <apr_lib.h>     /* for apr_isspace() */
  25 #include <apr_md5.h>
  26 #include <apr_fnmatch.h>
  27 #include "svn_string.h"  /* loads "svn_types.h" and <apr_pools.h> */
  28 #include "svn_ctype.h"
  29
  30
  31 \f
  32 /* Our own realloc, since APR doesn't have one.  Note: this is a
  33    generic realloc for memory pools, *not* for strings. */
  34 static void *
  35 my__realloc(char *data, apr_size_t oldsize, apr_size_t request,
  36             apr_pool_t *pool)
  37 {
  38   void *new_area;
  39
  40   /* kff todo: it's a pity APR doesn't give us this -- sometimes it
  41      could realloc the block merely by extending in place, sparing us
  42      a memcpy(), but only the pool would know enough to be able to do
  43      this.  We should add a realloc() to APR if someone hasn't
  44      already. */
  45
  46   /* malloc new area */
  47   new_area = apr_palloc(pool, request);
  48
  49   /* copy data to new area */
  50   memcpy(new_area, data, oldsize);
  51
  52   /* I'm NOT freeing old area here -- cuz we're using pools, ugh. */
  53
  54   /* return new area */
  55   return new_area;
  56 }
  57
  58 static APR_INLINE svn_boolean_t
  59 string_compare(const char *str1,
  60                const char *str2,
  61                apr_size_t len1,
  62                apr_size_t len2)
  63 {
  64   /* easy way out :)  */
  65   if (len1 != len2)
  66     return FALSE;
  67
  68   /* now the strings must have identical lenghths */
  69
  70   if ((memcmp(str1, str2, len1)) == 0)
  71     return TRUE;
  72   else
  73     return FALSE;
  74 }
  75
  76 static APR_INLINE apr_size_t
  77 string_first_non_whitespace(const char *str, apr_size_t len)
  78 {
  79   apr_size_t i;
  80
  81   for (i = 0; i < len; i++)
  82     {
  83       if (! apr_isspace(str[i]))
  84         return i;
  85     }
  86
  87   /* if we get here, then the string must be entirely whitespace */
  88   return len;
  89 }
  90
  91 static APR_INLINE apr_size_t
  92 find_char_backward(const char *str, apr_size_t len, char ch)
  93 {
  94   apr_size_t i = len;
  95
  96   while (i != 0)
  97     {
  98       if (str[--i] == ch)
  99         return i;
 100     }
 101
 102   /* char was not found, return len */
 103   return len;
 104 }
 105
 106 \f
 107 /* svn_string functions */
 108
 109 static svn_string_t *
 110 create_string(const char *data, apr_size_t size,
 111               apr_pool_t *pool)
 112 {
 113   svn_string_t *new_string;
 114
 115   new_string = apr_palloc(pool, sizeof(*new_string));
 116
 117   new_string->data = data;
 118   new_string->len = size;
 119
 120   return new_string;
 121 }
 122
 123 svn_string_t *
 124 svn_string_ncreate(const char *bytes, apr_size_t size, apr_pool_t *pool)
 125 {
 126   char *data;
 127
 128   data = apr_palloc(pool, size + 1);
 129   memcpy(data, bytes, size);
 130
 131   /* Null termination is the convention -- even if we suspect the data
 132      to be binary, it's not up to us to decide, it's the caller's
 133      call.  Heck, that's why they call it the caller! */
 134   data[size] = '\0';
 135
 136   /* wrap an svn_string_t around the new data */
 137   return create_string(data, size, pool);
 138 }
 139
 140
 141 svn_string_t *
 142 svn_string_create(const char *cstring, apr_pool_t *pool)
 143 {
 144   return svn_string_ncreate(cstring, strlen(cstring), pool);
 145 }
 146
 147
 148 svn_string_t *
 149 svn_string_create_from_buf(const svn_stringbuf_t *strbuf, apr_pool_t *pool)
 150 {
 151   return svn_string_ncreate(strbuf->data, strbuf->len, pool);
 152 }
 153
 154
 155 svn_string_t *
 156 svn_string_createv(apr_pool_t *pool, const char *fmt, va_list ap)
 157 {
 158   char *data = apr_pvsprintf(pool, fmt, ap);
 159
 160   /* wrap an svn_string_t around the new data */
 161   return create_string(data, strlen(data), pool);
 162 }
 163
 164
 165 svn_string_t *
 166 svn_string_createf(apr_pool_t *pool, const char *fmt, ...)
 167 {
 168   svn_string_t *str;
 169
 170   va_list ap;
 171   va_start(ap, fmt);
 172   str = svn_string_createv(pool, fmt, ap);
 173   va_end(ap);
 174
 175   return str;
 176 }
 177
 178
 179 svn_boolean_t
 180 svn_string_isempty(const svn_string_t *str)
 181 {
 182   return (str->len == 0);
 183 }
 184
 185
 186 svn_string_t *
 187 svn_string_dup(const svn_string_t *original_string, apr_pool_t *pool)
 188 {
 189   return (svn_string_ncreate(original_string->data,
 190                              original_string->len, pool));
 191 }
 192
 193
 194
 195 svn_boolean_t
 196 svn_string_compare(const svn_string_t *str1, const svn_string_t *str2)
 197 {
 198   return
 199     string_compare(str1->data, str2->data, str1->len, str2->len);
 200 }
 201
 202
 203
 204 apr_size_t
 205 svn_string_first_non_whitespace(const svn_string_t *str)
 206 {
 207   return
 208     string_first_non_whitespace(str->data, str->len);
 209 }
 210
 211
 212 apr_size_t
 213 svn_string_find_char_backward(const svn_string_t *str, char ch)
 214 {
 215   return find_char_backward(str->data, str->len, ch);
 216 }
 217
 218
 219 \f
 220 /* svn_stringbuf functions */
 221
 222 static svn_stringbuf_t *
 223 create_stringbuf(char *data, apr_size_t size, apr_pool_t *pool)
 224 {
 225   svn_stringbuf_t *new_string;
 226
 227   new_string = apr_palloc(pool, sizeof(*new_string));
 228
 229   new_string->data = data;
 230   new_string->len = size;
 231   new_string->blocksize = size + 1; /* we know there is a null-term */
 232   new_string->pool = pool;
 233
 234   return new_string;
 235 }
 236
 237 svn_stringbuf_t *
 238 svn_stringbuf_ncreate(const char *bytes, apr_size_t size, apr_pool_t *pool)
 239 {
 240   char *data;
 241
 242   data = apr_palloc(pool, size + 1);
 243   memcpy(data, bytes, size);
 244
 245   /* Null termination is the convention -- even if we suspect the data
 246      to be binary, it's not up to us to decide, it's the caller's
 247      call.  Heck, that's why they call it the caller! */
 248   data[size] = '\0';
 249
 250   /* wrap an svn_stringbuf_t around the new data */
 251   return create_stringbuf(data, size, pool);
 252 }
 253
 254
 255 svn_stringbuf_t *
 256 svn_stringbuf_create(const char *cstring, apr_pool_t *pool)
 257 {
 258   return svn_stringbuf_ncreate(cstring, strlen(cstring), pool);
 259 }
 260
 261
 262 svn_stringbuf_t *
 263 svn_stringbuf_create_from_string(const svn_string_t *str, apr_pool_t *pool)
 264 {
 265   return svn_stringbuf_ncreate(str->data, str->len, pool);
 266 }
 267
 268
 269 svn_stringbuf_t *
 270 svn_stringbuf_createv(apr_pool_t *pool, const char *fmt, va_list ap)
 271 {
 272   char *data = apr_pvsprintf(pool, fmt, ap);
 273
 274   /* wrap an svn_stringbuf_t around the new data */
 275   return create_stringbuf(data, strlen(data), pool);
 276 }
 277
 278
 279 svn_stringbuf_t *
 280 svn_stringbuf_createf(apr_pool_t *pool, const char *fmt, ...)
 281 {
 282   svn_stringbuf_t *str;
 283
 284   va_list ap;
 285   va_start(ap, fmt);
 286   str = svn_stringbuf_createv(pool, fmt, ap);
 287   va_end(ap);
 288
 289   return str;
 290 }
 291
 292
 293 void
 294 svn_stringbuf_fillchar(svn_stringbuf_t *str, unsigned char c)
 295 {
 296   memset(str->data, c, str->len);
 297 }
 298
 299
 300 void
 301 svn_stringbuf_set(svn_stringbuf_t *str, const char *value)
 302 {
 303   apr_size_t amt = strlen(value);
 304
 305   svn_stringbuf_ensure(str, amt + 1);
 306   memcpy(str->data, value, amt + 1);
 307   str->len = amt;
 308 }
 309
 310 void
 311 svn_stringbuf_setempty(svn_stringbuf_t *str)
 312 {
 313   if (str->len > 0)
 314     str->data[0] = '\0';
 315
 316   str->len = 0;
 317 }
 318
 319
 320 void
 321 svn_stringbuf_chop(svn_stringbuf_t *str, apr_size_t nbytes)
 322 {
 323   if (nbytes > str->len)
 324     str->len = 0;
 325   else
 326     str->len -= nbytes;
 327
 328   str->data[str->len] = '\0';
 329 }
 330
 331
 332 svn_boolean_t
 333 svn_stringbuf_isempty(const svn_stringbuf_t *str)
 334 {
 335   return (str->len == 0);
 336 }
 337
 338
 339 void
 340 svn_stringbuf_ensure(svn_stringbuf_t *str, apr_size_t minimum_size)
 341 {
 342   /* Keep doubling capacity until have enough. */
 343   if (str->blocksize < minimum_size)
 344     {
 345       if (str->blocksize == 0)
 346         str->blocksize = minimum_size;
 347       else
 348         while (str->blocksize < minimum_size)
 349           {
 350             apr_size_t prev_size = str->blocksize;
 351             str->blocksize *= 2;
 352             /* check for apr_size_t overflow */
 353             if (prev_size > str->blocksize)
 354               {
 355                 str->blocksize = minimum_size;
 356                 break;
 357               }
 358           }
 359
 360       str->data = (char *) my__realloc(str->data,
 361                                        str->len + 1,
 362                                        /* We need to maintain (and thus copy)
 363                                           the trailing nul */
 364                                        str->blocksize,
 365                                        str->pool);
 366     }
 367 }
 368
 369
 370 void
 371 svn_stringbuf_appendbytes(svn_stringbuf_t *str, const char *bytes,
 372                           apr_size_t count)
 373 {
 374   apr_size_t total_len;
 375   void *start_address;
 376
 377   total_len = str->len + count;  /* total size needed */
 378
 379   /* +1 for null terminator. */
 380   svn_stringbuf_ensure(str, (total_len + 1));
 381
 382   /* get address 1 byte beyond end of original bytestring */
 383   start_address = (str->data + str->len);
 384
 385   memcpy(start_address, bytes, count);
 386   str->len = total_len;
 387
 388   str->data[str->len] = '\0';  /* We don't know if this is binary
 389                                   data or not, but convention is
 390                                   to null-terminate. */
 391 }
 392
 393
 394 void
 395 svn_stringbuf_appendstr(svn_stringbuf_t *targetstr,
 396                         const svn_stringbuf_t *appendstr)
 397 {
 398   svn_stringbuf_appendbytes(targetstr, appendstr->data, appendstr->len);
 399 }
 400
 401
 402 void
 403 svn_stringbuf_appendcstr(svn_stringbuf_t *targetstr, const char *cstr)
 404 {
 405   svn_stringbuf_appendbytes(targetstr, cstr, strlen(cstr));
 406 }
 407
 408
 409
 410
 411 svn_stringbuf_t *
 412 svn_stringbuf_dup(const svn_stringbuf_t *original_string, apr_pool_t *pool)
 413 {
 414   return (svn_stringbuf_ncreate(original_string->data,
 415                                 original_string->len, pool));
 416 }
 417
 418
 419
 420 svn_boolean_t
 421 svn_stringbuf_compare(const svn_stringbuf_t *str1,
 422                       const svn_stringbuf_t *str2)
 423 {
 424   return string_compare(str1->data, str2->data, str1->len, str2->len);
 425 }
 426
 427
 428
 429 apr_size_t
 430 svn_stringbuf_first_non_whitespace(const svn_stringbuf_t *str)
 431 {
 432   return string_first_non_whitespace(str->data, str->len);
 433 }
 434
 435
 436 void
 437 svn_stringbuf_strip_whitespace(svn_stringbuf_t *str)
 438 {
 439   /* Find first non-whitespace character */
 440   apr_size_t offset = svn_stringbuf_first_non_whitespace(str);
 441
 442   /* Go ahead!  Waste some RAM, we've got pools! :)  */
 443   str->data += offset;
 444   str->len -= offset;
 445   str->blocksize -= offset;
 446
 447   /* Now that we've trimmed the front, trim the end, wasting more RAM. */
 448   while ((str->len > 0) && apr_isspace(str->data[str->len - 1]))
 449     str->len--;
 450   str->data[str->len] = '\0';
 451 }
 452
 453
 454 apr_size_t
 455 svn_stringbuf_find_char_backward(const svn_stringbuf_t *str, char ch)
 456 {
 457   return find_char_backward(str->data, str->len, ch);
 458 }
 459
 460
 461 svn_boolean_t
 462 svn_string_compare_stringbuf(const svn_string_t *str1,
 463                              const svn_stringbuf_t *str2)
 464 {
 465   return string_compare(str1->data, str2->data, str1->len, str2->len);
 466 }
 467
 468
 469 \f
 470 /*** C string stuff. ***/
 471
 472 void
 473 svn_cstring_split_append(apr_array_header_t *array,
 474                          const char *input,
 475                          const char *sep_chars,
 476                          svn_boolean_t chop_whitespace,
 477                          apr_pool_t *pool)
 478 {
 479   char *last;
 480   char *pats;
 481   char *p;
 482
 483   pats = apr_pstrdup(pool, input);  /* strtok wants non-const data */
 484   p = apr_strtok(pats, sep_chars, &last);
 485
 486   while (p)
 487     {
 488       if (chop_whitespace)
 489         {
 490           while (apr_isspace(*p))
 491             p++;
 492
 493           {
 494             char *e = p + (strlen(p) - 1);
 495             while ((e >= p) && (apr_isspace(*e)))
 496               e--;
 497             *(++e) = '\0';
 498           }
 499         }
 500
 501       if (p[0] != '\0')
 502         APR_ARRAY_PUSH(array, const char *) = p;
 503
 504       p = apr_strtok(NULL, sep_chars, &last);
 505     }
 506
 507   return;
 508 }
 509
 510
 511 apr_array_header_t *
 512 svn_cstring_split(const char *input,
 513                   const char *sep_chars,
 514                   svn_boolean_t chop_whitespace,
 515                   apr_pool_t *pool)
 516 {
 517   apr_array_header_t *a = apr_array_make(pool, 5, sizeof(input));
 518   svn_cstring_split_append(a, input, sep_chars, chop_whitespace, pool);
 519   return a;
 520 }
 521
 522
 523 svn_boolean_t svn_cstring_match_glob_list(const char *str,
 524                                           apr_array_header_t *list)
 525 {
 526   int i;
 527
 528   for (i = 0; i < list->nelts; i++)
 529     {
 530       const char *this_pattern = APR_ARRAY_IDX(list, i, char *);
 531
 532       if (apr_fnmatch(this_pattern, str, 0) == APR_SUCCESS)
 533         return TRUE;
 534     }
 535
 536   return FALSE;
 537 }
 538
 539 int svn_cstring_count_newlines(const char *msg)
 540 {
 541   int count = 0;
 542   const char *p;
 543
 544   for (p = msg; *p; p++)
 545     {
 546       if (*p == '\n')
 547         {
 548           count++;
 549           if (*(p + 1) == '\r')
 550             p++;
 551         }
 552       else if (*p == '\r')
 553         {
 554           count++;
 555           if (*(p + 1) == '\n')
 556             p++;
 557         }
 558     }
 559
 560   return count;
 561 }
 562
 563 char *
 564 svn_cstring_join(apr_array_header_t *strings,
 565                  const char *separator,
 566                  apr_pool_t *pool)
 567 {
 568   svn_stringbuf_t *new_str = svn_stringbuf_create("", pool);
 569   int sep_len = strlen(separator);
 570   int i;
 571
 572   for (i = 0; i < strings->nelts; i++)
 573     {
 574       const char *string = APR_ARRAY_IDX(strings, i, const char *);
 575       svn_stringbuf_appendbytes(new_str, string, strlen(string));
 576       svn_stringbuf_appendbytes(new_str, separator, sep_len);
 577     }
 578   return new_str->data;
 579 }
 580
 581 int
 582 svn_cstring_casecmp(const char *str1, const char *str2)
 583 {
 584   for (;;)
 585     {
 586       const int a = *str1++;
 587       const int b = *str2++;
 588       const int cmp = svn_ctype_casecmp(a, b);
 589       if (cmp || !a || !b)
 590         return cmp;
 591     }
 592 }