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
)
56 void strbuf_attach(struct strbuf
*sb
, void *buf
, size_t len
, size_t alloc
)
63 sb
->buf
[sb
->len
] = '\0';
66 void strbuf_grow(struct strbuf
*sb
, size_t extra
)
68 int new_buf
= !sb
->alloc
;
69 if (unsigned_add_overflows(extra
, 1) ||
70 unsigned_add_overflows(sb
->len
, extra
+ 1))
71 die("you want to use way too much memory");
74 ALLOC_GROW(sb
->buf
, sb
->len
+ extra
+ 1, sb
->alloc
);
79 void strbuf_trim(struct strbuf
*sb
)
82 while (sb
->len
> 0 && isspace((unsigned char)sb
->buf
[sb
->len
- 1]))
84 while (sb
->len
> 0 && isspace(*b
)) {
88 memmove(sb
->buf
, b
, sb
->len
);
89 sb
->buf
[sb
->len
] = '\0';
91 void strbuf_rtrim(struct strbuf
*sb
)
93 while (sb
->len
> 0 && isspace((unsigned char)sb
->buf
[sb
->len
- 1]))
95 sb
->buf
[sb
->len
] = '\0';
98 void strbuf_ltrim(struct strbuf
*sb
)
101 while (sb
->len
> 0 && isspace(*b
)) {
105 memmove(sb
->buf
, b
, sb
->len
);
106 sb
->buf
[sb
->len
] = '\0';
109 struct strbuf
**strbuf_split_buf(const char *str
, size_t slen
, int delim
, int max
)
111 struct strbuf
**ret
= NULL
;
112 size_t nr
= 0, alloc
= 0;
117 while (n
< str
+ slen
) {
119 if (max
<= 0 || nr
+ 1 < max
)
120 n
= memchr(n
, delim
, slen
- (n
- str
));
126 t
= xmalloc(sizeof(struct strbuf
));
128 strbuf_add(t
, p
, len
);
129 ALLOC_GROW(ret
, nr
+ 2, alloc
);
133 ALLOC_GROW(ret
, nr
+ 1, alloc
); /* In case string was empty */
138 void strbuf_list_free(struct strbuf
**sbs
)
140 struct strbuf
**s
= sbs
;
149 int strbuf_cmp(const struct strbuf
*a
, const struct strbuf
*b
)
151 int len
= a
->len
< b
->len
? a
->len
: b
->len
;
152 int cmp
= memcmp(a
->buf
, b
->buf
, len
);
155 return a
->len
< b
->len
? -1: a
->len
!= b
->len
;
158 void strbuf_splice(struct strbuf
*sb
, size_t pos
, size_t len
,
159 const void *data
, size_t dlen
)
161 if (unsigned_add_overflows(pos
, len
))
162 die("you want to use way too much memory");
164 die("`pos' is too far after the end of the buffer");
165 if (pos
+ len
> sb
->len
)
166 die("`pos + len' is too far after the end of the buffer");
169 strbuf_grow(sb
, dlen
- len
);
170 memmove(sb
->buf
+ pos
+ dlen
,
172 sb
->len
- pos
- len
);
173 memcpy(sb
->buf
+ pos
, data
, dlen
);
174 strbuf_setlen(sb
, sb
->len
+ dlen
- len
);
177 void strbuf_insert(struct strbuf
*sb
, size_t pos
, const void *data
, size_t len
)
179 strbuf_splice(sb
, pos
, 0, data
, len
);
182 void strbuf_remove(struct strbuf
*sb
, size_t pos
, size_t len
)
184 strbuf_splice(sb
, pos
, len
, NULL
, 0);
187 void strbuf_add(struct strbuf
*sb
, const void *data
, size_t len
)
189 strbuf_grow(sb
, len
);
190 memcpy(sb
->buf
+ sb
->len
, data
, len
);
191 strbuf_setlen(sb
, sb
->len
+ len
);
194 void strbuf_adddup(struct strbuf
*sb
, size_t pos
, size_t len
)
196 strbuf_grow(sb
, len
);
197 memcpy(sb
->buf
+ sb
->len
, sb
->buf
+ pos
, len
);
198 strbuf_setlen(sb
, sb
->len
+ len
);
201 void strbuf_addf(struct strbuf
*sb
, const char *fmt
, ...)
205 strbuf_vaddf(sb
, fmt
, ap
);
209 void strbuf_vaddf(struct strbuf
*sb
, const char *fmt
, va_list ap
)
214 if (!strbuf_avail(sb
))
217 len
= vsnprintf(sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
, fmt
, cp
);
220 die("BUG: your vsnprintf is broken (returned %d)", len
);
221 if (len
> strbuf_avail(sb
)) {
222 strbuf_grow(sb
, len
);
223 len
= vsnprintf(sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
, fmt
, ap
);
224 if (len
> strbuf_avail(sb
))
225 die("BUG: your vsnprintf is broken (insatiable)");
227 strbuf_setlen(sb
, sb
->len
+ len
);
230 void strbuf_expand(struct strbuf
*sb
, const char *format
, expand_fn_t fn
,
237 percent
= strchrnul(format
, '%');
238 strbuf_add(sb
, format
, percent
- format
);
241 format
= percent
+ 1;
243 if (*format
== '%') {
244 strbuf_addch(sb
, '%');
249 consumed
= fn(sb
, format
, context
);
253 strbuf_addch(sb
, '%');
257 size_t strbuf_expand_dict_cb(struct strbuf
*sb
, const char *placeholder
,
260 struct strbuf_expand_dict_entry
*e
= context
;
263 for (; e
->placeholder
&& (len
= strlen(e
->placeholder
)); e
++) {
264 if (!strncmp(placeholder
, e
->placeholder
, len
)) {
266 strbuf_addstr(sb
, e
->value
);
273 void strbuf_addbuf_percentquote(struct strbuf
*dst
, const struct strbuf
*src
)
275 int i
, len
= src
->len
;
277 for (i
= 0; i
< len
; i
++) {
278 if (src
->buf
[i
] == '%')
279 strbuf_addch(dst
, '%');
280 strbuf_addch(dst
, src
->buf
[i
]);
284 size_t strbuf_fread(struct strbuf
*sb
, size_t size
, FILE *f
)
287 size_t oldalloc
= sb
->alloc
;
289 strbuf_grow(sb
, size
);
290 res
= fread(sb
->buf
+ sb
->len
, 1, size
, f
);
292 strbuf_setlen(sb
, sb
->len
+ res
);
293 else if (oldalloc
== 0)
298 ssize_t
strbuf_read(struct strbuf
*sb
, int fd
, size_t hint
)
300 size_t oldlen
= sb
->len
;
301 size_t oldalloc
= sb
->alloc
;
303 strbuf_grow(sb
, hint
? hint
: 8192);
307 cnt
= xread(fd
, sb
->buf
+ sb
->len
, sb
->alloc
- sb
->len
- 1);
312 strbuf_setlen(sb
, oldlen
);
318 strbuf_grow(sb
, 8192);
321 sb
->buf
[sb
->len
] = '\0';
322 return sb
->len
- oldlen
;
325 #define STRBUF_MAXLINK (2*PATH_MAX)
327 int strbuf_readlink(struct strbuf
*sb
, const char *path
, size_t hint
)
329 size_t oldalloc
= sb
->alloc
;
334 while (hint
< STRBUF_MAXLINK
) {
337 strbuf_grow(sb
, hint
);
338 len
= readlink(path
, sb
->buf
, hint
);
342 } else if (len
< hint
) {
343 strbuf_setlen(sb
, len
);
347 /* .. the buffer was too small - try again */
355 int strbuf_getwholeline(struct strbuf
*sb
, FILE *fp
, int term
)
363 while ((ch
= fgetc(fp
)) != EOF
) {
365 sb
->buf
[sb
->len
++] = ch
;
369 if (ch
== EOF
&& sb
->len
== 0)
372 sb
->buf
[sb
->len
] = '\0';
376 int strbuf_getline(struct strbuf
*sb
, FILE *fp
, int term
)
378 if (strbuf_getwholeline(sb
, fp
, term
))
380 if (sb
->buf
[sb
->len
-1] == term
)
381 strbuf_setlen(sb
, sb
->len
-1);
385 int strbuf_getwholeline_fd(struct strbuf
*sb
, int fd
, int term
)
391 ssize_t len
= xread(fd
, &ch
, 1);
394 strbuf_addch(sb
, ch
);
401 int strbuf_read_file(struct strbuf
*sb
, const char *path
, size_t hint
)
405 fd
= open(path
, O_RDONLY
);
408 len
= strbuf_read(sb
, fd
, hint
);
416 void strbuf_add_lines(struct strbuf
*out
, const char *prefix
,
417 const char *buf
, size_t size
)
420 const char *next
= memchr(buf
, '\n', size
);
421 next
= next
? (next
+ 1) : (buf
+ size
);
422 strbuf_addstr(out
, prefix
);
423 strbuf_add(out
, buf
, next
- buf
);
427 strbuf_complete_line(out
);
430 static int is_rfc3986_reserved(char ch
)
433 case '!': case '*': case '\'': case '(': case ')': case ';':
434 case ':': case '@': case '&': case '=': case '+': case '$':
435 case ',': case '/': case '?': case '#': case '[': case ']':
441 static int is_rfc3986_unreserved(char ch
)
443 return isalnum(ch
) ||
444 ch
== '-' || ch
== '_' || ch
== '.' || ch
== '~';
447 static void strbuf_add_urlencode(struct strbuf
*sb
, const char *s
, size_t len
,
450 strbuf_grow(sb
, len
);
453 if (is_rfc3986_unreserved(ch
) ||
454 (!reserved
&& is_rfc3986_reserved(ch
)))
455 strbuf_addch(sb
, ch
);
457 strbuf_addf(sb
, "%%%02x", ch
);
461 void strbuf_addstr_urlencode(struct strbuf
*sb
, const char *s
,
464 strbuf_add_urlencode(sb
, s
, strlen(s
), reserved
);
467 int printf_ln(const char *fmt
, ...)
472 ret
= vprintf(fmt
, ap
);
474 if (ret
< 0 || putchar('\n') == EOF
)
479 int fprintf_ln(FILE *fp
, const char *fmt
, ...)
484 ret
= vfprintf(fp
, fmt
, ap
);
486 if (ret
< 0 || putc('\n', fp
) == EOF
)