4 int prefixcmp(const char *str
, const char *prefix
)
6 for (; ; str
++, prefix
++)
9 else if (*str
!= *prefix
)
10 return (unsigned char)*prefix
- (unsigned char)*str
;
13 int suffixcmp(const char *str
, const char *suffix
)
15 int len
= strlen(str
), suflen
= strlen(suffix
);
19 return strcmp(str
+ len
- suflen
, suffix
);
23 * Used as the default ->buf value, so that people can always assume
24 * buf is non NULL and ->buf is NUL terminated even for a freshly
27 char strbuf_slopbuf
[1];
29 void strbuf_init(struct strbuf
*sb
, size_t hint
)
31 sb
->alloc
= sb
->len
= 0;
32 sb
->buf
= strbuf_slopbuf
;
34 strbuf_grow(sb
, hint
);
37 void strbuf_release(struct strbuf
*sb
)
45 char *strbuf_detach(struct strbuf
*sb
, size_t *sz
)
47 char *res
= sb
->alloc
? sb
->buf
: NULL
;
54 void strbuf_attach(struct strbuf
*sb
, void *buf
, size_t len
, size_t alloc
)
61 sb
->buf
[sb
->len
] = '\0';
64 void strbuf_grow(struct strbuf
*sb
, size_t extra
)
66 if (sb
->len
+ extra
+ 1 <= sb
->len
)
67 die("you want to use way too much memory");
70 ALLOC_GROW(sb
->buf
, sb
->len
+ extra
+ 1, sb
->alloc
);
73 void strbuf_trim(struct strbuf
*sb
)
76 while (sb
->len
> 0 && isspace((unsigned char)sb
->buf
[sb
->len
- 1]))
78 while (sb
->len
> 0 && isspace(*b
)) {
82 memmove(sb
->buf
, b
, sb
->len
);
83 sb
->buf
[sb
->len
] = '\0';
85 void strbuf_rtrim(struct strbuf
*sb
)
87 while (sb
->len
> 0 && isspace((unsigned char)sb
->buf
[sb
->len
- 1]))
89 sb
->buf
[sb
->len
] = '\0';
92 void strbuf_ltrim(struct strbuf
*sb
)
95 while (sb
->len
> 0 && isspace(*b
)) {
99 memmove(sb
->buf
, b
, sb
->len
);
100 sb
->buf
[sb
->len
] = '\0';
103 struct strbuf
**strbuf_split(const struct strbuf
*sb
, int delim
)
105 int alloc
= 2, pos
= 0;
110 ret
= xcalloc(alloc
, sizeof(struct strbuf
*));
112 while (n
< sb
->buf
+ sb
->len
) {
114 n
= memchr(n
, delim
, sb
->len
- (n
- sb
->buf
));
115 if (pos
+ 1 >= alloc
) {
117 ret
= xrealloc(ret
, sizeof(struct strbuf
*) * alloc
);
120 n
= sb
->buf
+ sb
->len
- 1;
122 t
= xmalloc(sizeof(struct strbuf
));
124 strbuf_add(t
, p
, len
);
132 void strbuf_list_free(struct strbuf
**sbs
)
134 struct strbuf
**s
= sbs
;
143 int strbuf_cmp(const struct strbuf
*a
, const struct strbuf
*b
)
145 int len
= a
->len
< b
->len
? a
->len
: b
->len
;
146 int cmp
= memcmp(a
->buf
, b
->buf
, len
);
149 return a
->len
< b
->len
? -1: a
->len
!= b
->len
;
152 void strbuf_splice(struct strbuf
*sb
, size_t pos
, size_t len
,
153 const void *data
, size_t dlen
)
156 die("you want to use way too much memory");
158 die("`pos' is too far after the end of the buffer");
159 if (pos
+ len
> sb
->len
)
160 die("`pos + len' is too far after the end of the buffer");
163 strbuf_grow(sb
, dlen
- len
);
164 memmove(sb
->buf
+ pos
+ dlen
,
166 sb
->len
- pos
- len
);
167 memcpy(sb
->buf
+ pos
, data
, dlen
);
168 strbuf_setlen(sb
, sb
->len
+ dlen
- len
);
171 void strbuf_insert(struct strbuf
*sb
, size_t pos
, const void *data
, size_t len
)
173 strbuf_splice(sb
, pos
, 0, data
, len
);
176 void strbuf_remove(struct strbuf
*sb
, size_t pos
, size_t len
)
178 strbuf_splice(sb
, pos
, len
, NULL
, 0);
181 void strbuf_add(struct strbuf
*sb
, const void *data
, size_t len
)
183 strbuf_grow(sb
, len
);
184 memcpy(sb
->buf
+ sb
->len
, data
, len
);
185 strbuf_setlen(sb
, sb
->len
+ len
);
188 void strbuf_adddup(struct strbuf
*sb
, size_t pos
, size_t len
)
190 strbuf_grow(sb
, len
);
191 memcpy(sb
->buf
+ sb
->len
, sb
->buf
+ pos
, len
);
192 strbuf_setlen(sb
, sb
->len
+ len
);
195 static int number_length(unsigned long number
, long base
)
198 while (number
>= base
) {
206 * Only supports %u, %i, %d, %l, %o, %x and %X with size indicators
207 * '<number>', '0<number>', '-<number>' and ' <number>',
209 * and %s with size indicators '<number>', ' <number>' and '.*'.
211 void strbuf_vaddf(struct strbuf
*sb
, const char *fmt
, va_list ap
)
215 int size
= -1, max_size
= -1, left_align
= 0;
216 char *p
= (char *)fmt
;
219 p
= strchrnul(fmt
, '%');
220 strbuf_add(sb
, fmt
, p
- fmt
);
226 strbuf_addch(sb
, *p
++);
234 if (*p
== ' ' || *p
== '0')
237 size
= (int)strtol(p
, &p
, 10);
238 else if (*p
== '.' && p
[1] == '*') {
239 max_size
= va_arg(ap
, int);
242 else if (*p
== '*') {
245 size
= va_arg(ap
, int);
251 const char *s
= va_arg(ap
, const char *);
252 if (fill
&& !left_align
) {
253 int len
= size
- strlen(s
);
255 strbuf_addch(sb
, fill
);
257 while (*s
&& max_size
--)
258 strbuf_addch(sb
, *s
++);
259 if (fill
&& left_align
) {
260 int len
= size
- strlen(s
);
262 strbuf_addch(sb
, ' ');
267 strbuf_addch(sb
, va_arg(ap
, int));
276 int base
= *p
== 'x' || *p
== 'X' ? 16 :
278 int negative
= 0, len
;
279 unsigned long number
, power
;
282 number
= va_arg(ap
, unsigned int);
286 signed_number
= va_arg(ap
, long);
288 signed_number
= va_arg(ap
, int);
289 if (signed_number
< 0) {
291 number
= -signed_number
;
293 number
= signed_number
;
297 len
= number_length(number
, base
);
298 while (size
-- > len
+ negative
)
299 strbuf_addch(sb
, fill
? fill
: ' ');
301 strbuf_addch(sb
, '-');
308 int digit
= number
/ power
;
309 strbuf_addch(sb
, digit
< 10 ? '0' + digit
310 : *p
+ 'A' - 'X' + digit
- 10);
311 number
-= digit
* power
;
320 /* unknown / invalid format: copy verbatim */
321 strbuf_insert(sb
, sb
->len
, fmt
, p
- fmt
+ 1);
323 fmt
= p
+ (*p
!= '\0');
327 void strbuf_addf(struct strbuf
*sb
, const char *fmt
, ...)
332 strbuf_vaddf(sb
, fmt
, ap
);
336 void strbuf_initf(struct strbuf
*sb
, const char *fmt
, ...)
340 strbuf_init(sb
, strlen(fmt
) + 64);
342 strbuf_vaddf(sb
, fmt
, ap
);
346 void strbuf_expand(struct strbuf
*sb
, const char *format
, expand_fn_t fn
,
353 percent
= strchrnul(format
, '%');
354 strbuf_add(sb
, format
, percent
- format
);
357 format
= percent
+ 1;
359 if (*format
== '%') {
360 strbuf_addch(sb
, '%');
365 consumed
= fn(sb
, format
, context
);
369 strbuf_addch(sb
, '%');
373 size_t strbuf_expand_dict_cb(struct strbuf
*sb
, const char *placeholder
,
376 struct strbuf_expand_dict_entry
*e
= context
;
379 for (; e
->placeholder
&& (len
= strlen(e
->placeholder
)); e
++) {
380 if (!strncmp(placeholder
, e
->placeholder
, len
)) {
382 strbuf_addstr(sb
, e
->value
);
389 void strbuf_addbuf_percentquote(struct strbuf
*dst
, const struct strbuf
*src
)
391 int i
, len
= src
->len
;
393 for (i
= 0; i
< len
; i
++) {
394 if (src
->buf
[i
] == '%')
395 strbuf_addch(dst
, '%');
396 strbuf_addch(dst
, src
->buf
[i
]);
400 size_t strbuf_fread(struct strbuf
*sb
, size_t size
, FILE *f
)
403 size_t oldalloc
= sb
->alloc
;
405 strbuf_grow(sb
, size
);
406 res
= fread(sb
->buf
+ sb
->len
, 1, size
, f
);
408 strbuf_setlen(sb
, sb
->len
+ res
);
409 else if (oldalloc
== 0)
414 ssize_t
strbuf_read(struct strbuf
*sb
, int fd
, size_t hint
)
416 size_t oldlen
= sb
->len
;
417 size_t oldalloc
= sb
->alloc
;
419 strbuf_grow(sb
, hint
? hint
: 8192);
423 cnt
= xread(fd
, sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
- 1);
428 strbuf_setlen(sb
, oldlen
);
434 strbuf_grow(sb
, 8192);
437 sb
->buf
[sb
->len
] = '\0';
438 return sb
->len
- oldlen
;
441 #define STRBUF_MAXLINK (2*PATH_MAX)
443 int strbuf_readlink(struct strbuf
*sb
, const char *path
, size_t hint
)
445 size_t oldalloc
= sb
->alloc
;
450 while (hint
< STRBUF_MAXLINK
) {
453 strbuf_grow(sb
, hint
);
454 len
= readlink(path
, sb
->buf
, hint
);
458 } else if (len
< hint
) {
459 strbuf_setlen(sb
, len
);
463 /* .. the buffer was too small - try again */
471 int strbuf_getwholeline(struct strbuf
*sb
, FILE *fp
, int term
)
480 while ((ch
= fgetc(fp
)) != EOF
) {
482 sb
->buf
[sb
->len
++] = ch
;
486 if (ch
== EOF
&& sb
->len
== 0)
489 sb
->buf
[sb
->len
] = '\0';
493 int strbuf_getline(struct strbuf
*sb
, FILE *fp
, int term
)
495 if (strbuf_getwholeline(sb
, fp
, term
))
497 if (sb
->buf
[sb
->len
-1] == term
)
498 strbuf_setlen(sb
, sb
->len
-1);
502 int strbuf_read_file(struct strbuf
*sb
, const char *path
, size_t hint
)
506 fd
= open(path
, O_RDONLY
);
509 len
= strbuf_read(sb
, fd
, hint
);
517 int strbuf_branchname(struct strbuf
*sb
, const char *name
)
519 int len
= strlen(name
);
520 if (interpret_branch_name(name
, sb
) == len
)
522 strbuf_add(sb
, name
, len
);
526 int strbuf_check_branch_ref(struct strbuf
*sb
, const char *name
)
528 strbuf_branchname(sb
, name
);
529 strbuf_splice(sb
, 0, 0, "refs/heads/", 11);
530 return check_ref_format(sb
->buf
);