Andrew's git / gitweb.git / strbuf.c
?
strbuf.con commit convert: add round trip check based on 'core.checkRoundtripEncoding' (e92d622)
   1#include "cache.h"
   2#include "refs.h"
   3#include "utf8.h"
   4
   5int 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
  14int 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
  23int 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 */
  50char strbuf_slopbuf[1];
  51
  52void 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
  60void strbuf_release(struct strbuf *sb)
  61{
  62        if (sb->alloc) {
  63                free(sb->buf);
  64                strbuf_init(sb, 0);
  65        }
  66}
  67
  68char *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
  79void 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
  89void 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
 102void strbuf_trim(struct strbuf *sb)
 103{
 104        strbuf_rtrim(sb);
 105        strbuf_ltrim(sb);
 106}
 107void 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
 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_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
 186int 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
 195void 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
 214void 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
 219void strbuf_remove(struct strbuf *sb, size_t pos, size_t len)
 220{
 221        strbuf_splice(sb, pos, len, "", 0);
 222}
 223
 224void 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
 231void 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
 238void 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
 245void 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
 253static 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
 273void 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
 285void 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
 302void 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
 323void 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
 350size_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
 366void 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
 377size_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
 391ssize_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
 418ssize_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
 432ssize_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
 440int 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
 468int 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
 501int 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
 548int 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
 573static 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
 582int 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
 594int strbuf_getline_lf(struct strbuf *sb, FILE *fp)
 595{
 596        return strbuf_getdelim(sb, fp, '\n');
 597}
 598
 599int strbuf_getline_nul(struct strbuf *sb, FILE *fp)
 600{
 601        return strbuf_getdelim(sb, fp, '\0');
 602}
 603
 604int 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
 620ssize_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
 636void 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
 642void 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
 668static 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
 679static int is_rfc3986_unreserved(char ch)
 680{
 681        return isalnum(ch) ||
 682                ch == '-' || ch == '_' || ch == '.' || ch == '~';
 683}
 684
 685static 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
 699void strbuf_addstr_urlencode(struct strbuf *sb, const char *s,
 700                             int reserved)
 701{
 702        strbuf_add_urlencode(sb, s, strlen(s), reserved);
 703}
 704
 705void 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
 724void 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
 749void 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
 760int 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
 772int 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
 784char *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
 796char *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
 808char *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
 815char *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
 827void 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
 892void 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 */
 906static 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 */
 933void 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
 967int 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}