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