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