1 #include "git-compat-util.h"
5 #include "string-list.h"
9 int starts_with(const char *str
, const char *prefix
)
11 for (; ; str
++, prefix
++)
14 else if (*str
!= *prefix
)
18 int istarts_with(const char *str
, const char *prefix
)
20 for (; ; str
++, prefix
++)
23 else if (tolower(*str
) != tolower(*prefix
))
27 int skip_to_optional_arg_default(const char *str
, const char *prefix
,
28 const char **arg
, const char *def
)
32 if (!skip_prefix(str
, prefix
, &p
))
50 * Used as the default ->buf value, so that people can always assume
51 * buf is non NULL and ->buf is NUL terminated even for a freshly
54 char strbuf_slopbuf
[1];
56 void strbuf_init(struct strbuf
*sb
, size_t hint
)
58 struct strbuf blank
= STRBUF_INIT
;
59 memcpy(sb
, &blank
, sizeof(*sb
));
61 strbuf_grow(sb
, hint
);
64 void strbuf_release(struct strbuf
*sb
)
72 char *strbuf_detach(struct strbuf
*sb
, size_t *sz
)
83 void strbuf_attach(struct strbuf
*sb
, void *buf
, size_t len
, size_t alloc
)
90 sb
->buf
[sb
->len
] = '\0';
93 void strbuf_grow(struct strbuf
*sb
, size_t extra
)
95 int new_buf
= !sb
->alloc
;
96 if (unsigned_add_overflows(extra
, 1) ||
97 unsigned_add_overflows(sb
->len
, extra
+ 1))
98 die("you want to use way too much memory");
101 ALLOC_GROW(sb
->buf
, sb
->len
+ extra
+ 1, sb
->alloc
);
106 void strbuf_trim(struct strbuf
*sb
)
112 void strbuf_rtrim(struct strbuf
*sb
)
114 while (sb
->len
> 0 && isspace((unsigned char)sb
->buf
[sb
->len
- 1]))
116 sb
->buf
[sb
->len
] = '\0';
119 void strbuf_trim_trailing_dir_sep(struct strbuf
*sb
)
121 while (sb
->len
> 0 && is_dir_sep((unsigned char)sb
->buf
[sb
->len
- 1]))
123 sb
->buf
[sb
->len
] = '\0';
126 void strbuf_trim_trailing_newline(struct strbuf
*sb
)
128 if (sb
->len
> 0 && sb
->buf
[sb
->len
- 1] == '\n') {
129 if (--sb
->len
> 0 && sb
->buf
[sb
->len
- 1] == '\r')
131 sb
->buf
[sb
->len
] = '\0';
135 void strbuf_ltrim(struct strbuf
*sb
)
138 while (sb
->len
> 0 && isspace(*b
)) {
142 memmove(sb
->buf
, b
, sb
->len
);
143 sb
->buf
[sb
->len
] = '\0';
146 int strbuf_reencode(struct strbuf
*sb
, const char *from
, const char *to
)
151 if (same_encoding(from
, to
))
154 out
= reencode_string_len(sb
->buf
, sb
->len
, to
, from
, &len
);
158 strbuf_attach(sb
, out
, len
, len
);
162 void strbuf_tolower(struct strbuf
*sb
)
164 char *p
= sb
->buf
, *end
= sb
->buf
+ sb
->len
;
169 struct strbuf
**strbuf_split_buf(const char *str
, size_t slen
,
170 int terminator
, int max
)
172 struct strbuf
**ret
= NULL
;
173 size_t nr
= 0, alloc
= 0;
178 if (max
<= 0 || nr
+ 1 < max
) {
179 const char *end
= memchr(str
, terminator
, slen
);
183 t
= xmalloc(sizeof(struct strbuf
));
185 strbuf_add(t
, str
, len
);
186 ALLOC_GROW(ret
, nr
+ 2, alloc
);
191 ALLOC_GROW(ret
, nr
+ 1, alloc
); /* In case string was empty */
196 void strbuf_add_separated_string_list(struct strbuf
*str
,
198 struct string_list
*slist
)
200 struct string_list_item
*item
;
203 for_each_string_list_item(item
, slist
) {
205 strbuf_addstr(str
, sep
);
206 strbuf_addstr(str
, item
->string
);
211 void strbuf_list_free(struct strbuf
**sbs
)
213 struct strbuf
**s
= sbs
;
224 int strbuf_cmp(const struct strbuf
*a
, const struct strbuf
*b
)
226 size_t len
= a
->len
< b
->len
? a
->len
: b
->len
;
227 int cmp
= memcmp(a
->buf
, b
->buf
, len
);
230 return a
->len
< b
->len
? -1: a
->len
!= b
->len
;
233 void strbuf_splice(struct strbuf
*sb
, size_t pos
, size_t len
,
234 const void *data
, size_t dlen
)
236 if (unsigned_add_overflows(pos
, len
))
237 die("you want to use way too much memory");
239 die("`pos' is too far after the end of the buffer");
240 if (pos
+ len
> sb
->len
)
241 die("`pos + len' is too far after the end of the buffer");
244 strbuf_grow(sb
, dlen
- len
);
245 memmove(sb
->buf
+ pos
+ dlen
,
247 sb
->len
- pos
- len
);
248 memcpy(sb
->buf
+ pos
, data
, dlen
);
249 strbuf_setlen(sb
, sb
->len
+ dlen
- len
);
252 void strbuf_insert(struct strbuf
*sb
, size_t pos
, const void *data
, size_t len
)
254 strbuf_splice(sb
, pos
, 0, data
, len
);
257 void strbuf_vinsertf(struct strbuf
*sb
, size_t pos
, const char *fmt
, va_list ap
)
264 die("`pos' is too far after the end of the buffer");
266 len
= vsnprintf(sb
->buf
+ sb
->len
, 0, fmt
, cp
);
269 BUG("your vsnprintf is broken (returned %d)", len
);
271 return; /* nothing to do */
272 if (unsigned_add_overflows(sb
->len
, len
))
273 die("you want to use way too much memory");
274 strbuf_grow(sb
, len
);
275 memmove(sb
->buf
+ pos
+ len
, sb
->buf
+ pos
, sb
->len
- pos
);
276 /* vsnprintf() will append a NUL, overwriting one of our characters */
277 save
= sb
->buf
[pos
+ len
];
278 len2
= vsnprintf(sb
->buf
+ pos
, len
+ 1, fmt
, ap
);
279 sb
->buf
[pos
+ len
] = save
;
281 BUG("your vsnprintf is broken (returns inconsistent lengths)");
282 strbuf_setlen(sb
, sb
->len
+ len
);
285 void strbuf_insertf(struct strbuf
*sb
, size_t pos
, const char *fmt
, ...)
289 strbuf_vinsertf(sb
, pos
, fmt
, ap
);
293 void strbuf_remove(struct strbuf
*sb
, size_t pos
, size_t len
)
295 strbuf_splice(sb
, pos
, len
, "", 0);
298 void strbuf_add(struct strbuf
*sb
, const void *data
, size_t len
)
300 strbuf_grow(sb
, len
);
301 memcpy(sb
->buf
+ sb
->len
, data
, len
);
302 strbuf_setlen(sb
, sb
->len
+ len
);
305 void strbuf_addbuf(struct strbuf
*sb
, const struct strbuf
*sb2
)
307 strbuf_grow(sb
, sb2
->len
);
308 memcpy(sb
->buf
+ sb
->len
, sb2
->buf
, sb2
->len
);
309 strbuf_setlen(sb
, sb
->len
+ sb2
->len
);
312 const char *strbuf_join_argv(struct strbuf
*buf
,
313 int argc
, const char **argv
, char delim
)
318 strbuf_addstr(buf
, *argv
);
320 strbuf_addch(buf
, delim
);
321 strbuf_addstr(buf
, *(++argv
));
327 void strbuf_addchars(struct strbuf
*sb
, int c
, size_t n
)
330 memset(sb
->buf
+ sb
->len
, c
, n
);
331 strbuf_setlen(sb
, sb
->len
+ n
);
334 void strbuf_addf(struct strbuf
*sb
, const char *fmt
, ...)
338 strbuf_vaddf(sb
, fmt
, ap
);
342 static void add_lines(struct strbuf
*out
,
344 const char *buf
, size_t size
,
345 int space_after_prefix
)
348 const char *next
= memchr(buf
, '\n', size
);
349 next
= next
? (next
+ 1) : (buf
+ size
);
351 strbuf_addstr(out
, prefix
);
352 if (space_after_prefix
&& buf
[0] != '\n' && buf
[0] != '\t')
353 strbuf_addch(out
, ' ');
354 strbuf_add(out
, buf
, next
- buf
);
358 strbuf_complete_line(out
);
361 void strbuf_add_commented_lines(struct strbuf
*out
, const char *buf
,
362 size_t size
, char comment_prefix
)
366 prefix
[0] = comment_prefix
;
368 add_lines(out
, prefix
, buf
, size
, 1);
371 void strbuf_commented_addf(struct strbuf
*sb
, const char *comment_prefix
,
372 const char *fmt
, ...)
375 struct strbuf buf
= STRBUF_INIT
;
376 int incomplete_line
= sb
->len
&& sb
->buf
[sb
->len
- 1] != '\n';
378 va_start(params
, fmt
);
379 strbuf_vaddf(&buf
, fmt
, params
);
383 * TODO Our commented_lines helper does not yet understand
384 * comment strings. But since we know that the strings are
385 * always single-char, we can cheat for the moment, and
388 strbuf_add_commented_lines(sb
, buf
.buf
, buf
.len
, comment_prefix
[0]);
390 sb
->buf
[--sb
->len
] = '\0';
392 strbuf_release(&buf
);
395 void strbuf_vaddf(struct strbuf
*sb
, const char *fmt
, va_list ap
)
400 if (!strbuf_avail(sb
))
403 len
= vsnprintf(sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
, fmt
, cp
);
406 BUG("your vsnprintf is broken (returned %d)", len
);
407 if (len
> strbuf_avail(sb
)) {
408 strbuf_grow(sb
, len
);
409 len
= vsnprintf(sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
, fmt
, ap
);
410 if (len
> strbuf_avail(sb
))
411 BUG("your vsnprintf is broken (insatiable)");
413 strbuf_setlen(sb
, sb
->len
+ len
);
416 int strbuf_expand_step(struct strbuf
*sb
, const char **formatp
)
418 const char *format
= *formatp
;
419 const char *percent
= strchrnul(format
, '%');
421 strbuf_add(sb
, format
, percent
- format
);
424 *formatp
= percent
+ 1;
428 size_t strbuf_expand_literal(struct strbuf
*sb
, const char *placeholder
)
432 switch (placeholder
[0]) {
433 case 'n': /* newline */
434 strbuf_addch(sb
, '\n');
437 /* %x00 == NUL, %x0a == LF, etc. */
438 ch
= hex2chr(placeholder
+ 1);
441 strbuf_addch(sb
, ch
);
447 void strbuf_addbuf_percentquote(struct strbuf
*dst
, const struct strbuf
*src
)
449 size_t i
, len
= src
->len
;
451 for (i
= 0; i
< len
; i
++) {
452 if (src
->buf
[i
] == '%')
453 strbuf_addch(dst
, '%');
454 strbuf_addch(dst
, src
->buf
[i
]);
458 #define URL_UNSAFE_CHARS " <>\"%{}|\\^`:?#[]@!$&'()*+,;="
460 void strbuf_add_percentencode(struct strbuf
*dst
, const char *src
, int flags
)
462 size_t i
, len
= strlen(src
);
464 for (i
= 0; i
< len
; i
++) {
465 unsigned char ch
= src
[i
];
466 if (ch
<= 0x1F || ch
>= 0x7F ||
467 (ch
== '/' && (flags
& STRBUF_ENCODE_SLASH
)) ||
468 strchr(URL_UNSAFE_CHARS
, ch
))
469 strbuf_addf(dst
, "%%%02X", (unsigned char)ch
);
471 strbuf_addch(dst
, ch
);
475 size_t strbuf_fread(struct strbuf
*sb
, size_t size
, FILE *f
)
478 size_t oldalloc
= sb
->alloc
;
480 strbuf_grow(sb
, size
);
481 res
= fread(sb
->buf
+ sb
->len
, 1, size
, f
);
483 strbuf_setlen(sb
, sb
->len
+ res
);
484 else if (oldalloc
== 0)
489 ssize_t
strbuf_read(struct strbuf
*sb
, int fd
, size_t hint
)
491 size_t oldlen
= sb
->len
;
492 size_t oldalloc
= sb
->alloc
;
494 strbuf_grow(sb
, hint
? hint
: 8192);
496 ssize_t want
= sb
->alloc
- sb
->len
- 1;
497 ssize_t got
= read_in_full(fd
, sb
->buf
+ sb
->len
, want
);
503 strbuf_setlen(sb
, oldlen
);
509 strbuf_grow(sb
, 8192);
512 sb
->buf
[sb
->len
] = '\0';
513 return sb
->len
- oldlen
;
516 ssize_t
strbuf_read_once(struct strbuf
*sb
, int fd
, size_t hint
)
518 size_t oldalloc
= sb
->alloc
;
521 strbuf_grow(sb
, hint
? hint
: 8192);
522 cnt
= xread(fd
, sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
- 1);
524 strbuf_setlen(sb
, sb
->len
+ cnt
);
525 else if (oldalloc
== 0)
530 ssize_t
strbuf_write(struct strbuf
*sb
, FILE *f
)
532 return sb
->len
? fwrite(sb
->buf
, 1, sb
->len
, f
) : 0;
535 #define STRBUF_MAXLINK (2*PATH_MAX)
537 int strbuf_readlink(struct strbuf
*sb
, const char *path
, size_t hint
)
539 size_t oldalloc
= sb
->alloc
;
544 while (hint
< STRBUF_MAXLINK
) {
547 strbuf_grow(sb
, hint
);
548 len
= readlink(path
, sb
->buf
, hint
);
552 } else if (len
< hint
) {
553 strbuf_setlen(sb
, len
);
557 /* .. the buffer was too small - try again */
565 int strbuf_getcwd(struct strbuf
*sb
)
567 size_t oldalloc
= sb
->alloc
;
568 size_t guessed_len
= 128;
570 for (;; guessed_len
*= 2) {
571 strbuf_grow(sb
, guessed_len
);
572 if (getcwd(sb
->buf
, sb
->alloc
)) {
573 strbuf_setlen(sb
, strlen(sb
->buf
));
578 * If getcwd(3) is implemented as a syscall that falls
579 * back to a regular lookup using readdir(3) etc. then
580 * we may be able to avoid EACCES by providing enough
581 * space to the syscall as it's not necessarily bound
582 * to the same restrictions as the fallback.
584 if (errno
== EACCES
&& guessed_len
< PATH_MAX
)
598 int strbuf_getwholeline(struct strbuf
*sb
, FILE *fp
, int term
)
607 /* Translate slopbuf to NULL, as we cannot call realloc on it */
611 r
= getdelim(&sb
->buf
, &sb
->alloc
, term
, fp
);
620 * Normally we would have called xrealloc, which will try to free
621 * memory and recover. But we have no way to tell getdelim() to do so.
622 * Worse, we cannot try to recover ENOMEM ourselves, because we have
623 * no idea how many bytes were read by getdelim.
625 * Dying here is reasonable. It mirrors what xrealloc would do on
626 * catastrophic memory failure. We skip the opportunity to free pack
627 * memory and retry, but that's unlikely to help for a malloc small
628 * enough to hold a single line of input, anyway.
631 die("Out of memory, getdelim failed");
634 * Restore strbuf invariants; if getdelim left us with a NULL pointer,
635 * we can just re-init, but otherwise we should make sure that our
636 * length is empty, and that the result is NUL-terminated.
645 int strbuf_getwholeline(struct strbuf
*sb
, FILE *fp
, int term
)
654 while ((ch
= getc_unlocked(fp
)) != EOF
) {
655 if (!strbuf_avail(sb
))
657 sb
->buf
[sb
->len
++] = ch
;
662 if (ch
== EOF
&& sb
->len
== 0)
665 sb
->buf
[sb
->len
] = '\0';
670 int strbuf_appendwholeline(struct strbuf
*sb
, FILE *fp
, int term
)
672 struct strbuf line
= STRBUF_INIT
;
673 if (strbuf_getwholeline(&line
, fp
, term
))
675 strbuf_addbuf(sb
, &line
);
676 strbuf_release(&line
);
680 static int strbuf_getdelim(struct strbuf
*sb
, FILE *fp
, int term
)
682 if (strbuf_getwholeline(sb
, fp
, term
))
684 if (sb
->buf
[sb
->len
- 1] == term
)
685 strbuf_setlen(sb
, sb
->len
- 1);
689 int strbuf_getdelim_strip_crlf(struct strbuf
*sb
, FILE *fp
, int term
)
691 if (strbuf_getwholeline(sb
, fp
, term
))
693 if (term
== '\n' && sb
->buf
[sb
->len
- 1] == '\n') {
694 strbuf_setlen(sb
, sb
->len
- 1);
695 if (sb
->len
&& sb
->buf
[sb
->len
- 1] == '\r')
696 strbuf_setlen(sb
, sb
->len
- 1);
701 int strbuf_getline(struct strbuf
*sb
, FILE *fp
)
703 return strbuf_getdelim_strip_crlf(sb
, fp
, '\n');
706 int strbuf_getline_lf(struct strbuf
*sb
, FILE *fp
)
708 return strbuf_getdelim(sb
, fp
, '\n');
711 int strbuf_getline_nul(struct strbuf
*sb
, FILE *fp
)
713 return strbuf_getdelim(sb
, fp
, '\0');
716 int strbuf_getwholeline_fd(struct strbuf
*sb
, int fd
, int term
)
722 ssize_t len
= xread(fd
, &ch
, 1);
725 strbuf_addch(sb
, ch
);
732 ssize_t
strbuf_read_file(struct strbuf
*sb
, const char *path
, size_t hint
)
738 fd
= open(path
, O_RDONLY
);
741 len
= strbuf_read(sb
, fd
, hint
);
752 void strbuf_add_lines(struct strbuf
*out
, const char *prefix
,
753 const char *buf
, size_t size
)
755 add_lines(out
, prefix
, buf
, size
, 0);
758 void strbuf_addstr_xml_quoted(struct strbuf
*buf
, const char *s
)
761 size_t len
= strcspn(s
, "\"<>&");
762 strbuf_add(buf
, s
, len
);
766 strbuf_addstr(buf
, """);
769 strbuf_addstr(buf
, "<");
772 strbuf_addstr(buf
, ">");
775 strbuf_addstr(buf
, "&");
784 static void strbuf_add_urlencode(struct strbuf
*sb
, const char *s
, size_t len
,
785 char_predicate allow_unencoded_fn
)
787 strbuf_grow(sb
, len
);
790 if (allow_unencoded_fn(ch
))
791 strbuf_addch(sb
, ch
);
793 strbuf_addf(sb
, "%%%02x", (unsigned char)ch
);
797 void strbuf_addstr_urlencode(struct strbuf
*sb
, const char *s
,
798 char_predicate allow_unencoded_fn
)
800 strbuf_add_urlencode(sb
, s
, strlen(s
), allow_unencoded_fn
);
803 static void strbuf_humanise(struct strbuf
*buf
, off_t bytes
,
806 if (bytes
> 1 << 30) {
809 /* TRANSLATORS: IEC 80000-13:2008 gibibyte */
811 /* TRANSLATORS: IEC 80000-13:2008 gibibyte/second */
813 (unsigned)(bytes
>> 30),
814 (unsigned)(bytes
& ((1 << 30) - 1)) / 10737419);
815 } else if (bytes
> 1 << 20) {
816 unsigned x
= bytes
+ 5243; /* for rounding */
819 /* TRANSLATORS: IEC 80000-13:2008 mebibyte */
821 /* TRANSLATORS: IEC 80000-13:2008 mebibyte/second */
823 x
>> 20, ((x
& ((1 << 20) - 1)) * 100) >> 20);
824 } else if (bytes
> 1 << 10) {
825 unsigned x
= bytes
+ 5; /* for rounding */
828 /* TRANSLATORS: IEC 80000-13:2008 kibibyte */
830 /* TRANSLATORS: IEC 80000-13:2008 kibibyte/second */
832 x
>> 10, ((x
& ((1 << 10) - 1)) * 100) >> 10);
836 /* TRANSLATORS: IEC 80000-13:2008 byte */
837 Q_("%u byte", "%u bytes", bytes
) :
838 /* TRANSLATORS: IEC 80000-13:2008 byte/second */
839 Q_("%u byte/s", "%u bytes/s", bytes
),
844 void strbuf_humanise_bytes(struct strbuf
*buf
, off_t bytes
)
846 strbuf_humanise(buf
, bytes
, 0);
849 void strbuf_humanise_rate(struct strbuf
*buf
, off_t bytes
)
851 strbuf_humanise(buf
, bytes
, 1);
854 int printf_ln(const char *fmt
, ...)
859 ret
= vprintf(fmt
, ap
);
861 if (ret
< 0 || putchar('\n') == EOF
)
866 int fprintf_ln(FILE *fp
, const char *fmt
, ...)
871 ret
= vfprintf(fp
, fmt
, ap
);
873 if (ret
< 0 || putc('\n', fp
) == EOF
)
878 char *xstrdup_tolower(const char *string
)
883 len
= strlen(string
);
884 result
= xmallocz(len
);
885 for (i
= 0; i
< len
; i
++)
886 result
[i
] = tolower(string
[i
]);
890 char *xstrdup_toupper(const char *string
)
895 len
= strlen(string
);
896 result
= xmallocz(len
);
897 for (i
= 0; i
< len
; i
++)
898 result
[i
] = toupper(string
[i
]);
902 char *xstrvfmt(const char *fmt
, va_list ap
)
904 struct strbuf buf
= STRBUF_INIT
;
905 strbuf_vaddf(&buf
, fmt
, ap
);
906 return strbuf_detach(&buf
, NULL
);
909 char *xstrfmt(const char *fmt
, ...)
915 ret
= xstrvfmt(fmt
, ap
);
921 void strbuf_addftime(struct strbuf
*sb
, const char *fmt
, const struct tm
*tm
,
922 int tz_offset
, int suppress_tz_name
)
924 struct strbuf munged_fmt
= STRBUF_INIT
;
932 * There is no portable way to pass timezone information to
933 * strftime, so we handle %z and %Z here. Likewise '%s', because
934 * going back to an epoch time requires knowing the zone.
936 * Note that tz_offset is in the "[-+]HHMM" decimal form; this is what
937 * we want for %z, but the computation for %s has to convert to number
940 while (strbuf_expand_step(&munged_fmt
, &fmt
)) {
941 if (skip_prefix(fmt
, "%", &fmt
))
942 strbuf_addstr(&munged_fmt
, "%%");
943 else if (skip_prefix(fmt
, "s", &fmt
))
944 strbuf_addf(&munged_fmt
, "%"PRItime
,
945 (timestamp_t
)tm_to_time_t(tm
) -
946 3600 * (tz_offset
/ 100) -
947 60 * (tz_offset
% 100));
948 else if (skip_prefix(fmt
, "z", &fmt
))
949 strbuf_addf(&munged_fmt
, "%+05d", tz_offset
);
950 else if (suppress_tz_name
&& skip_prefix(fmt
, "Z", &fmt
))
953 strbuf_addch(&munged_fmt
, '%');
955 fmt
= munged_fmt
.buf
;
957 strbuf_grow(sb
, hint
);
958 len
= strftime(sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
, fmt
, tm
);
962 * strftime reports "0" if it could not fit the result in the buffer.
963 * Unfortunately, it also reports "0" if the requested time string
964 * takes 0 bytes. So our strategy is to munge the format so that the
965 * output contains at least one character, and then drop the extra
966 * character before returning.
968 strbuf_addch(&munged_fmt
, ' ');
971 strbuf_grow(sb
, hint
);
972 len
= strftime(sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
,
975 len
--; /* drop munged space */
977 strbuf_release(&munged_fmt
);
978 strbuf_setlen(sb
, sb
->len
+ len
);
982 * Returns the length of a line, without trailing spaces.
984 * If the line ends with newline, it will be removed too.
986 static size_t cleanup(char *line
, size_t len
)
989 unsigned char c
= line
[len
- 1];
999 * Remove empty lines from the beginning and end
1000 * and also trailing spaces from every line.
1002 * Turn multiple consecutive empty lines between paragraphs
1003 * into just one empty line.
1005 * If the input has only empty lines and spaces,
1006 * no output will be produced.
1008 * If last line does not have a newline at the end, one is added.
1010 * Pass a non-NULL comment_prefix to skip every line starting
1013 void strbuf_stripspace(struct strbuf
*sb
, const char *comment_prefix
)
1016 size_t i
, j
, len
, newlen
;
1019 /* We may have to add a newline. */
1022 for (i
= j
= 0; i
< sb
->len
; i
+= len
, j
+= newlen
) {
1023 eol
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
1024 len
= eol
? eol
- (sb
->buf
+ i
) + 1 : sb
->len
- i
;
1026 if (comment_prefix
&& len
&&
1027 starts_with(sb
->buf
+ i
, comment_prefix
)) {
1031 newlen
= cleanup(sb
->buf
+ i
, len
);
1033 /* Not just an empty line? */
1035 if (empties
> 0 && j
> 0)
1036 sb
->buf
[j
++] = '\n';
1038 memmove(sb
->buf
+ j
, sb
->buf
+ i
, newlen
);
1039 sb
->buf
[newlen
+ j
++] = '\n';
1045 strbuf_setlen(sb
, j
);
1048 void strbuf_strip_file_from_path(struct strbuf
*sb
)
1050 char *path_sep
= find_last_dir_sep(sb
->buf
);
1051 strbuf_setlen(sb
, path_sep
? path_sep
- sb
->buf
+ 1 : 0);