git.oblomov.eu Git - git/blob - strbuf.c

   1 #include "cache.h"
   2 #include "refs.h"
   3 #include "utf8.h"
   4
   5 int starts_with(const char *str, const char *prefix)
   6 {
   7         for (; ; str++, prefix++)
   8                 if (!*prefix)
   9                         return 1;
  10                 else if (*str != *prefix)
  11                         return 0;
  12 }
  13
  14 int istarts_with(const char *str, const char *prefix)
  15 {
  16         for (; ; str++, prefix++)
  17                 if (!*prefix)
  18                         return 1;
  19                 else if (tolower(*str) != tolower(*prefix))
  20                         return 0;
  21 }
  22
  23 int skip_to_optional_arg_default(const char *str, const char *prefix,
  24                                  const char **arg, const char *def)
  25 {
  26         const char *p;
  27
  28         if (!skip_prefix(str, prefix, &p))
  29                 return 0;
  30
  31         if (!*p) {
  32                 if (arg)
  33                         *arg = def;
  34                 return 1;
  35         }
  36
  37         if (*p != '=')
  38                 return 0;
  39
  40         if (arg)
  41                 *arg = p + 1;
  42         return 1;
  43 }
  44
  45 /*
  46  * Used as the default ->buf value, so that people can always assume
  47  * buf is non NULL and ->buf is NUL terminated even for a freshly
  48  * initialized strbuf.
  49  */
  50 char strbuf_slopbuf[1];
  51
  52 void strbuf_init(struct strbuf *sb, size_t hint)
  53 {
  54         sb->alloc = sb->len = 0;
  55         sb->buf = strbuf_slopbuf;
  56         if (hint)
  57                 strbuf_grow(sb, hint);
  58 }
  59
  60 void strbuf_release(struct strbuf *sb)
  61 {
  62         if (sb->alloc) {
  63                 free(sb->buf);
  64                 strbuf_init(sb, 0);
  65         }
  66 }
  67
  68 char *strbuf_detach(struct strbuf *sb, size_t *sz)
  69 {
  70         char *res;
  71         strbuf_grow(sb, 0);
  72         res = sb->buf;
  73         if (sz)
  74                 *sz = sb->len;
  75         strbuf_init(sb, 0);
  76         return res;
  77 }
  78
  79 void strbuf_attach(struct strbuf *sb, void *buf, size_t len, size_t alloc)
  80 {
  81         strbuf_release(sb);
  82         sb->buf   = buf;
  83         sb->len   = len;
  84         sb->alloc = alloc;
  85         strbuf_grow(sb, 0);
  86         sb->buf[sb->len] = '\0';
  87 }
  88
  89 void strbuf_grow(struct strbuf *sb, size_t extra)
  90 {
  91         int new_buf = !sb->alloc;
  92         if (unsigned_add_overflows(extra, 1) ||
  93             unsigned_add_overflows(sb->len, extra + 1))
  94                 die("you want to use way too much memory");
  95         if (new_buf)
  96                 sb->buf = NULL;
  97         ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);
  98         if (new_buf)
  99                 sb->buf[0] = '\0';
 100 }
 101
 102 void strbuf_trim(struct strbuf *sb)
 103 {
 104         strbuf_rtrim(sb);
 105         strbuf_ltrim(sb);
 106 }
 107 void strbuf_rtrim(struct strbuf *sb)
 108 {
 109         while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
 110                 sb->len--;
 111         sb->buf[sb->len] = '\0';
 112 }
 113
 114 void strbuf_ltrim(struct strbuf *sb)
 115 {
 116         char *b = sb->buf;
 117         while (sb->len > 0 && isspace(*b)) {
 118                 b++;
 119                 sb->len--;
 120         }
 121         memmove(sb->buf, b, sb->len);
 122         sb->buf[sb->len] = '\0';
 123 }
 124
 125 int strbuf_reencode(struct strbuf *sb, const char *from, const char *to)
 126 {
 127         char *out;
 128         int len;
 129
 130         if (same_encoding(from, to))
 131                 return 0;
 132
 133         out = reencode_string_len(sb->buf, sb->len, to, from, &len);
 134         if (!out)
 135                 return -1;
 136
 137         strbuf_attach(sb, out, len, len);
 138         return 0;
 139 }
 140
 141 void strbuf_tolower(struct strbuf *sb)
 142 {
 143         char *p = sb->buf, *end = sb->buf + sb->len;
 144         for (; p < end; p++)
 145                 *p = tolower(*p);
 146 }
 147
 148 struct strbuf **strbuf_split_buf(const char *str, size_t slen,
 149                                  int terminator, int max)
 150 {
 151         struct strbuf **ret = NULL;
 152         size_t nr = 0, alloc = 0;
 153         struct strbuf *t;
 154
 155         while (slen) {
 156                 int len = slen;
 157                 if (max <= 0 || nr + 1 < max) {
 158                         const char *end = memchr(str, terminator, slen);
 159                         if (end)
 160                                 len = end - str + 1;
 161                 }
 162                 t = xmalloc(sizeof(struct strbuf));
 163                 strbuf_init(t, len);
 164                 strbuf_add(t, str, len);
 165                 ALLOC_GROW(ret, nr + 2, alloc);
 166                 ret[nr++] = t;
 167                 str += len;
 168                 slen -= len;
 169         }
 170         ALLOC_GROW(ret, nr + 1, alloc); /* In case string was empty */
 171         ret[nr] = NULL;
 172         return ret;
 173 }
 174
 175 void strbuf_list_free(struct strbuf **sbs)
 176 {
 177         struct strbuf **s = sbs;
 178
 179         while (*s) {
 180                 strbuf_release(*s);
 181                 free(*s++);
 182         }
 183         free(sbs);
 184 }
 185
 186 int strbuf_cmp(const struct strbuf *a, const struct strbuf *b)
 187 {
 188         int len = a->len < b->len ? a->len: b->len;
 189         int cmp = memcmp(a->buf, b->buf, len);
 190         if (cmp)
 191                 return cmp;
 192         return a->len < b->len ? -1: a->len != b->len;
 193 }
 194
 195 void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
 196                                    const void *data, size_t dlen)
 197 {
 198         if (unsigned_add_overflows(pos, len))
 199                 die("you want to use way too much memory");
 200         if (pos > sb->len)
 201                 die("`pos' is too far after the end of the buffer");
 202         if (pos + len > sb->len)
 203                 die("`pos + len' is too far after the end of the buffer");
 204
 205         if (dlen >= len)
 206                 strbuf_grow(sb, dlen - len);
 207         memmove(sb->buf + pos + dlen,
 208                         sb->buf + pos + len,
 209                         sb->len - pos - len);
 210         memcpy(sb->buf + pos, data, dlen);
 211         strbuf_setlen(sb, sb->len + dlen - len);
 212 }
 213
 214 void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len)
 215 {
 216         strbuf_splice(sb, pos, 0, data, len);
 217 }
 218
 219 void strbuf_remove(struct strbuf *sb, size_t pos, size_t len)
 220 {
 221         strbuf_splice(sb, pos, len, "", 0);
 222 }
 223
 224 void strbuf_add(struct strbuf *sb, const void *data, size_t len)
 225 {
 226         strbuf_grow(sb, len);
 227         memcpy(sb->buf + sb->len, data, len);
 228         strbuf_setlen(sb, sb->len + len);
 229 }
 230
 231 void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2)
 232 {
 233         strbuf_grow(sb, sb2->len);
 234         memcpy(sb->buf + sb->len, sb2->buf, sb2->len);
 235         strbuf_setlen(sb, sb->len + sb2->len);
 236 }
 237
 238 void strbuf_addchars(struct strbuf *sb, int c, size_t n)
 239 {
 240         strbuf_grow(sb, n);
 241         memset(sb->buf + sb->len, c, n);
 242         strbuf_setlen(sb, sb->len + n);
 243 }
 244
 245 void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
 246 {
 247         va_list ap;
 248         va_start(ap, fmt);
 249         strbuf_vaddf(sb, fmt, ap);
 250         va_end(ap);
 251 }
 252
 253 static void add_lines(struct strbuf *out,
 254                         const char *prefix1,
 255                         const char *prefix2,
 256                         const char *buf, size_t size)
 257 {
 258         while (size) {
 259                 const char *prefix;
 260                 const char *next = memchr(buf, '\n', size);
 261                 next = next ? (next + 1) : (buf + size);
 262
 263                 prefix = ((prefix2 && (buf[0] == '\n' || buf[0] == '\t'))
 264                           ? prefix2 : prefix1);
 265                 strbuf_addstr(out, prefix);
 266                 strbuf_add(out, buf, next - buf);
 267                 size -= next - buf;
 268                 buf = next;
 269         }
 270         strbuf_complete_line(out);
 271 }
 272
 273 void strbuf_add_commented_lines(struct strbuf *out, const char *buf, size_t size)
 274 {
 275         static char prefix1[3];
 276         static char prefix2[2];
 277
 278         if (prefix1[0] != comment_line_char) {
 279                 xsnprintf(prefix1, sizeof(prefix1), "%c ", comment_line_char);
 280                 xsnprintf(prefix2, sizeof(prefix2), "%c", comment_line_char);
 281         }
 282         add_lines(out, prefix1, prefix2, buf, size);
 283 }
 284
 285 void strbuf_commented_addf(struct strbuf *sb, const char *fmt, ...)
 286 {
 287         va_list params;
 288         struct strbuf buf = STRBUF_INIT;
 289         int incomplete_line = sb->len && sb->buf[sb->len - 1] != '\n';
 290
 291         va_start(params, fmt);
 292         strbuf_vaddf(&buf, fmt, params);
 293         va_end(params);
 294
 295         strbuf_add_commented_lines(sb, buf.buf, buf.len);
 296         if (incomplete_line)
 297                 sb->buf[--sb->len] = '\0';
 298
 299         strbuf_release(&buf);
 300 }
 301
 302 void strbuf_vaddf(struct strbuf *sb, const char *fmt, va_list ap)
 303 {
 304         int len;
 305         va_list cp;
 306
 307         if (!strbuf_avail(sb))
 308                 strbuf_grow(sb, 64);
 309         va_copy(cp, ap);
 310         len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, cp);
 311         va_end(cp);
 312         if (len < 0)
 313                 die("BUG: your vsnprintf is broken (returned %d)", len);
 314         if (len > strbuf_avail(sb)) {
 315                 strbuf_grow(sb, len);
 316                 len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
 317                 if (len > strbuf_avail(sb))
 318                         die("BUG: your vsnprintf is broken (insatiable)");
 319         }
 320         strbuf_setlen(sb, sb->len + len);
 321 }
 322
 323 void strbuf_expand(struct strbuf *sb, const char *format, expand_fn_t fn,
 324                    void *context)
 325 {
 326         for (;;) {
 327                 const char *percent;
 328                 size_t consumed;
 329
 330                 percent = strchrnul(format, '%');
 331                 strbuf_add(sb, format, percent - format);
 332                 if (!*percent)
 333                         break;
 334                 format = percent + 1;
 335
 336                 if (*format == '%') {
 337                         strbuf_addch(sb, '%');
 338                         format++;
 339                         continue;
 340                 }
 341
 342                 consumed = fn(sb, format, context);
 343                 if (consumed)
 344                         format += consumed;
 345                 else
 346                         strbuf_addch(sb, '%');
 347         }
 348 }
 349
 350 size_t strbuf_expand_dict_cb(struct strbuf *sb, const char *placeholder,
 351                 void *context)
 352 {
 353         struct strbuf_expand_dict_entry *e = context;
 354         size_t len;
 355
 356         for (; e->placeholder && (len = strlen(e->placeholder)); e++) {
 357                 if (!strncmp(placeholder, e->placeholder, len)) {
 358                         if (e->value)
 359                                 strbuf_addstr(sb, e->value);
 360                         return len;
 361                 }
 362         }
 363         return 0;
 364 }
 365
 366 void strbuf_addbuf_percentquote(struct strbuf *dst, const struct strbuf *src)
 367 {
 368         int i, len = src->len;
 369
 370         for (i = 0; i < len; i++) {
 371                 if (src->buf[i] == '%')
 372                         strbuf_addch(dst, '%');
 373                 strbuf_addch(dst, src->buf[i]);
 374         }
 375 }
 376
 377 size_t strbuf_fread(struct strbuf *sb, size_t size, FILE *f)
 378 {
 379         size_t res;
 380         size_t oldalloc = sb->alloc;
 381
 382         strbuf_grow(sb, size);
 383         res = fread(sb->buf + sb->len, 1, size, f);
 384         if (res > 0)
 385                 strbuf_setlen(sb, sb->len + res);
 386         else if (oldalloc == 0)
 387                 strbuf_release(sb);
 388         return res;
 389 }
 390
 391 ssize_t strbuf_read(struct strbuf *sb, int fd, size_t hint)
 392 {
 393         size_t oldlen = sb->len;
 394         size_t oldalloc = sb->alloc;
 395
 396         strbuf_grow(sb, hint ? hint : 8192);
 397         for (;;) {
 398                 ssize_t want = sb->alloc - sb->len - 1;
 399                 ssize_t got = read_in_full(fd, sb->buf + sb->len, want);
 400
 401                 if (got < 0) {
 402                         if (oldalloc == 0)
 403                                 strbuf_release(sb);
 404                         else
 405                                 strbuf_setlen(sb, oldlen);
 406                         return -1;
 407                 }
 408                 sb->len += got;
 409                 if (got < want)
 410                         break;
 411                 strbuf_grow(sb, 8192);
 412         }
 413
 414         sb->buf[sb->len] = '\0';
 415         return sb->len - oldlen;
 416 }
 417
 418 ssize_t strbuf_read_once(struct strbuf *sb, int fd, size_t hint)
 419 {
 420         size_t oldalloc = sb->alloc;
 421         ssize_t cnt;
 422
 423         strbuf_grow(sb, hint ? hint : 8192);
 424         cnt = xread(fd, sb->buf + sb->len, sb->alloc - sb->len - 1);
 425         if (cnt > 0)
 426                 strbuf_setlen(sb, sb->len + cnt);
 427         else if (oldalloc == 0)
 428                 strbuf_release(sb);
 429         return cnt;
 430 }
 431
 432 ssize_t strbuf_write(struct strbuf *sb, FILE *f)
 433 {
 434         return sb->len ? fwrite(sb->buf, 1, sb->len, f) : 0;
 435 }
 436
 437
 438 #define STRBUF_MAXLINK (2*PATH_MAX)
 439
 440 int strbuf_readlink(struct strbuf *sb, const char *path, size_t hint)
 441 {
 442         size_t oldalloc = sb->alloc;
 443
 444         if (hint < 32)
 445                 hint = 32;
 446
 447         while (hint < STRBUF_MAXLINK) {
 448                 int len;
 449
 450                 strbuf_grow(sb, hint);
 451                 len = readlink(path, sb->buf, hint);
 452                 if (len < 0) {
 453                         if (errno != ERANGE)
 454                                 break;
 455                 } else if (len < hint) {
 456                         strbuf_setlen(sb, len);
 457                         return 0;
 458                 }
 459
 460                 /* .. the buffer was too small - try again */
 461                 hint *= 2;
 462         }
 463         if (oldalloc == 0)
 464                 strbuf_release(sb);
 465         return -1;
 466 }
 467
 468 int strbuf_getcwd(struct strbuf *sb)
 469 {
 470         size_t oldalloc = sb->alloc;
 471         size_t guessed_len = 128;
 472
 473         for (;; guessed_len *= 2) {
 474                 strbuf_grow(sb, guessed_len);
 475                 if (getcwd(sb->buf, sb->alloc)) {
 476                         strbuf_setlen(sb, strlen(sb->buf));
 477                         return 0;
 478                 }
 479
 480                 /*
 481                  * If getcwd(3) is implemented as a syscall that falls
 482                  * back to a regular lookup using readdir(3) etc. then
 483                  * we may be able to avoid EACCES by providing enough
 484                  * space to the syscall as it's not necessarily bound
 485                  * to the same restrictions as the fallback.
 486                  */
 487                 if (errno == EACCES && guessed_len < PATH_MAX)
 488                         continue;
 489
 490                 if (errno != ERANGE)
 491                         break;
 492         }
 493         if (oldalloc == 0)
 494                 strbuf_release(sb);
 495         else
 496                 strbuf_reset(sb);
 497         return -1;
 498 }
 499
 500 #ifdef HAVE_GETDELIM
 501 int strbuf_getwholeline(struct strbuf *sb, FILE *fp, int term)
 502 {
 503         ssize_t r;
 504
 505         if (feof(fp))
 506                 return EOF;
 507
 508         strbuf_reset(sb);
 509
 510         /* Translate slopbuf to NULL, as we cannot call realloc on it */
 511         if (!sb->alloc)
 512                 sb->buf = NULL;
 513         errno = 0;
 514         r = getdelim(&sb->buf, &sb->alloc, term, fp);
 515
 516         if (r > 0) {
 517                 sb->len = r;
 518                 return 0;
 519         }
 520         assert(r == -1);
 521
 522         /*
 523          * Normally we would have called xrealloc, which will try to free
 524          * memory and recover. But we have no way to tell getdelim() to do so.
 525          * Worse, we cannot try to recover ENOMEM ourselves, because we have
 526          * no idea how many bytes were read by getdelim.
 527          *
 528          * Dying here is reasonable. It mirrors what xrealloc would do on
 529          * catastrophic memory failure. We skip the opportunity to free pack
 530          * memory and retry, but that's unlikely to help for a malloc small
 531          * enough to hold a single line of input, anyway.
 532          */
 533         if (errno == ENOMEM)
 534                 die("Out of memory, getdelim failed");
 535
 536         /*
 537          * Restore strbuf invariants; if getdelim left us with a NULL pointer,
 538          * we can just re-init, but otherwise we should make sure that our
 539          * length is empty, and that the result is NUL-terminated.
 540          */
 541         if (!sb->buf)
 542                 strbuf_init(sb, 0);
 543         else
 544                 strbuf_reset(sb);
 545         return EOF;
 546 }
 547 #else
 548 int strbuf_getwholeline(struct strbuf *sb, FILE *fp, int term)
 549 {
 550         int ch;
 551
 552         if (feof(fp))
 553                 return EOF;
 554
 555         strbuf_reset(sb);
 556         flockfile(fp);
 557         while ((ch = getc_unlocked(fp)) != EOF) {
 558                 if (!strbuf_avail(sb))
 559                         strbuf_grow(sb, 1);
 560                 sb->buf[sb->len++] = ch;
 561                 if (ch == term)
 562                         break;
 563         }
 564         funlockfile(fp);
 565         if (ch == EOF && sb->len == 0)
 566                 return EOF;
 567
 568         sb->buf[sb->len] = '\0';
 569         return 0;
 570 }
 571 #endif
 572
 573 static int strbuf_getdelim(struct strbuf *sb, FILE *fp, int term)
 574 {
 575         if (strbuf_getwholeline(sb, fp, term))
 576                 return EOF;
 577         if (sb->buf[sb->len - 1] == term)
 578                 strbuf_setlen(sb, sb->len - 1);
 579         return 0;
 580 }
 581
 582 int strbuf_getline(struct strbuf *sb, FILE *fp)
 583 {
 584         if (strbuf_getwholeline(sb, fp, '\n'))
 585                 return EOF;
 586         if (sb->buf[sb->len - 1] == '\n') {
 587                 strbuf_setlen(sb, sb->len - 1);
 588                 if (sb->len && sb->buf[sb->len - 1] == '\r')
 589                         strbuf_setlen(sb, sb->len - 1);
 590         }
 591         return 0;
 592 }
 593
 594 int strbuf_getline_lf(struct strbuf *sb, FILE *fp)
 595 {
 596         return strbuf_getdelim(sb, fp, '\n');
 597 }
 598
 599 int strbuf_getline_nul(struct strbuf *sb, FILE *fp)
 600 {
 601         return strbuf_getdelim(sb, fp, '\0');
 602 }
 603
 604 int strbuf_getwholeline_fd(struct strbuf *sb, int fd, int term)
 605 {
 606         strbuf_reset(sb);
 607
 608         while (1) {
 609                 char ch;
 610                 ssize_t len = xread(fd, &ch, 1);
 611                 if (len <= 0)
 612                         return EOF;
 613                 strbuf_addch(sb, ch);
 614                 if (ch == term)
 615                         break;
 616         }
 617         return 0;
 618 }
 619
 620 ssize_t strbuf_read_file(struct strbuf *sb, const char *path, size_t hint)
 621 {
 622         int fd;
 623         ssize_t len;
 624
 625         fd = open(path, O_RDONLY);
 626         if (fd < 0)
 627                 return -1;
 628         len = strbuf_read(sb, fd, hint);
 629         close(fd);
 630         if (len < 0)
 631                 return -1;
 632
 633         return len;
 634 }
 635
 636 void strbuf_add_lines(struct strbuf *out, const char *prefix,
 637                       const char *buf, size_t size)
 638 {
 639         add_lines(out, prefix, NULL, buf, size);
 640 }
 641
 642 void strbuf_addstr_xml_quoted(struct strbuf *buf, const char *s)
 643 {
 644         while (*s) {
 645                 size_t len = strcspn(s, "\"<>&");
 646                 strbuf_add(buf, s, len);
 647                 s += len;
 648                 switch (*s) {
 649                 case '"':
 650                         strbuf_addstr(buf, "&quot;");
 651                         break;
 652                 case '<':
 653                         strbuf_addstr(buf, "&lt;");
 654                         break;
 655                 case '>':
 656                         strbuf_addstr(buf, "&gt;");
 657                         break;
 658                 case '&':
 659                         strbuf_addstr(buf, "&amp;");
 660                         break;
 661                 case 0:
 662                         return;
 663                 }
 664                 s++;
 665         }
 666 }
 667
 668 static int is_rfc3986_reserved(char ch)
 669 {
 670         switch (ch) {
 671                 case '!': case '*': case '\'': case '(': case ')': case ';':
 672                 case ':': case '@': case '&': case '=': case '+': case '$':
 673                 case ',': case '/': case '?': case '#': case '[': case ']':
 674                         return 1;
 675         }
 676         return 0;
 677 }
 678
 679 static int is_rfc3986_unreserved(char ch)
 680 {
 681         return isalnum(ch) ||
 682                 ch == '-' || ch == '_' || ch == '.' || ch == '~';
 683 }
 684
 685 static void strbuf_add_urlencode(struct strbuf *sb, const char *s, size_t len,
 686                                  int reserved)
 687 {
 688         strbuf_grow(sb, len);
 689         while (len--) {
 690                 char ch = *s++;
 691                 if (is_rfc3986_unreserved(ch) ||
 692                     (!reserved && is_rfc3986_reserved(ch)))
 693                         strbuf_addch(sb, ch);
 694                 else
 695                         strbuf_addf(sb, "%%%02x", ch);
 696         }
 697 }
 698
 699 void strbuf_addstr_urlencode(struct strbuf *sb, const char *s,
 700                              int reserved)
 701 {
 702         strbuf_add_urlencode(sb, s, strlen(s), reserved);
 703 }
 704
 705 void strbuf_humanise_bytes(struct strbuf *buf, off_t bytes)
 706 {
 707         if (bytes > 1 << 30) {
 708                 strbuf_addf(buf, "%u.%2.2u GiB",
 709                             (int)(bytes >> 30),
 710                             (int)(bytes & ((1 << 30) - 1)) / 10737419);
 711         } else if (bytes > 1 << 20) {
 712                 int x = bytes + 5243;  /* for rounding */
 713                 strbuf_addf(buf, "%u.%2.2u MiB",
 714                             x >> 20, ((x & ((1 << 20) - 1)) * 100) >> 20);
 715         } else if (bytes > 1 << 10) {
 716                 int x = bytes + 5;  /* for rounding */
 717                 strbuf_addf(buf, "%u.%2.2u KiB",
 718                             x >> 10, ((x & ((1 << 10) - 1)) * 100) >> 10);
 719         } else {
 720                 strbuf_addf(buf, "%u bytes", (int)bytes);
 721         }
 722 }
 723
 724 void strbuf_add_absolute_path(struct strbuf *sb, const char *path)
 725 {
 726         if (!*path)
 727                 die("The empty string is not a valid path");
 728         if (!is_absolute_path(path)) {
 729                 struct stat cwd_stat, pwd_stat;
 730                 size_t orig_len = sb->len;
 731                 char *cwd = xgetcwd();
 732                 char *pwd = getenv("PWD");
 733                 if (pwd && strcmp(pwd, cwd) &&
 734                     !stat(cwd, &cwd_stat) &&
 735                     (cwd_stat.st_dev || cwd_stat.st_ino) &&
 736                     !stat(pwd, &pwd_stat) &&
 737                     pwd_stat.st_dev == cwd_stat.st_dev &&
 738                     pwd_stat.st_ino == cwd_stat.st_ino)
 739                         strbuf_addstr(sb, pwd);
 740                 else
 741                         strbuf_addstr(sb, cwd);
 742                 if (sb->len > orig_len && !is_dir_sep(sb->buf[sb->len - 1]))
 743                         strbuf_addch(sb, '/');
 744                 free(cwd);
 745         }
 746         strbuf_addstr(sb, path);
 747 }
 748
 749 void strbuf_add_real_path(struct strbuf *sb, const char *path)
 750 {
 751         if (sb->len) {
 752                 struct strbuf resolved = STRBUF_INIT;
 753                 strbuf_realpath(&resolved, path, 1);
 754                 strbuf_addbuf(sb, &resolved);
 755                 strbuf_release(&resolved);
 756         } else
 757                 strbuf_realpath(sb, path, 1);
 758 }
 759
 760 int printf_ln(const char *fmt, ...)
 761 {
 762         int ret;
 763         va_list ap;
 764         va_start(ap, fmt);
 765         ret = vprintf(fmt, ap);
 766         va_end(ap);
 767         if (ret < 0 || putchar('\n') == EOF)
 768                 return -1;
 769         return ret + 1;
 770 }
 771
 772 int fprintf_ln(FILE *fp, const char *fmt, ...)
 773 {
 774         int ret;
 775         va_list ap;
 776         va_start(ap, fmt);
 777         ret = vfprintf(fp, fmt, ap);
 778         va_end(ap);
 779         if (ret < 0 || putc('\n', fp) == EOF)
 780                 return -1;
 781         return ret + 1;
 782 }
 783
 784 char *xstrdup_tolower(const char *string)
 785 {
 786         char *result;
 787         size_t len, i;
 788
 789         len = strlen(string);
 790         result = xmallocz(len);
 791         for (i = 0; i < len; i++)
 792                 result[i] = tolower(string[i]);
 793         return result;
 794 }
 795
 796 char *xstrdup_toupper(const char *string)
 797 {
 798         char *result;
 799         size_t len, i;
 800
 801         len = strlen(string);
 802         result = xmallocz(len);
 803         for (i = 0; i < len; i++)
 804                 result[i] = toupper(string[i]);
 805         return result;
 806 }
 807
 808 char *xstrvfmt(const char *fmt, va_list ap)
 809 {
 810         struct strbuf buf = STRBUF_INIT;
 811         strbuf_vaddf(&buf, fmt, ap);
 812         return strbuf_detach(&buf, NULL);
 813 }
 814
 815 char *xstrfmt(const char *fmt, ...)
 816 {
 817         va_list ap;
 818         char *ret;
 819
 820         va_start(ap, fmt);
 821         ret = xstrvfmt(fmt, ap);
 822         va_end(ap);
 823
 824         return ret;
 825 }
 826
 827 void strbuf_addftime(struct strbuf *sb, const char *fmt, const struct tm *tm,
 828                      int tz_offset, int suppress_tz_name)
 829 {
 830         struct strbuf munged_fmt = STRBUF_INIT;
 831         size_t hint = 128;
 832         size_t len;
 833
 834         if (!*fmt)
 835                 return;
 836
 837         /*
 838          * There is no portable way to pass timezone information to
 839          * strftime, so we handle %z and %Z here.
 840          */
 841         for (;;) {
 842                 const char *percent = strchrnul(fmt, '%');
 843                 strbuf_add(&munged_fmt, fmt, percent - fmt);
 844                 if (!*percent)
 845                         break;
 846                 fmt = percent + 1;
 847                 switch (*fmt) {
 848                 case '%':
 849                         strbuf_addstr(&munged_fmt, "%%");
 850                         fmt++;
 851                         break;
 852                 case 'z':
 853                         strbuf_addf(&munged_fmt, "%+05d", tz_offset);
 854                         fmt++;
 855                         break;
 856                 case 'Z':
 857                         if (suppress_tz_name) {
 858                                 fmt++;
 859                                 break;
 860                         }
 861                         /* FALLTHROUGH */
 862                 default:
 863                         strbuf_addch(&munged_fmt, '%');
 864                 }
 865         }
 866         fmt = munged_fmt.buf;
 867
 868         strbuf_grow(sb, hint);
 869         len = strftime(sb->buf + sb->len, sb->alloc - sb->len, fmt, tm);
 870
 871         if (!len) {
 872                 /*
 873                  * strftime reports "0" if it could not fit the result in the buffer.
 874                  * Unfortunately, it also reports "0" if the requested time string
 875                  * takes 0 bytes. So our strategy is to munge the format so that the
 876                  * output contains at least one character, and then drop the extra
 877                  * character before returning.
 878                  */
 879                 strbuf_addch(&munged_fmt, ' ');
 880                 while (!len) {
 881                         hint *= 2;
 882                         strbuf_grow(sb, hint);
 883                         len = strftime(sb->buf + sb->len, sb->alloc - sb->len,
 884                                        munged_fmt.buf, tm);
 885                 }
 886                 len--; /* drop munged space */
 887         }
 888         strbuf_release(&munged_fmt);
 889         strbuf_setlen(sb, sb->len + len);
 890 }
 891
 892 void strbuf_add_unique_abbrev(struct strbuf *sb, const unsigned char *sha1,
 893                               int abbrev_len)
 894 {
 895         int r;
 896         strbuf_grow(sb, GIT_SHA1_HEXSZ + 1);
 897         r = find_unique_abbrev_r(sb->buf + sb->len, sha1, abbrev_len);
 898         strbuf_setlen(sb, sb->len + r);
 899 }
 900
 901 /*
 902  * Returns the length of a line, without trailing spaces.
 903  *
 904  * If the line ends with newline, it will be removed too.
 905  */
 906 static size_t cleanup(char *line, size_t len)
 907 {
 908         while (len) {
 909                 unsigned char c = line[len - 1];
 910                 if (!isspace(c))
 911                         break;
 912                 len--;
 913         }
 914
 915         return len;
 916 }
 917
 918 /*
 919  * Remove empty lines from the beginning and end
 920  * and also trailing spaces from every line.
 921  *
 922  * Turn multiple consecutive empty lines between paragraphs
 923  * into just one empty line.
 924  *
 925  * If the input has only empty lines and spaces,
 926  * no output will be produced.
 927  *
 928  * If last line does not have a newline at the end, one is added.
 929  *
 930  * Enable skip_comments to skip every line starting with comment
 931  * character.
 932  */
 933 void strbuf_stripspace(struct strbuf *sb, int skip_comments)
 934 {
 935         int empties = 0;
 936         size_t i, j, len, newlen;
 937         char *eol;
 938
 939         /* We may have to add a newline. */
 940         strbuf_grow(sb, 1);
 941
 942         for (i = j = 0; i < sb->len; i += len, j += newlen) {
 943                 eol = memchr(sb->buf + i, '\n', sb->len - i);
 944                 len = eol ? eol - (sb->buf + i) + 1 : sb->len - i;
 945
 946                 if (skip_comments && len && sb->buf[i] == comment_line_char) {
 947                         newlen = 0;
 948                         continue;
 949                 }
 950                 newlen = cleanup(sb->buf + i, len);
 951
 952                 /* Not just an empty line? */
 953                 if (newlen) {
 954                         if (empties > 0 && j > 0)
 955                                 sb->buf[j++] = '\n';
 956                         empties = 0;
 957                         memmove(sb->buf + j, sb->buf + i, newlen);
 958                         sb->buf[newlen + j++] = '\n';
 959                 } else {
 960                         empties++;
 961                 }
 962         }
 963
 964         strbuf_setlen(sb, j);
 965 }
 966
 967 int strbuf_normalize_path(struct strbuf *src)
 968 {
 969         struct strbuf dst = STRBUF_INIT;
 970
 971         strbuf_grow(&dst, src->len);
 972         if (normalize_path_copy(dst.buf, src->buf) < 0) {
 973                 strbuf_release(&dst);
 974                 return -1;
 975         }
 976
 977         /*
 978          * normalize_path does not tell us the new length, so we have to
 979          * compute it by looking for the new NUL it placed
 980          */
 981         strbuf_setlen(&dst, strlen(dst.buf));
 982         strbuf_swap(src, &dst);
 983         strbuf_release(&dst);
 984         return 0;
 985 }