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_size_t blocksize, 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 = blocksize;
 232   new_string->pool = pool;
 233
 234   return new_string;
 235 }
 236
 237 svn_stringbuf_t *
 238 svn_stringbuf_create_ensure(apr_size_t blocksize, apr_pool_t *pool)
 239 {
 240   char *data = apr_palloc(pool, blocksize);
 241
 242   data[0] = '\0';
 243
 244   /* wrap an svn_stringbuf_t around the new data buffer. */
 245   return create_stringbuf(data, 0, blocksize, pool);
 246 }
 247
 248 svn_stringbuf_t *
 249 svn_stringbuf_ncreate(const char *bytes, apr_size_t size, apr_pool_t *pool)
 250 {
 251   svn_stringbuf_t *strbuf = svn_stringbuf_create_ensure(size + 1, pool);
 252
 253   memcpy(strbuf->data, bytes, size);
 254
 255   /* Null termination is the convention -- even if we suspect the data
 256      to be binary, it's not up to us to decide, it's the caller's
 257      call.  Heck, that's why they call it the caller! */
 258   strbuf->data[size] = '\0';
 259   strbuf->len = size;
 260
 261   return strbuf;
 262 }
 263
 264
 265 svn_stringbuf_t *
 266 svn_stringbuf_create(const char *cstring, apr_pool_t *pool)
 267 {
 268   return svn_stringbuf_ncreate(cstring, strlen(cstring), pool);
 269 }
 270
 271
 272 svn_stringbuf_t *
 273 svn_stringbuf_create_from_string(const svn_string_t *str, apr_pool_t *pool)
 274 {
 275   return svn_stringbuf_ncreate(str->data, str->len, pool);
 276 }
 277
 278
 279 svn_stringbuf_t *
 280 svn_stringbuf_createv(apr_pool_t *pool, const char *fmt, va_list ap)
 281 {
 282   char *data = apr_pvsprintf(pool, fmt, ap);
 283   apr_size_t size = strlen(data);
 284
 285   /* wrap an svn_stringbuf_t around the new data */
 286   return create_stringbuf(data, size, size + 1, pool);
 287 }
 288
 289
 290 svn_stringbuf_t *
 291 svn_stringbuf_createf(apr_pool_t *pool, const char *fmt, ...)
 292 {
 293   svn_stringbuf_t *str;
 294
 295   va_list ap;
 296   va_start(ap, fmt);
 297   str = svn_stringbuf_createv(pool, fmt, ap);
 298   va_end(ap);
 299
 300   return str;
 301 }
 302
 303
 304 void
 305 svn_stringbuf_fillchar(svn_stringbuf_t *str, unsigned char c)
 306 {
 307   memset(str->data, c, str->len);
 308 }
 309
 310
 311 void
 312 svn_stringbuf_set(svn_stringbuf_t *str, const char *value)
 313 {
 314   apr_size_t amt = strlen(value);
 315
 316   svn_stringbuf_ensure(str, amt + 1);
 317   memcpy(str->data, value, amt + 1);
 318   str->len = amt;
 319 }
 320
 321 void
 322 svn_stringbuf_setempty(svn_stringbuf_t *str)
 323 {
 324   if (str->len > 0)
 325     str->data[0] = '\0';
 326
 327   str->len = 0;
 328 }
 329
 330
 331 void
 332 svn_stringbuf_chop(svn_stringbuf_t *str, apr_size_t nbytes)
 333 {
 334   if (nbytes > str->len)
 335     str->len = 0;
 336   else
 337     str->len -= nbytes;
 338
 339   str->data[str->len] = '\0';
 340 }
 341
 342
 343 svn_boolean_t
 344 svn_stringbuf_isempty(const svn_stringbuf_t *str)
 345 {
 346   return (str->len == 0);
 347 }
 348
 349
 350 void
 351 svn_stringbuf_ensure(svn_stringbuf_t *str, apr_size_t minimum_size)
 352 {
 353   /* Keep doubling capacity until have enough. */
 354   if (str->blocksize < minimum_size)
 355     {
 356       if (str->blocksize == 0)
 357         str->blocksize = minimum_size;
 358       else
 359         while (str->blocksize < minimum_size)
 360           {
 361             apr_size_t prev_size = str->blocksize;
 362             str->blocksize *= 2;
 363             /* check for apr_size_t overflow */
 364             if (prev_size > str->blocksize)
 365               {
 366                 str->blocksize = minimum_size;
 367                 break;
 368               }
 369           }
 370
 371       str->data = (char *) my__realloc(str->data,
 372                                        str->len + 1,
 373                                        /* We need to maintain (and thus copy)
 374                                           the trailing nul */
 375                                        str->blocksize,
 376                                        str->pool);
 377     }
 378 }
 379
 380
 381 void
 382 svn_stringbuf_appendbytes(svn_stringbuf_t *str, const char *bytes,
 383                           apr_size_t count)
 384 {
 385   apr_size_t total_len;
 386   void *start_address;
 387
 388   total_len = str->len + count;  /* total size needed */
 389
 390   /* +1 for null terminator. */
 391   svn_stringbuf_ensure(str, (total_len + 1));
 392
 393   /* get address 1 byte beyond end of original bytestring */
 394   start_address = (str->data + str->len);
 395
 396   memcpy(start_address, bytes, count);
 397   str->len = total_len;
 398
 399   str->data[str->len] = '\0';  /* We don't know if this is binary
 400                                   data or not, but convention is
 401                                   to null-terminate. */
 402 }
 403
 404
 405 void
 406 svn_stringbuf_appendstr(svn_stringbuf_t *targetstr,
 407                         const svn_stringbuf_t *appendstr)
 408 {
 409   svn_stringbuf_appendbytes(targetstr, appendstr->data, appendstr->len);
 410 }
 411
 412
 413 void
 414 svn_stringbuf_appendcstr(svn_stringbuf_t *targetstr, const char *cstr)
 415 {
 416   svn_stringbuf_appendbytes(targetstr, cstr, strlen(cstr));
 417 }
 418
 419
 420
 421
 422 svn_stringbuf_t *
 423 svn_stringbuf_dup(const svn_stringbuf_t *original_string, apr_pool_t *pool)
 424 {
 425   return (svn_stringbuf_ncreate(original_string->data,
 426                                 original_string->len, pool));
 427 }
 428
 429
 430
 431 svn_boolean_t
 432 svn_stringbuf_compare(const svn_stringbuf_t *str1,
 433                       const svn_stringbuf_t *str2)
 434 {
 435   return string_compare(str1->data, str2->data, str1->len, str2->len);
 436 }
 437
 438
 439
 440 apr_size_t
 441 svn_stringbuf_first_non_whitespace(const svn_stringbuf_t *str)
 442 {
 443   return string_first_non_whitespace(str->data, str->len);
 444 }
 445
 446
 447 void
 448 svn_stringbuf_strip_whitespace(svn_stringbuf_t *str)
 449 {
 450   /* Find first non-whitespace character */
 451   apr_size_t offset = svn_stringbuf_first_non_whitespace(str);
 452
 453   /* Go ahead!  Waste some RAM, we've got pools! :)  */
 454   str->data += offset;
 455   str->len -= offset;
 456   str->blocksize -= offset;
 457
 458   /* Now that we've trimmed the front, trim the end, wasting more RAM. */
 459   while ((str->len > 0) && apr_isspace(str->data[str->len - 1]))
 460     str->len--;
 461   str->data[str->len] = '\0';
 462 }
 463
 464
 465 apr_size_t
 466 svn_stringbuf_find_char_backward(const svn_stringbuf_t *str, char ch)
 467 {
 468   return find_char_backward(str->data, str->len, ch);
 469 }
 470
 471
 472 svn_boolean_t
 473 svn_string_compare_stringbuf(const svn_string_t *str1,
 474                              const svn_stringbuf_t *str2)
 475 {
 476   return string_compare(str1->data, str2->data, str1->len, str2->len);
 477 }
 478
 479
 480 \f
 481 /*** C string stuff. ***/
 482
 483 void
 484 svn_cstring_split_append(apr_array_header_t *array,
 485                          const char *input,
 486                          const char *sep_chars,
 487                          svn_boolean_t chop_whitespace,
 488                          apr_pool_t *pool)
 489 {
 490   char *last;
 491   char *pats;
 492   char *p;
 493
 494   pats = apr_pstrdup(pool, input);  /* strtok wants non-const data */
 495   p = apr_strtok(pats, sep_chars, &last);
 496
 497   while (p)
 498     {
 499       if (chop_whitespace)
 500         {
 501           while (apr_isspace(*p))
 502             p++;
 503
 504           {
 505             char *e = p + (strlen(p) - 1);
 506             while ((e >= p) && (apr_isspace(*e)))
 507               e--;
 508             *(++e) = '\0';
 509           }
 510         }
 511
 512       if (p[0] != '\0')
 513         APR_ARRAY_PUSH(array, const char *) = p;
 514
 515       p = apr_strtok(NULL, sep_chars, &last);
 516     }
 517
 518   return;
 519 }
 520
 521
 522 apr_array_header_t *
 523 svn_cstring_split(const char *input,
 524                   const char *sep_chars,
 525                   svn_boolean_t chop_whitespace,
 526                   apr_pool_t *pool)
 527 {
 528   apr_array_header_t *a = apr_array_make(pool, 5, sizeof(input));
 529   svn_cstring_split_append(a, input, sep_chars, chop_whitespace, pool);
 530   return a;
 531 }
 532
 533
 534 svn_boolean_t svn_cstring_match_glob_list(const char *str,
 535                                           apr_array_header_t *list)
 536 {
 537   int i;
 538
 539   for (i = 0; i < list->nelts; i++)
 540     {
 541       const char *this_pattern = APR_ARRAY_IDX(list, i, char *);
 542
 543       if (apr_fnmatch(this_pattern, str, 0) == APR_SUCCESS)
 544         return TRUE;
 545     }
 546
 547   return FALSE;
 548 }
 549
 550 int svn_cstring_count_newlines(const char *msg)
 551 {
 552   int count = 0;
 553   const char *p;
 554
 555   for (p = msg; *p; p++)
 556     {
 557       if (*p == '\n')
 558         {
 559           count++;
 560           if (*(p + 1) == '\r')
 561             p++;
 562         }
 563       else if (*p == '\r')
 564         {
 565           count++;
 566           if (*(p + 1) == '\n')
 567             p++;
 568         }
 569     }
 570
 571   return count;
 572 }
 573
 574 char *
 575 svn_cstring_join(apr_array_header_t *strings,
 576                  const char *separator,
 577                  apr_pool_t *pool)
 578 {
 579   svn_stringbuf_t *new_str = svn_stringbuf_create("", pool);
 580   int sep_len = strlen(separator);
 581   int i;
 582
 583   for (i = 0; i < strings->nelts; i++)
 584     {
 585       const char *string = APR_ARRAY_IDX(strings, i, const char *);
 586       svn_stringbuf_appendbytes(new_str, string, strlen(string));
 587       svn_stringbuf_appendbytes(new_str, separator, sep_len);
 588     }
 589   return new_str->data;
 590 }
 591
 592 int
 593 svn_cstring_casecmp(const char *str1, const char *str2)
 594 {
 595   for (;;)
 596     {
 597       const int a = *str1++;
 598       const int b = *str2++;
 599       const int cmp = svn_ctype_casecmp(a, b);
 600       if (cmp || !a || !b)
 601         return cmp;
 602     }
 603 }