Merge branch 'ew/svn-crlf'
[git/git.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", 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 }