5 int starts_with(const char *str
, const char *prefix
)
7 for (; ; str
++, prefix
++)
10 else if (*str
!= *prefix
)
14 int istarts_with(const char *str
, const char *prefix
)
16 for (; ; str
++, prefix
++)
19 else if (tolower(*str
) != tolower(*prefix
))
23 int skip_to_optional_arg_default(const char *str
, const char *prefix
,
24 const char **arg
, const char *def
)
28 if (!skip_prefix(str
, prefix
, &p
))
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
50 char strbuf_slopbuf
[1];
52 void strbuf_init(struct strbuf
*sb
, size_t hint
)
54 sb
->alloc
= sb
->len
= 0;
55 sb
->buf
= strbuf_slopbuf
;
57 strbuf_grow(sb
, hint
);
60 void strbuf_release(struct strbuf
*sb
)
68 char *strbuf_detach(struct strbuf
*sb
, size_t *sz
)
79 void strbuf_attach(struct strbuf
*sb
, void *buf
, size_t len
, size_t alloc
)
86 sb
->buf
[sb
->len
] = '\0';
89 void strbuf_grow(struct strbuf
*sb
, size_t extra
)
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");
97 ALLOC_GROW(sb
->buf
, sb
->len
+ extra
+ 1, sb
->alloc
);
102 void strbuf_trim(struct strbuf
*sb
)
107 void strbuf_rtrim(struct strbuf
*sb
)
109 while (sb
->len
> 0 && isspace((unsigned char)sb
->buf
[sb
->len
- 1]))
111 sb
->buf
[sb
->len
] = '\0';
114 void strbuf_ltrim(struct strbuf
*sb
)
117 while (sb
->len
> 0 && isspace(*b
)) {
121 memmove(sb
->buf
, b
, sb
->len
);
122 sb
->buf
[sb
->len
] = '\0';
125 int strbuf_reencode(struct strbuf
*sb
, const char *from
, const char *to
)
130 if (same_encoding(from
, to
))
133 out
= reencode_string_len(sb
->buf
, sb
->len
, to
, from
, &len
);
137 strbuf_attach(sb
, out
, len
, len
);
141 void strbuf_tolower(struct strbuf
*sb
)
143 char *p
= sb
->buf
, *end
= sb
->buf
+ sb
->len
;
148 struct strbuf
**strbuf_split_buf(const char *str
, size_t slen
,
149 int terminator
, int max
)
151 struct strbuf
**ret
= NULL
;
152 size_t nr
= 0, alloc
= 0;
157 if (max
<= 0 || nr
+ 1 < max
) {
158 const char *end
= memchr(str
, terminator
, slen
);
162 t
= xmalloc(sizeof(struct strbuf
));
164 strbuf_add(t
, str
, len
);
165 ALLOC_GROW(ret
, nr
+ 2, alloc
);
170 ALLOC_GROW(ret
, nr
+ 1, alloc
); /* In case string was empty */
175 void strbuf_list_free(struct strbuf
**sbs
)
177 struct strbuf
**s
= sbs
;
186 int strbuf_cmp(const struct strbuf
*a
, const struct strbuf
*b
)
188 int len
= a
->len
< b
->len
? a
->len
: b
->len
;
189 int cmp
= memcmp(a
->buf
, b
->buf
, len
);
192 return a
->len
< b
->len
? -1: a
->len
!= b
->len
;
195 void strbuf_splice(struct strbuf
*sb
, size_t pos
, size_t len
,
196 const void *data
, size_t dlen
)
198 if (unsigned_add_overflows(pos
, len
))
199 die("you want to use way too much memory");
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");
206 strbuf_grow(sb
, dlen
- len
);
207 memmove(sb
->buf
+ pos
+ dlen
,
209 sb
->len
- pos
- len
);
210 memcpy(sb
->buf
+ pos
, data
, dlen
);
211 strbuf_setlen(sb
, sb
->len
+ dlen
- len
);
214 void strbuf_insert(struct strbuf
*sb
, size_t pos
, const void *data
, size_t len
)
216 strbuf_splice(sb
, pos
, 0, data
, len
);
219 void strbuf_remove(struct strbuf
*sb
, size_t pos
, size_t len
)
221 strbuf_splice(sb
, pos
, len
, "", 0);
224 void strbuf_add(struct strbuf
*sb
, const void *data
, size_t len
)
226 strbuf_grow(sb
, len
);
227 memcpy(sb
->buf
+ sb
->len
, data
, len
);
228 strbuf_setlen(sb
, sb
->len
+ len
);
231 void strbuf_addbuf(struct strbuf
*sb
, const struct strbuf
*sb2
)
233 strbuf_grow(sb
, sb2
->len
);
234 memcpy(sb
->buf
+ sb
->len
, sb2
->buf
, sb2
->len
);
235 strbuf_setlen(sb
, sb
->len
+ sb2
->len
);
238 void strbuf_addchars(struct strbuf
*sb
, int c
, size_t n
)
241 memset(sb
->buf
+ sb
->len
, c
, n
);
242 strbuf_setlen(sb
, sb
->len
+ n
);
245 void strbuf_addf(struct strbuf
*sb
, const char *fmt
, ...)
249 strbuf_vaddf(sb
, fmt
, ap
);
253 static void add_lines(struct strbuf
*out
,
256 const char *buf
, size_t size
)
260 const char *next
= memchr(buf
, '\n', size
);
261 next
= next
? (next
+ 1) : (buf
+ size
);
263 prefix
= ((prefix2
&& (buf
[0] == '\n' || buf
[0] == '\t'))
264 ? prefix2
: prefix1
);
265 strbuf_addstr(out
, prefix
);
266 strbuf_add(out
, buf
, next
- buf
);
270 strbuf_complete_line(out
);
273 void strbuf_add_commented_lines(struct strbuf
*out
, const char *buf
, size_t size
)
275 static char prefix1
[3];
276 static char prefix2
[2];
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
);
282 add_lines(out
, prefix1
, prefix2
, buf
, size
);
285 void strbuf_commented_addf(struct strbuf
*sb
, const char *fmt
, ...)
288 struct strbuf buf
= STRBUF_INIT
;
289 int incomplete_line
= sb
->len
&& sb
->buf
[sb
->len
- 1] != '\n';
291 va_start(params
, fmt
);
292 strbuf_vaddf(&buf
, fmt
, params
);
295 strbuf_add_commented_lines(sb
, buf
.buf
, buf
.len
);
297 sb
->buf
[--sb
->len
] = '\0';
299 strbuf_release(&buf
);
302 void strbuf_vaddf(struct strbuf
*sb
, const char *fmt
, va_list ap
)
307 if (!strbuf_avail(sb
))
310 len
= vsnprintf(sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
, fmt
, cp
);
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)");
320 strbuf_setlen(sb
, sb
->len
+ len
);
323 void strbuf_expand(struct strbuf
*sb
, const char *format
, expand_fn_t fn
,
330 percent
= strchrnul(format
, '%');
331 strbuf_add(sb
, format
, percent
- format
);
334 format
= percent
+ 1;
336 if (*format
== '%') {
337 strbuf_addch(sb
, '%');
342 consumed
= fn(sb
, format
, context
);
346 strbuf_addch(sb
, '%');
350 size_t strbuf_expand_dict_cb(struct strbuf
*sb
, const char *placeholder
,
353 struct strbuf_expand_dict_entry
*e
= context
;
356 for (; e
->placeholder
&& (len
= strlen(e
->placeholder
)); e
++) {
357 if (!strncmp(placeholder
, e
->placeholder
, len
)) {
359 strbuf_addstr(sb
, e
->value
);
366 void strbuf_addbuf_percentquote(struct strbuf
*dst
, const struct strbuf
*src
)
368 int i
, len
= src
->len
;
370 for (i
= 0; i
< len
; i
++) {
371 if (src
->buf
[i
] == '%')
372 strbuf_addch(dst
, '%');
373 strbuf_addch(dst
, src
->buf
[i
]);
377 size_t strbuf_fread(struct strbuf
*sb
, size_t size
, FILE *f
)
380 size_t oldalloc
= sb
->alloc
;
382 strbuf_grow(sb
, size
);
383 res
= fread(sb
->buf
+ sb
->len
, 1, size
, f
);
385 strbuf_setlen(sb
, sb
->len
+ res
);
386 else if (oldalloc
== 0)
391 ssize_t
strbuf_read(struct strbuf
*sb
, int fd
, size_t hint
)
393 size_t oldlen
= sb
->len
;
394 size_t oldalloc
= sb
->alloc
;
396 strbuf_grow(sb
, hint
? hint
: 8192);
398 ssize_t want
= sb
->alloc
- sb
->len
- 1;
399 ssize_t got
= read_in_full(fd
, sb
->buf
+ sb
->len
, want
);
405 strbuf_setlen(sb
, oldlen
);
411 strbuf_grow(sb
, 8192);
414 sb
->buf
[sb
->len
] = '\0';
415 return sb
->len
- oldlen
;
418 ssize_t
strbuf_read_once(struct strbuf
*sb
, int fd
, size_t hint
)
420 size_t oldalloc
= sb
->alloc
;
423 strbuf_grow(sb
, hint
? hint
: 8192);
424 cnt
= xread(fd
, sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
- 1);
426 strbuf_setlen(sb
, sb
->len
+ cnt
);
427 else if (oldalloc
== 0)
432 ssize_t
strbuf_write(struct strbuf
*sb
, FILE *f
)
434 return sb
->len
? fwrite(sb
->buf
, 1, sb
->len
, f
) : 0;
438 #define STRBUF_MAXLINK (2*PATH_MAX)
440 int strbuf_readlink(struct strbuf
*sb
, const char *path
, size_t hint
)
442 size_t oldalloc
= sb
->alloc
;
447 while (hint
< STRBUF_MAXLINK
) {
450 strbuf_grow(sb
, hint
);
451 len
= readlink(path
, sb
->buf
, hint
);
455 } else if (len
< hint
) {
456 strbuf_setlen(sb
, len
);
460 /* .. the buffer was too small - try again */
468 int strbuf_getcwd(struct strbuf
*sb
)
470 size_t oldalloc
= sb
->alloc
;
471 size_t guessed_len
= 128;
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
));
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.
487 if (errno
== EACCES
&& guessed_len
< PATH_MAX
)
501 int strbuf_getwholeline(struct strbuf
*sb
, FILE *fp
, int term
)
510 /* Translate slopbuf to NULL, as we cannot call realloc on it */
514 r
= getdelim(&sb
->buf
, &sb
->alloc
, term
, fp
);
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.
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.
534 die("Out of memory, getdelim failed");
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.
548 int strbuf_getwholeline(struct strbuf
*sb
, FILE *fp
, int term
)
557 while ((ch
= getc_unlocked(fp
)) != EOF
) {
558 if (!strbuf_avail(sb
))
560 sb
->buf
[sb
->len
++] = ch
;
565 if (ch
== EOF
&& sb
->len
== 0)
568 sb
->buf
[sb
->len
] = '\0';
573 static int strbuf_getdelim(struct strbuf
*sb
, FILE *fp
, int term
)
575 if (strbuf_getwholeline(sb
, fp
, term
))
577 if (sb
->buf
[sb
->len
- 1] == term
)
578 strbuf_setlen(sb
, sb
->len
- 1);
582 int strbuf_getline(struct strbuf
*sb
, FILE *fp
)
584 if (strbuf_getwholeline(sb
, fp
, '\n'))
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);
594 int strbuf_getline_lf(struct strbuf
*sb
, FILE *fp
)
596 return strbuf_getdelim(sb
, fp
, '\n');
599 int strbuf_getline_nul(struct strbuf
*sb
, FILE *fp
)
601 return strbuf_getdelim(sb
, fp
, '\0');
604 int strbuf_getwholeline_fd(struct strbuf
*sb
, int fd
, int term
)
610 ssize_t len
= xread(fd
, &ch
, 1);
613 strbuf_addch(sb
, ch
);
620 ssize_t
strbuf_read_file(struct strbuf
*sb
, const char *path
, size_t hint
)
625 fd
= open(path
, O_RDONLY
);
628 len
= strbuf_read(sb
, fd
, hint
);
636 void strbuf_add_lines(struct strbuf
*out
, const char *prefix
,
637 const char *buf
, size_t size
)
639 add_lines(out
, prefix
, NULL
, buf
, size
);
642 void strbuf_addstr_xml_quoted(struct strbuf
*buf
, const char *s
)
645 size_t len
= strcspn(s
, "\"<>&");
646 strbuf_add(buf
, s
, len
);
650 strbuf_addstr(buf
, """);
653 strbuf_addstr(buf
, "<");
656 strbuf_addstr(buf
, ">");
659 strbuf_addstr(buf
, "&");
668 static int is_rfc3986_reserved(char ch
)
671 case '!': case '*': case '\'': case '(': case ')': case ';':
672 case ':': case '@': case '&': case '=': case '+': case '$':
673 case ',': case '/': case '?': case '#': case '[': case ']':
679 static int is_rfc3986_unreserved(char ch
)
681 return isalnum(ch
) ||
682 ch
== '-' || ch
== '_' || ch
== '.' || ch
== '~';
685 static void strbuf_add_urlencode(struct strbuf
*sb
, const char *s
, size_t len
,
688 strbuf_grow(sb
, len
);
691 if (is_rfc3986_unreserved(ch
) ||
692 (!reserved
&& is_rfc3986_reserved(ch
)))
693 strbuf_addch(sb
, ch
);
695 strbuf_addf(sb
, "%%%02x", ch
);
699 void strbuf_addstr_urlencode(struct strbuf
*sb
, const char *s
,
702 strbuf_add_urlencode(sb
, s
, strlen(s
), reserved
);
705 void strbuf_humanise_bytes(struct strbuf
*buf
, off_t bytes
)
707 if (bytes
> 1 << 30) {
708 strbuf_addf(buf
, "%u.%2.2u GiB",
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);
720 strbuf_addf(buf
, "%u bytes", (int)bytes
);
724 void strbuf_add_absolute_path(struct strbuf
*sb
, const char *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
);
741 strbuf_addstr(sb
, cwd
);
742 if (sb
->len
> orig_len
&& !is_dir_sep(sb
->buf
[sb
->len
- 1]))
743 strbuf_addch(sb
, '/');
746 strbuf_addstr(sb
, path
);
749 void strbuf_add_real_path(struct strbuf
*sb
, const char *path
)
752 struct strbuf resolved
= STRBUF_INIT
;
753 strbuf_realpath(&resolved
, path
, 1);
754 strbuf_addbuf(sb
, &resolved
);
755 strbuf_release(&resolved
);
757 strbuf_realpath(sb
, path
, 1);
760 int printf_ln(const char *fmt
, ...)
765 ret
= vprintf(fmt
, ap
);
767 if (ret
< 0 || putchar('\n') == EOF
)
772 int fprintf_ln(FILE *fp
, const char *fmt
, ...)
777 ret
= vfprintf(fp
, fmt
, ap
);
779 if (ret
< 0 || putc('\n', fp
) == EOF
)
784 char *xstrdup_tolower(const char *string
)
789 len
= strlen(string
);
790 result
= xmallocz(len
);
791 for (i
= 0; i
< len
; i
++)
792 result
[i
] = tolower(string
[i
]);
796 char *xstrdup_toupper(const char *string
)
801 len
= strlen(string
);
802 result
= xmallocz(len
);
803 for (i
= 0; i
< len
; i
++)
804 result
[i
] = toupper(string
[i
]);
808 char *xstrvfmt(const char *fmt
, va_list ap
)
810 struct strbuf buf
= STRBUF_INIT
;
811 strbuf_vaddf(&buf
, fmt
, ap
);
812 return strbuf_detach(&buf
, NULL
);
815 char *xstrfmt(const char *fmt
, ...)
821 ret
= xstrvfmt(fmt
, ap
);
827 void strbuf_addftime(struct strbuf
*sb
, const char *fmt
, const struct tm
*tm
,
828 int tz_offset
, int suppress_tz_name
)
830 struct strbuf munged_fmt
= STRBUF_INIT
;
838 * There is no portable way to pass timezone information to
839 * strftime, so we handle %z and %Z here.
842 const char *percent
= strchrnul(fmt
, '%');
843 strbuf_add(&munged_fmt
, fmt
, percent
- fmt
);
849 strbuf_addstr(&munged_fmt
, "%%");
853 strbuf_addf(&munged_fmt
, "%+05d", tz_offset
);
857 if (suppress_tz_name
) {
863 strbuf_addch(&munged_fmt
, '%');
866 fmt
= munged_fmt
.buf
;
868 strbuf_grow(sb
, hint
);
869 len
= strftime(sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
, fmt
, tm
);
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.
879 strbuf_addch(&munged_fmt
, ' ');
882 strbuf_grow(sb
, hint
);
883 len
= strftime(sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
,
886 len
--; /* drop munged space */
888 strbuf_release(&munged_fmt
);
889 strbuf_setlen(sb
, sb
->len
+ len
);
892 void strbuf_add_unique_abbrev(struct strbuf
*sb
, const unsigned char *sha1
,
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
);
902 * Returns the length of a line, without trailing spaces.
904 * If the line ends with newline, it will be removed too.
906 static size_t cleanup(char *line
, size_t len
)
909 unsigned char c
= line
[len
- 1];
919 * Remove empty lines from the beginning and end
920 * and also trailing spaces from every line.
922 * Turn multiple consecutive empty lines between paragraphs
923 * into just one empty line.
925 * If the input has only empty lines and spaces,
926 * no output will be produced.
928 * If last line does not have a newline at the end, one is added.
930 * Enable skip_comments to skip every line starting with comment
933 void strbuf_stripspace(struct strbuf
*sb
, int skip_comments
)
936 size_t i
, j
, len
, newlen
;
939 /* We may have to add a newline. */
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
;
946 if (skip_comments
&& len
&& sb
->buf
[i
] == comment_line_char
) {
950 newlen
= cleanup(sb
->buf
+ i
, len
);
952 /* Not just an empty line? */
954 if (empties
> 0 && j
> 0)
957 memmove(sb
->buf
+ j
, sb
->buf
+ i
, newlen
);
958 sb
->buf
[newlen
+ j
++] = '\n';
964 strbuf_setlen(sb
, j
);
967 int strbuf_normalize_path(struct strbuf
*src
)
969 struct strbuf dst
= STRBUF_INIT
;
971 strbuf_grow(&dst
, src
->len
);
972 if (normalize_path_copy(dst
.buf
, src
->buf
) < 0) {
973 strbuf_release(&dst
);
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
981 strbuf_setlen(&dst
, strlen(dst
.buf
));
982 strbuf_swap(src
, &dst
);
983 strbuf_release(&dst
);