blob: 3d2189a7f648dcba44e85aa1b2047b00b3f871df [file] [log] [blame]
Elijah Newrene93fc5d2023-04-11 00:41:50 -07001#include "git-compat-util.h"
Elijah Newrenf394e092023-03-21 06:25:54 +00002#include "gettext.h"
Calvin Wand88e8102023-09-29 14:20:48 -07003#include "hex-ll.h"
Calvin Wan16b171f2023-06-06 19:48:38 +00004#include "strbuf.h"
Elijah Newrenf6f77552018-04-19 10:58:08 -07005#include "string-list.h"
Jeff Kingd4241f52014-05-22 05:30:14 -04006#include "utf8.h"
Ævar Arnfjörð Bjarmason88c7b4c2022-02-16 09:14:02 +01007#include "date.h"
Junio C Hamanod1df5742005-04-25 18:26:45 -07008
Christian Couder95662312013-12-01 08:49:16 +01009int starts_with(const char *str, const char *prefix)
10{
11 for (; ; str++, prefix++)
12 if (!*prefix)
13 return 1;
14 else if (*str != *prefix)
15 return 0;
16}
17
Lars Schneider66b8af32018-03-09 18:35:29 +010018int istarts_with(const char *str, const char *prefix)
19{
20 for (; ; str++, prefix++)
21 if (!*prefix)
22 return 1;
23 else if (tolower(*str) != tolower(*prefix))
24 return 0;
25}
26
Jeff King2ec225d2024-03-12 05:17:39 -040027int starts_with_mem(const char *str, size_t len, const char *prefix)
28{
29 const char *end = str + len;
30 for (; ; str++, prefix++) {
31 if (!*prefix)
32 return 1;
33 else if (str == end || *str != *prefix)
34 return 0;
35 }
36}
37
Christian Couderafaef552017-12-09 21:40:07 +010038int skip_to_optional_arg_default(const char *str, const char *prefix,
39 const char **arg, const char *def)
40{
41 const char *p;
42
43 if (!skip_prefix(str, prefix, &p))
44 return 0;
45
46 if (!*p) {
47 if (arg)
48 *arg = def;
49 return 1;
50 }
51
52 if (*p != '=')
53 return 0;
54
55 if (arg)
56 *arg = p + 1;
57 return 1;
58}
59
Pierre Habouzitb315c5c2007-09-27 12:58:23 +020060/*
61 * Used as the default ->buf value, so that people can always assume
62 * buf is non NULL and ->buf is NUL terminated even for a freshly
63 * initialized strbuf.
64 */
65char strbuf_slopbuf[1];
66
Pierre Habouzit917c9a72007-09-15 15:56:50 +020067void strbuf_init(struct strbuf *sb, size_t hint)
68{
Ævar Arnfjörð Bjarmason5726a6b2021-07-01 12:51:26 +020069 struct strbuf blank = STRBUF_INIT;
70 memcpy(sb, &blank, sizeof(*sb));
Thomas Rast8c74ef12011-08-29 23:16:12 +020071 if (hint)
Pierre Habouzitf1696ee2007-09-10 12:35:04 +020072 strbuf_grow(sb, hint);
Junio C Hamanod1df5742005-04-25 18:26:45 -070073}
74
Pierre Habouzit917c9a72007-09-15 15:56:50 +020075void strbuf_release(struct strbuf *sb)
76{
Pierre Habouzitb315c5c2007-09-27 12:58:23 +020077 if (sb->alloc) {
78 free(sb->buf);
79 strbuf_init(sb, 0);
80 }
Pierre Habouzitb449f4c2007-09-06 13:20:05 +020081}
82
Pierre Habouzitb315c5c2007-09-27 12:58:23 +020083char *strbuf_detach(struct strbuf *sb, size_t *sz)
Pierre Habouzit917c9a72007-09-15 15:56:50 +020084{
Jeff King08ad56f2012-10-18 06:00:12 -040085 char *res;
86 strbuf_grow(sb, 0);
87 res = sb->buf;
Pierre Habouzitb315c5c2007-09-27 12:58:23 +020088 if (sz)
89 *sz = sb->len;
Pierre Habouzitf1696ee2007-09-10 12:35:04 +020090 strbuf_init(sb, 0);
Pierre Habouzitb449f4c2007-09-06 13:20:05 +020091 return res;
Junio C Hamanod1df5742005-04-25 18:26:45 -070092}
93
Pierre Habouzit917c9a72007-09-15 15:56:50 +020094void strbuf_attach(struct strbuf *sb, void *buf, size_t len, size_t alloc)
95{
96 strbuf_release(sb);
97 sb->buf = buf;
98 sb->len = len;
99 sb->alloc = alloc;
100 strbuf_grow(sb, 0);
101 sb->buf[sb->len] = '\0';
102}
103
104void strbuf_grow(struct strbuf *sb, size_t extra)
105{
Thomas Rast8c74ef12011-08-29 23:16:12 +0200106 int new_buf = !sb->alloc;
Jonathan Nieder1368f652010-10-10 21:59:26 -0500107 if (unsigned_add_overflows(extra, 1) ||
108 unsigned_add_overflows(sb->len, extra + 1))
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200109 die("you want to use way too much memory");
Thomas Rast8c74ef12011-08-29 23:16:12 +0200110 if (new_buf)
Pierre Habouzitb315c5c2007-09-27 12:58:23 +0200111 sb->buf = NULL;
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200112 ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);
Thomas Rast8c74ef12011-08-29 23:16:12 +0200113 if (new_buf)
114 sb->buf[0] = '\0';
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200115}
116
Lukas Sandströmeacd6dc2008-07-13 20:29:18 +0200117void strbuf_trim(struct strbuf *sb)
118{
Brian Gesiak3bb55e82014-04-30 17:58:06 +0900119 strbuf_rtrim(sb);
120 strbuf_ltrim(sb);
Lukas Sandströmeacd6dc2008-07-13 20:29:18 +0200121}
Nguyễn Thái Ngọc Duyc64a8d22018-02-12 16:49:37 +0700122
Pierre Habouzitf1696ee2007-09-10 12:35:04 +0200123void strbuf_rtrim(struct strbuf *sb)
124{
125 while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
126 sb->len--;
127 sb->buf[sb->len] = '\0';
128}
129
Nguyễn Thái Ngọc Duyc64a8d22018-02-12 16:49:37 +0700130void strbuf_trim_trailing_dir_sep(struct strbuf *sb)
131{
132 while (sb->len > 0 && is_dir_sep((unsigned char)sb->buf[sb->len - 1]))
133 sb->len--;
134 sb->buf[sb->len] = '\0';
135}
136
Pratik Karkif9573622018-08-08 20:51:16 +0545137void strbuf_trim_trailing_newline(struct strbuf *sb)
138{
139 if (sb->len > 0 && sb->buf[sb->len - 1] == '\n') {
140 if (--sb->len > 0 && sb->buf[sb->len - 1] == '\r')
141 --sb->len;
142 sb->buf[sb->len] = '\0';
143 }
144}
145
Lukas Sandströmeacd6dc2008-07-13 20:29:18 +0200146void strbuf_ltrim(struct strbuf *sb)
147{
148 char *b = sb->buf;
149 while (sb->len > 0 && isspace(*b)) {
150 b++;
151 sb->len--;
152 }
153 memmove(sb->buf, b, sb->len);
154 sb->buf[sb->len] = '\0';
155}
156
Jeff Kingd4241f52014-05-22 05:30:14 -0400157int strbuf_reencode(struct strbuf *sb, const char *from, const char *to)
158{
159 char *out;
Jeff Kingc7d017d2018-07-24 06:50:33 -0400160 size_t len;
Jeff Kingd4241f52014-05-22 05:30:14 -0400161
162 if (same_encoding(from, to))
163 return 0;
164
165 out = reencode_string_len(sb->buf, sb->len, to, from, &len);
166 if (!out)
167 return -1;
168
169 strbuf_attach(sb, out, len, len);
170 return 0;
171}
172
Jeff Kingffb20ce2014-05-23 16:03:47 -0400173void strbuf_tolower(struct strbuf *sb)
174{
175 char *p = sb->buf, *end = sb->buf + sb->len;
176 for (; p < end; p++)
177 *p = tolower(*p);
178}
179
Michael Haggerty17b73dc2012-11-04 07:46:53 +0100180struct strbuf **strbuf_split_buf(const char *str, size_t slen,
181 int terminator, int max)
Lukas Sandströmeacd6dc2008-07-13 20:29:18 +0200182{
Michael Haggertyb8c2c1f2012-11-04 07:46:51 +0100183 struct strbuf **ret = NULL;
184 size_t nr = 0, alloc = 0;
Lukas Sandströmeacd6dc2008-07-13 20:29:18 +0200185 struct strbuf *t;
186
Michael Haggerty1173bb32012-11-04 07:46:52 +0100187 while (slen) {
188 int len = slen;
189 if (max <= 0 || nr + 1 < max) {
Michael Haggerty17b73dc2012-11-04 07:46:53 +0100190 const char *end = memchr(str, terminator, slen);
Michael Haggerty1173bb32012-11-04 07:46:52 +0100191 if (end)
192 len = end - str + 1;
193 }
Lukas Sandströmeacd6dc2008-07-13 20:29:18 +0200194 t = xmalloc(sizeof(struct strbuf));
195 strbuf_init(t, len);
Michael Haggerty1173bb32012-11-04 07:46:52 +0100196 strbuf_add(t, str, len);
Michael Haggertyb8c2c1f2012-11-04 07:46:51 +0100197 ALLOC_GROW(ret, nr + 2, alloc);
198 ret[nr++] = t;
Michael Haggerty1173bb32012-11-04 07:46:52 +0100199 str += len;
200 slen -= len;
Lukas Sandströmeacd6dc2008-07-13 20:29:18 +0200201 }
Michael Haggertyb8c2c1f2012-11-04 07:46:51 +0100202 ALLOC_GROW(ret, nr + 1, alloc); /* In case string was empty */
203 ret[nr] = NULL;
Lukas Sandströmeacd6dc2008-07-13 20:29:18 +0200204 return ret;
205}
206
Elijah Newrenf6f77552018-04-19 10:58:08 -0700207void strbuf_add_separated_string_list(struct strbuf *str,
208 const char *sep,
209 struct string_list *slist)
210{
211 struct string_list_item *item;
212 int sep_needed = 0;
213
214 for_each_string_list_item(item, slist) {
215 if (sep_needed)
216 strbuf_addstr(str, sep);
217 strbuf_addstr(str, item->string);
218 sep_needed = 1;
219 }
220}
221
Lukas Sandströmeacd6dc2008-07-13 20:29:18 +0200222void strbuf_list_free(struct strbuf **sbs)
223{
224 struct strbuf **s = sbs;
225
Andrzej Huntf3a96802021-04-25 14:16:16 +0000226 if (!s)
227 return;
Lukas Sandströmeacd6dc2008-07-13 20:29:18 +0200228 while (*s) {
229 strbuf_release(*s);
230 free(*s++);
231 }
232 free(sbs);
233}
234
Lukas Sandström9b200fd2008-07-13 20:28:24 +0200235int strbuf_cmp(const struct strbuf *a, const struct strbuf *b)
Pierre Habouzit45f66f62007-09-24 11:25:03 +0200236{
Jeff King26114c02018-07-24 06:51:08 -0400237 size_t len = a->len < b->len ? a->len: b->len;
Alex Riesen8f024652009-03-19 23:27:32 +0100238 int cmp = memcmp(a->buf, b->buf, len);
239 if (cmp)
240 return cmp;
241 return a->len < b->len ? -1: a->len != b->len;
Pierre Habouzit45f66f62007-09-24 11:25:03 +0200242}
243
Pierre Habouzit917c9a72007-09-15 15:56:50 +0200244void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
245 const void *data, size_t dlen)
246{
Jonathan Nieder1368f652010-10-10 21:59:26 -0500247 if (unsigned_add_overflows(pos, len))
Pierre Habouzit917c9a72007-09-15 15:56:50 +0200248 die("you want to use way too much memory");
249 if (pos > sb->len)
250 die("`pos' is too far after the end of the buffer");
251 if (pos + len > sb->len)
252 die("`pos + len' is too far after the end of the buffer");
253
254 if (dlen >= len)
255 strbuf_grow(sb, dlen - len);
256 memmove(sb->buf + pos + dlen,
257 sb->buf + pos + len,
258 sb->len - pos - len);
259 memcpy(sb->buf + pos, data, dlen);
260 strbuf_setlen(sb, sb->len + dlen - len);
261}
262
Pierre Habouzitc76689d2007-09-20 00:42:12 +0200263void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len)
264{
265 strbuf_splice(sb, pos, 0, data, len);
266}
267
Paul-Sebastian Ungureanu5ef264d2019-02-25 23:16:07 +0000268void strbuf_vinsertf(struct strbuf *sb, size_t pos, const char *fmt, va_list ap)
269{
270 int len, len2;
271 char save;
272 va_list cp;
273
274 if (pos > sb->len)
275 die("`pos' is too far after the end of the buffer");
276 va_copy(cp, ap);
277 len = vsnprintf(sb->buf + sb->len, 0, fmt, cp);
278 va_end(cp);
279 if (len < 0)
René Scharfe0283cd52024-04-21 14:40:28 +0200280 die(_("unable to format message: %s"), fmt);
Paul-Sebastian Ungureanu5ef264d2019-02-25 23:16:07 +0000281 if (!len)
282 return; /* nothing to do */
283 if (unsigned_add_overflows(sb->len, len))
284 die("you want to use way too much memory");
285 strbuf_grow(sb, len);
286 memmove(sb->buf + pos + len, sb->buf + pos, sb->len - pos);
287 /* vsnprintf() will append a NUL, overwriting one of our characters */
288 save = sb->buf[pos + len];
289 len2 = vsnprintf(sb->buf + pos, len + 1, fmt, ap);
290 sb->buf[pos + len] = save;
291 if (len2 != len)
292 BUG("your vsnprintf is broken (returns inconsistent lengths)");
293 strbuf_setlen(sb, sb->len + len);
294}
295
296void strbuf_insertf(struct strbuf *sb, size_t pos, const char *fmt, ...)
297{
298 va_list ap;
299 va_start(ap, fmt);
300 strbuf_vinsertf(sb, pos, fmt, ap);
301 va_end(ap);
302}
303
Pierre Habouzitc76689d2007-09-20 00:42:12 +0200304void strbuf_remove(struct strbuf *sb, size_t pos, size_t len)
305{
René Scharfea8342a42016-09-13 18:40:22 +0200306 strbuf_splice(sb, pos, len, "", 0);
Pierre Habouzitc76689d2007-09-20 00:42:12 +0200307}
308
Pierre Habouzit917c9a72007-09-15 15:56:50 +0200309void strbuf_add(struct strbuf *sb, const void *data, size_t len)
310{
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200311 strbuf_grow(sb, len);
312 memcpy(sb->buf + sb->len, data, len);
313 strbuf_setlen(sb, sb->len + len);
314}
315
Ghanshyam Thakkara70f8f12024-05-29 13:30:29 +0530316void strbuf_addstrings(struct strbuf *sb, const char *s, size_t n)
317{
318 size_t len = strlen(s);
319
320 strbuf_grow(sb, st_mult(len, n));
321 for (size_t i = 0; i < n; i++)
322 strbuf_add(sb, s, len);
323}
324
René Scharfe31471ba2016-07-21 18:46:44 +0200325void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2)
326{
327 strbuf_grow(sb, sb2->len);
328 memcpy(sb->buf + sb->len, sb2->buf, sb2->len);
329 strbuf_setlen(sb, sb->len + sb2->len);
330}
331
Paul-Sebastian Ungureanue71c4a82019-02-25 23:16:06 +0000332const char *strbuf_join_argv(struct strbuf *buf,
333 int argc, const char **argv, char delim)
334{
335 if (!argc)
336 return buf->buf;
337
338 strbuf_addstr(buf, *argv);
339 while (--argc) {
340 strbuf_addch(buf, delim);
341 strbuf_addstr(buf, *(++argv));
342 }
343
344 return buf->buf;
345}
346
René Scharfed07235a2014-09-07 09:03:32 +0200347void strbuf_addchars(struct strbuf *sb, int c, size_t n)
348{
349 strbuf_grow(sb, n);
350 memset(sb->buf + sb->len, c, n);
351 strbuf_setlen(sb, sb->len + n);
352}
353
Pierre Habouzit917c9a72007-09-15 15:56:50 +0200354void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
355{
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200356 va_list ap;
Jeff Kingebeb6092011-02-25 23:08:53 -0600357 va_start(ap, fmt);
358 strbuf_vaddf(sb, fmt, ap);
359 va_end(ap);
360}
361
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100362static void add_lines(struct strbuf *out,
Jeff Kingdb7f9302024-03-12 05:17:10 -0400363 const char *prefix,
364 const char *buf, size_t size,
365 int space_after_prefix)
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100366{
367 while (size) {
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100368 const char *next = memchr(buf, '\n', size);
369 next = next ? (next + 1) : (buf + size);
370
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100371 strbuf_addstr(out, prefix);
Jeff Kingdb7f9302024-03-12 05:17:10 -0400372 if (space_after_prefix && buf[0] != '\n' && buf[0] != '\t')
373 strbuf_addch(out, ' ');
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100374 strbuf_add(out, buf, next - buf);
375 size -= next - buf;
376 buf = next;
377 }
378 strbuf_complete_line(out);
379}
380
Calvin Wan787cb8a2023-06-06 19:48:43 +0000381void strbuf_add_commented_lines(struct strbuf *out, const char *buf,
Jeff Kinga1bb1462024-03-12 05:17:32 -0400382 size_t size, const char *comment_prefix)
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100383{
Jeff Kinga1bb1462024-03-12 05:17:32 -0400384 add_lines(out, comment_prefix, buf, size, 1);
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100385}
386
Jeff King3a35d962024-03-12 05:17:29 -0400387void strbuf_commented_addf(struct strbuf *sb, const char *comment_prefix,
Calvin Wan787cb8a2023-06-06 19:48:43 +0000388 const char *fmt, ...)
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100389{
390 va_list params;
391 struct strbuf buf = STRBUF_INIT;
392 int incomplete_line = sb->len && sb->buf[sb->len - 1] != '\n';
393
394 va_start(params, fmt);
395 strbuf_vaddf(&buf, fmt, params);
396 va_end(params);
397
Jeff Kinga1bb1462024-03-12 05:17:32 -0400398 strbuf_add_commented_lines(sb, buf.buf, buf.len, comment_prefix);
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100399 if (incomplete_line)
400 sb->buf[--sb->len] = '\0';
401
402 strbuf_release(&buf);
403}
404
Jeff Kingebeb6092011-02-25 23:08:53 -0600405void strbuf_vaddf(struct strbuf *sb, const char *fmt, va_list ap)
406{
407 int len;
408 va_list cp;
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200409
Shawn O. Pearcef141bd82007-11-13 03:22:44 -0500410 if (!strbuf_avail(sb))
411 strbuf_grow(sb, 64);
Jeff Kingebeb6092011-02-25 23:08:53 -0600412 va_copy(cp, ap);
413 len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, cp);
414 va_end(cp);
Shawn O. Pearcef141bd82007-11-13 03:22:44 -0500415 if (len < 0)
René Scharfe0283cd52024-04-21 14:40:28 +0200416 die(_("unable to format message: %s"), fmt);
Pierre Habouzitf1696ee2007-09-10 12:35:04 +0200417 if (len > strbuf_avail(sb)) {
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200418 strbuf_grow(sb, len);
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200419 len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
Jeff Kingebeb6092011-02-25 23:08:53 -0600420 if (len > strbuf_avail(sb))
Johannes Schindelin033abf92018-05-02 11:38:39 +0200421 BUG("your vsnprintf is broken (insatiable)");
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200422 }
423 strbuf_setlen(sb, sb->len + len);
Junio C Hamanod1df5742005-04-25 18:26:45 -0700424}
425
René Scharfe44ccb332023-06-17 22:41:44 +0200426int strbuf_expand_step(struct strbuf *sb, const char **formatp)
René Scharfecde75e52007-11-09 01:49:42 +0100427{
René Scharfe44ccb332023-06-17 22:41:44 +0200428 const char *format = *formatp;
429 const char *percent = strchrnul(format, '%');
René Scharfecde75e52007-11-09 01:49:42 +0100430
René Scharfe44ccb332023-06-17 22:41:44 +0200431 strbuf_add(sb, format, percent - format);
432 if (!*percent)
433 return 0;
434 *formatp = percent + 1;
435 return 1;
René Scharfecde75e52007-11-09 01:49:42 +0100436}
437
René Scharfe4416b862023-06-17 22:44:00 +0200438size_t strbuf_expand_literal(struct strbuf *sb, const char *placeholder)
Anders Waldenborgfd2015b2019-01-28 22:33:36 +0100439{
440 int ch;
441
442 switch (placeholder[0]) {
443 case 'n': /* newline */
444 strbuf_addch(sb, '\n');
445 return 1;
446 case 'x':
447 /* %x00 == NUL, %x0a == LF, etc. */
448 ch = hex2chr(placeholder + 1);
449 if (ch < 0)
450 return 0;
451 strbuf_addch(sb, ch);
452 return 3;
453 }
454 return 0;
455}
456
René Scharfee36091a2024-03-24 12:19:40 +0100457void strbuf_expand_bad_format(const char *format, const char *command)
458{
459 const char *end;
460
461 if (*format != '(')
462 /* TRANSLATORS: The first %s is a command like "ls-tree". */
463 die(_("bad %s format: element '%s' does not start with '('"),
464 command, format);
465
466 end = strchr(format + 1, ')');
467 if (!end)
468 /* TRANSLATORS: The first %s is a command like "ls-tree". */
469 die(_("bad %s format: element '%s' does not end in ')'"),
470 command, format);
471
472 /* TRANSLATORS: %s is a command like "ls-tree". */
473 die(_("bad %s format: %%%.*s"),
474 command, (int)(end - format + 1), format);
475}
476
Jeff King361df5d2010-01-13 12:36:42 -0500477void strbuf_addbuf_percentquote(struct strbuf *dst, const struct strbuf *src)
478{
Jeff King26114c02018-07-24 06:51:08 -0400479 size_t i, len = src->len;
Jeff King361df5d2010-01-13 12:36:42 -0500480
481 for (i = 0; i < len; i++) {
482 if (src->buf[i] == '%')
483 strbuf_addch(dst, '%');
484 strbuf_addch(dst, src->buf[i]);
485 }
486}
487
brian m. carlsonb44d0112020-04-27 01:18:08 +0000488#define URL_UNSAFE_CHARS " <>\"%{}|\\^`:?#[]@!$&'()*+,;="
brian m. carlson46fd7b32020-02-20 02:24:13 +0000489
brian m. carlsonb44d0112020-04-27 01:18:08 +0000490void strbuf_add_percentencode(struct strbuf *dst, const char *src, int flags)
brian m. carlson46fd7b32020-02-20 02:24:13 +0000491{
492 size_t i, len = strlen(src);
493
494 for (i = 0; i < len; i++) {
495 unsigned char ch = src[i];
brian m. carlsonb44d0112020-04-27 01:18:08 +0000496 if (ch <= 0x1F || ch >= 0x7F ||
497 (ch == '/' && (flags & STRBUF_ENCODE_SLASH)) ||
498 strchr(URL_UNSAFE_CHARS, ch))
brian m. carlson46fd7b32020-02-20 02:24:13 +0000499 strbuf_addf(dst, "%%%02X", (unsigned char)ch);
500 else
501 strbuf_addch(dst, ch);
502 }
503}
504
Pierre Habouzit917c9a72007-09-15 15:56:50 +0200505size_t strbuf_fread(struct strbuf *sb, size_t size, FILE *f)
506{
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200507 size_t res;
René Scharfe2fc64702009-01-06 21:41:14 +0100508 size_t oldalloc = sb->alloc;
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200509
510 strbuf_grow(sb, size);
511 res = fread(sb->buf + sb->len, 1, size, f);
René Scharfe2fc64702009-01-06 21:41:14 +0100512 if (res > 0)
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200513 strbuf_setlen(sb, sb->len + res);
Roel Kluin6651c3f2009-06-22 18:42:33 +0200514 else if (oldalloc == 0)
René Scharfe2fc64702009-01-06 21:41:14 +0100515 strbuf_release(sb);
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200516 return res;
517}
518
Pierre Habouzitf1696ee2007-09-10 12:35:04 +0200519ssize_t strbuf_read(struct strbuf *sb, int fd, size_t hint)
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200520{
521 size_t oldlen = sb->len;
René Scharfe2fc64702009-01-06 21:41:14 +0100522 size_t oldalloc = sb->alloc;
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200523
Pierre Habouzitf1696ee2007-09-10 12:35:04 +0200524 strbuf_grow(sb, hint ? hint : 8192);
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200525 for (;;) {
Jim Hill3ebbd002015-05-31 11:16:45 -0700526 ssize_t want = sb->alloc - sb->len - 1;
527 ssize_t got = read_in_full(fd, sb->buf + sb->len, want);
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200528
Jim Hill3ebbd002015-05-31 11:16:45 -0700529 if (got < 0) {
René Scharfe2fc64702009-01-06 21:41:14 +0100530 if (oldalloc == 0)
531 strbuf_release(sb);
532 else
533 strbuf_setlen(sb, oldlen);
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200534 return -1;
535 }
Jim Hill3ebbd002015-05-31 11:16:45 -0700536 sb->len += got;
537 if (got < want)
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200538 break;
Pierre Habouzitf1696ee2007-09-10 12:35:04 +0200539 strbuf_grow(sb, 8192);
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200540 }
541
542 sb->buf[sb->len] = '\0';
543 return sb->len - oldlen;
Junio C Hamanod1df5742005-04-25 18:26:45 -0700544}
545
Stefan Bellerb4e04fb2015-12-15 16:04:08 -0800546ssize_t strbuf_read_once(struct strbuf *sb, int fd, size_t hint)
547{
René Scharfec3ff8f62017-12-07 21:51:26 +0100548 size_t oldalloc = sb->alloc;
Stefan Bellerb4e04fb2015-12-15 16:04:08 -0800549 ssize_t cnt;
550
551 strbuf_grow(sb, hint ? hint : 8192);
552 cnt = xread(fd, sb->buf + sb->len, sb->alloc - sb->len - 1);
553 if (cnt > 0)
554 strbuf_setlen(sb, sb->len + cnt);
René Scharfec3ff8f62017-12-07 21:51:26 +0100555 else if (oldalloc == 0)
556 strbuf_release(sb);
Stefan Bellerb4e04fb2015-12-15 16:04:08 -0800557 return cnt;
558}
559
Stefan Beller2dac9b52016-02-29 18:07:15 -0800560ssize_t strbuf_write(struct strbuf *sb, FILE *f)
561{
562 return sb->len ? fwrite(sb->buf, 1, sb->len, f) : 0;
563}
564
Linus Torvaldsb11b7e12008-12-17 09:36:40 -0800565#define STRBUF_MAXLINK (2*PATH_MAX)
566
567int strbuf_readlink(struct strbuf *sb, const char *path, size_t hint)
568{
René Scharfe2fc64702009-01-06 21:41:14 +0100569 size_t oldalloc = sb->alloc;
570
Linus Torvaldsb11b7e12008-12-17 09:36:40 -0800571 if (hint < 32)
572 hint = 32;
573
574 while (hint < STRBUF_MAXLINK) {
Jeff Kingf3e76ed2018-07-24 06:51:25 -0400575 ssize_t len;
Linus Torvaldsb11b7e12008-12-17 09:36:40 -0800576
577 strbuf_grow(sb, hint);
578 len = readlink(path, sb->buf, hint);
579 if (len < 0) {
580 if (errno != ERANGE)
581 break;
582 } else if (len < hint) {
583 strbuf_setlen(sb, len);
584 return 0;
585 }
586
587 /* .. the buffer was too small - try again */
588 hint *= 2;
589 }
René Scharfe2fc64702009-01-06 21:41:14 +0100590 if (oldalloc == 0)
591 strbuf_release(sb);
Linus Torvaldsb11b7e12008-12-17 09:36:40 -0800592 return -1;
593}
594
René Scharfef22a76e2014-07-28 20:24:29 +0200595int strbuf_getcwd(struct strbuf *sb)
596{
597 size_t oldalloc = sb->alloc;
598 size_t guessed_len = 128;
599
600 for (;; guessed_len *= 2) {
601 strbuf_grow(sb, guessed_len);
602 if (getcwd(sb->buf, sb->alloc)) {
603 strbuf_setlen(sb, strlen(sb->buf));
604 return 0;
605 }
René Scharfea54e9382017-03-26 15:43:50 +0200606
607 /*
608 * If getcwd(3) is implemented as a syscall that falls
609 * back to a regular lookup using readdir(3) etc. then
610 * we may be able to avoid EACCES by providing enough
611 * space to the syscall as it's not necessarily bound
612 * to the same restrictions as the fallback.
613 */
614 if (errno == EACCES && guessed_len < PATH_MAX)
615 continue;
616
René Scharfef22a76e2014-07-28 20:24:29 +0200617 if (errno != ERANGE)
618 break;
619 }
620 if (oldalloc == 0)
621 strbuf_release(sb);
622 else
623 strbuf_reset(sb);
624 return -1;
625}
626
Jeff King0cc30e02015-04-16 05:01:38 -0400627#ifdef HAVE_GETDELIM
628int strbuf_getwholeline(struct strbuf *sb, FILE *fp, int term)
629{
630 ssize_t r;
631
632 if (feof(fp))
633 return EOF;
634
635 strbuf_reset(sb);
636
637 /* Translate slopbuf to NULL, as we cannot call realloc on it */
638 if (!sb->alloc)
639 sb->buf = NULL;
René Scharfe642956c2017-08-10 22:56:40 +0200640 errno = 0;
Jeff King0cc30e02015-04-16 05:01:38 -0400641 r = getdelim(&sb->buf, &sb->alloc, term, fp);
642
643 if (r > 0) {
644 sb->len = r;
645 return 0;
646 }
647 assert(r == -1);
648
649 /*
650 * Normally we would have called xrealloc, which will try to free
651 * memory and recover. But we have no way to tell getdelim() to do so.
652 * Worse, we cannot try to recover ENOMEM ourselves, because we have
653 * no idea how many bytes were read by getdelim.
654 *
655 * Dying here is reasonable. It mirrors what xrealloc would do on
656 * catastrophic memory failure. We skip the opportunity to free pack
657 * memory and retry, but that's unlikely to help for a malloc small
658 * enough to hold a single line of input, anyway.
659 */
660 if (errno == ENOMEM)
661 die("Out of memory, getdelim failed");
662
Jeff Kingb7090432016-03-05 13:43:30 -0500663 /*
664 * Restore strbuf invariants; if getdelim left us with a NULL pointer,
665 * we can just re-init, but otherwise we should make sure that our
666 * length is empty, and that the result is NUL-terminated.
667 */
Jeff King0cc30e02015-04-16 05:01:38 -0400668 if (!sb->buf)
669 strbuf_init(sb, 0);
Jeff Kingb7090432016-03-05 13:43:30 -0500670 else
671 strbuf_reset(sb);
Jeff King0cc30e02015-04-16 05:01:38 -0400672 return EOF;
673}
674#else
Brandon Caseyc7e4f0d2009-08-04 22:31:56 -0500675int strbuf_getwholeline(struct strbuf *sb, FILE *fp, int term)
Pierre Habouzit917c9a72007-09-15 15:56:50 +0200676{
Junio C Hamanod1df5742005-04-25 18:26:45 -0700677 int ch;
Pierre Habouzite6c019d2007-09-17 11:19:04 +0200678
Pierre Habouzite6c019d2007-09-17 11:19:04 +0200679 if (feof(fp))
680 return EOF;
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200681
682 strbuf_reset(sb);
Jeff King82912d12015-04-16 04:49:06 -0400683 flockfile(fp);
684 while ((ch = getc_unlocked(fp)) != EOF) {
Jeff Kingf80c1532015-04-16 04:58:54 -0400685 if (!strbuf_avail(sb))
686 strbuf_grow(sb, 1);
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200687 sb->buf[sb->len++] = ch;
Brandon Caseyc7e4f0d2009-08-04 22:31:56 -0500688 if (ch == term)
689 break;
Junio C Hamanod1df5742005-04-25 18:26:45 -0700690 }
Jeff King82912d12015-04-16 04:49:06 -0400691 funlockfile(fp);
Pierre Habouzite6c019d2007-09-17 11:19:04 +0200692 if (ch == EOF && sb->len == 0)
693 return EOF;
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200694
Pierre Habouzitb449f4c2007-09-06 13:20:05 +0200695 sb->buf[sb->len] = '\0';
Pierre Habouzite6c019d2007-09-17 11:19:04 +0200696 return 0;
Junio C Hamanod1df5742005-04-25 18:26:45 -0700697}
Jeff King0cc30e02015-04-16 05:01:38 -0400698#endif
Kristian Høgsberga9390b92007-09-17 20:06:46 -0400699
Patrick Steinhardtbd021f32020-03-30 15:46:27 +0200700int strbuf_appendwholeline(struct strbuf *sb, FILE *fp, int term)
701{
702 struct strbuf line = STRBUF_INIT;
Patrick Steinhardt94e2aa52024-05-27 13:46:01 +0200703 if (strbuf_getwholeline(&line, fp, term)) {
704 strbuf_release(&line);
Patrick Steinhardtbd021f32020-03-30 15:46:27 +0200705 return EOF;
Patrick Steinhardt94e2aa52024-05-27 13:46:01 +0200706 }
Patrick Steinhardtbd021f32020-03-30 15:46:27 +0200707 strbuf_addbuf(sb, &line);
708 strbuf_release(&line);
709 return 0;
710}
711
Junio C Hamano1a0c8df2016-01-13 18:32:23 -0800712static int strbuf_getdelim(struct strbuf *sb, FILE *fp, int term)
Brandon Caseyc7e4f0d2009-08-04 22:31:56 -0500713{
714 if (strbuf_getwholeline(sb, fp, term))
715 return EOF;
Junio C Hamanodce80bd2016-01-13 15:10:45 -0800716 if (sb->buf[sb->len - 1] == term)
717 strbuf_setlen(sb, sb->len - 1);
Brandon Caseyc7e4f0d2009-08-04 22:31:56 -0500718 return 0;
719}
720
Patrick Steinhardtaf35e562023-06-06 07:19:37 +0200721int strbuf_getdelim_strip_crlf(struct strbuf *sb, FILE *fp, int term)
Junio C Hamanoc8aa9fd2015-10-28 13:17:29 -0700722{
Patrick Steinhardtaf35e562023-06-06 07:19:37 +0200723 if (strbuf_getwholeline(sb, fp, term))
Junio C Hamanoc8aa9fd2015-10-28 13:17:29 -0700724 return EOF;
Patrick Steinhardtaf35e562023-06-06 07:19:37 +0200725 if (term == '\n' && sb->buf[sb->len - 1] == '\n') {
Junio C Hamanoc8aa9fd2015-10-28 13:17:29 -0700726 strbuf_setlen(sb, sb->len - 1);
727 if (sb->len && sb->buf[sb->len - 1] == '\r')
728 strbuf_setlen(sb, sb->len - 1);
729 }
730 return 0;
731}
732
Patrick Steinhardtaf35e562023-06-06 07:19:37 +0200733int strbuf_getline(struct strbuf *sb, FILE *fp)
734{
735 return strbuf_getdelim_strip_crlf(sb, fp, '\n');
736}
737
Junio C Hamano8f309ae2016-01-13 15:31:17 -0800738int strbuf_getline_lf(struct strbuf *sb, FILE *fp)
739{
Junio C Hamano1a0c8df2016-01-13 18:32:23 -0800740 return strbuf_getdelim(sb, fp, '\n');
Junio C Hamano8f309ae2016-01-13 15:31:17 -0800741}
742
743int strbuf_getline_nul(struct strbuf *sb, FILE *fp)
744{
Junio C Hamano1a0c8df2016-01-13 18:32:23 -0800745 return strbuf_getdelim(sb, fp, '\0');
Junio C Hamano8f309ae2016-01-13 15:31:17 -0800746}
747
Thomas Rast5e8617f2012-02-22 20:34:22 +0100748int strbuf_getwholeline_fd(struct strbuf *sb, int fd, int term)
749{
750 strbuf_reset(sb);
751
752 while (1) {
753 char ch;
754 ssize_t len = xread(fd, &ch, 1);
755 if (len <= 0)
756 return EOF;
757 strbuf_addch(sb, ch);
758 if (ch == term)
759 break;
760 }
761 return 0;
762}
763
Michael Haggerty6c8afe42015-07-03 15:59:32 +0200764ssize_t strbuf_read_file(struct strbuf *sb, const char *path, size_t hint)
Kristian Høgsberga9390b92007-09-17 20:06:46 -0400765{
Michael Haggerty6c8afe42015-07-03 15:59:32 +0200766 int fd;
767 ssize_t len;
Jeff King79f0ba12018-02-23 02:00:54 -0500768 int saved_errno;
Kristian Høgsberga9390b92007-09-17 20:06:46 -0400769
770 fd = open(path, O_RDONLY);
771 if (fd < 0)
772 return -1;
Pierre Habouzit387e7e12007-09-27 15:25:55 +0200773 len = strbuf_read(sb, fd, hint);
Jeff King79f0ba12018-02-23 02:00:54 -0500774 saved_errno = errno;
Kristian Høgsberga9390b92007-09-17 20:06:46 -0400775 close(fd);
Jeff King79f0ba12018-02-23 02:00:54 -0500776 if (len < 0) {
777 errno = saved_errno;
Kristian Høgsberga9390b92007-09-17 20:06:46 -0400778 return -1;
Jeff King79f0ba12018-02-23 02:00:54 -0500779 }
Kristian Høgsberga9390b92007-09-17 20:06:46 -0400780
781 return len;
782}
Junio C Hamano895680f2011-11-04 21:06:30 -0700783
784void strbuf_add_lines(struct strbuf *out, const char *prefix,
785 const char *buf, size_t size)
786{
Jeff Kingdb7f9302024-03-12 05:17:10 -0400787 add_lines(out, prefix, buf, size, 0);
Junio C Hamano895680f2011-11-04 21:06:30 -0700788}
Junio C Hamano367d20e2011-12-19 16:05:16 -0800789
Michael Haggerty5963c032012-11-25 12:08:34 +0100790void strbuf_addstr_xml_quoted(struct strbuf *buf, const char *s)
791{
792 while (*s) {
793 size_t len = strcspn(s, "\"<>&");
794 strbuf_add(buf, s, len);
795 s += len;
796 switch (*s) {
797 case '"':
798 strbuf_addstr(buf, "&quot;");
799 break;
800 case '<':
801 strbuf_addstr(buf, "&lt;");
802 break;
803 case '>':
804 strbuf_addstr(buf, "&gt;");
805 break;
806 case '&':
807 strbuf_addstr(buf, "&amp;");
808 break;
809 case 0:
810 return;
811 }
812 s++;
813 }
814}
815
Junio C Hamanoea03a8e2012-09-15 22:43:15 -0700816static void strbuf_add_urlencode(struct strbuf *sb, const char *s, size_t len,
Matthew DeVorec2694952019-06-27 15:54:11 -0700817 char_predicate allow_unencoded_fn)
Jeff Kingc5051162011-12-10 05:34:20 -0500818{
819 strbuf_grow(sb, len);
820 while (len--) {
821 char ch = *s++;
Matthew DeVorec2694952019-06-27 15:54:11 -0700822 if (allow_unencoded_fn(ch))
Jeff Kingc5051162011-12-10 05:34:20 -0500823 strbuf_addch(sb, ch);
824 else
Julien Dusser4c267f22017-12-22 18:24:37 +0100825 strbuf_addf(sb, "%%%02x", (unsigned char)ch);
Jeff Kingc5051162011-12-10 05:34:20 -0500826 }
827}
828
829void strbuf_addstr_urlencode(struct strbuf *sb, const char *s,
Matthew DeVorec2694952019-06-27 15:54:11 -0700830 char_predicate allow_unencoded_fn)
Jeff Kingc5051162011-12-10 05:34:20 -0500831{
Matthew DeVorec2694952019-06-27 15:54:11 -0700832 strbuf_add_urlencode(sb, s, strlen(s), allow_unencoded_fn);
Jeff Kingc5051162011-12-10 05:34:20 -0500833}
Nguyễn Thái Ngọc Duy9a0a30a2012-04-23 19:30:22 +0700834
Dimitriy Ryazantcev8f354a12019-07-02 21:22:48 +0300835static void strbuf_humanise(struct strbuf *buf, off_t bytes,
836 int humanise_rate)
Antoine Pelisse079b5462013-04-10 21:03:23 +0200837{
838 if (bytes > 1 << 30) {
Dimitriy Ryazantcev8f354a12019-07-02 21:22:48 +0300839 strbuf_addf(buf,
840 humanise_rate == 0 ?
841 /* TRANSLATORS: IEC 80000-13:2008 gibibyte */
842 _("%u.%2.2u GiB") :
843 /* TRANSLATORS: IEC 80000-13:2008 gibibyte/second */
844 _("%u.%2.2u GiB/s"),
Jeff King7726d362018-07-24 06:52:29 -0400845 (unsigned)(bytes >> 30),
846 (unsigned)(bytes & ((1 << 30) - 1)) / 10737419);
Antoine Pelisse079b5462013-04-10 21:03:23 +0200847 } else if (bytes > 1 << 20) {
Jeff King7726d362018-07-24 06:52:29 -0400848 unsigned x = bytes + 5243; /* for rounding */
Dimitriy Ryazantcev8f354a12019-07-02 21:22:48 +0300849 strbuf_addf(buf,
850 humanise_rate == 0 ?
851 /* TRANSLATORS: IEC 80000-13:2008 mebibyte */
852 _("%u.%2.2u MiB") :
853 /* TRANSLATORS: IEC 80000-13:2008 mebibyte/second */
854 _("%u.%2.2u MiB/s"),
Antoine Pelisse079b5462013-04-10 21:03:23 +0200855 x >> 20, ((x & ((1 << 20) - 1)) * 100) >> 20);
856 } else if (bytes > 1 << 10) {
Jeff King7726d362018-07-24 06:52:29 -0400857 unsigned x = bytes + 5; /* for rounding */
Dimitriy Ryazantcev8f354a12019-07-02 21:22:48 +0300858 strbuf_addf(buf,
859 humanise_rate == 0 ?
860 /* TRANSLATORS: IEC 80000-13:2008 kibibyte */
861 _("%u.%2.2u KiB") :
862 /* TRANSLATORS: IEC 80000-13:2008 kibibyte/second */
863 _("%u.%2.2u KiB/s"),
Antoine Pelisse079b5462013-04-10 21:03:23 +0200864 x >> 10, ((x & ((1 << 10) - 1)) * 100) >> 10);
865 } else {
Dimitriy Ryazantcev8f354a12019-07-02 21:22:48 +0300866 strbuf_addf(buf,
867 humanise_rate == 0 ?
868 /* TRANSLATORS: IEC 80000-13:2008 byte */
Ævar Arnfjörð Bjarmason6f693252022-03-07 16:27:07 +0100869 Q_("%u byte", "%u bytes", bytes) :
Dimitriy Ryazantcev8f354a12019-07-02 21:22:48 +0300870 /* TRANSLATORS: IEC 80000-13:2008 byte/second */
Ævar Arnfjörð Bjarmason6f693252022-03-07 16:27:07 +0100871 Q_("%u byte/s", "%u bytes/s", bytes),
Dimitriy Ryazantcev8f354a12019-07-02 21:22:48 +0300872 (unsigned)bytes);
Antoine Pelisse079b5462013-04-10 21:03:23 +0200873 }
874}
875
Dimitriy Ryazantcev8f354a12019-07-02 21:22:48 +0300876void strbuf_humanise_bytes(struct strbuf *buf, off_t bytes)
877{
878 strbuf_humanise(buf, bytes, 0);
879}
880
881void strbuf_humanise_rate(struct strbuf *buf, off_t bytes)
882{
883 strbuf_humanise(buf, bytes, 1);
884}
885
Nguyễn Thái Ngọc Duy9a0a30a2012-04-23 19:30:22 +0700886int printf_ln(const char *fmt, ...)
887{
888 int ret;
889 va_list ap;
890 va_start(ap, fmt);
891 ret = vprintf(fmt, ap);
892 va_end(ap);
893 if (ret < 0 || putchar('\n') == EOF)
894 return -1;
895 return ret + 1;
896}
897
898int fprintf_ln(FILE *fp, const char *fmt, ...)
899{
900 int ret;
901 va_list ap;
902 va_start(ap, fmt);
903 ret = vfprintf(fp, fmt, ap);
904 va_end(ap);
905 if (ret < 0 || putc('\n', fp) == EOF)
906 return -1;
907 return ret + 1;
908}
Jeff King88d5a6f2014-05-22 05:44:09 -0400909
910char *xstrdup_tolower(const char *string)
911{
912 char *result;
913 size_t len, i;
914
915 len = strlen(string);
Jeff King3733e692016-02-22 17:44:28 -0500916 result = xmallocz(len);
Jeff King88d5a6f2014-05-22 05:44:09 -0400917 for (i = 0; i < len; i++)
918 result[i] = tolower(string[i]);
Jeff King88d5a6f2014-05-22 05:44:09 -0400919 return result;
920}
Jeff King30a0ddb2014-06-18 16:01:34 -0400921
Lars Schneider13ecb4632018-02-15 16:27:06 +0100922char *xstrdup_toupper(const char *string)
923{
924 char *result;
925 size_t len, i;
926
927 len = strlen(string);
928 result = xmallocz(len);
929 for (i = 0; i < len; i++)
930 result[i] = toupper(string[i]);
Junio C Hamanod1df5742005-04-25 18:26:45 -0700931 return result;
932}
Jeff King30a0ddb2014-06-18 16:01:34 -0400933
934char *xstrvfmt(const char *fmt, va_list ap)
935{
936 struct strbuf buf = STRBUF_INIT;
937 strbuf_vaddf(&buf, fmt, ap);
938 return strbuf_detach(&buf, NULL);
939}
940
941char *xstrfmt(const char *fmt, ...)
942{
943 va_list ap;
944 char *ret;
945
946 va_start(ap, fmt);
947 ret = xstrvfmt(fmt, ap);
948 va_end(ap);
949
950 return ret;
951}
Jeff Kingaa1462c2015-06-25 12:55:45 -0400952
René Scharfec3fbf812017-06-15 14:29:53 +0200953void strbuf_addftime(struct strbuf *sb, const char *fmt, const struct tm *tm,
Ævar Arnfjörð Bjarmason3b702232017-07-01 13:15:47 +0000954 int tz_offset, int suppress_tz_name)
Jeff Kingaa1462c2015-06-25 12:55:45 -0400955{
René Scharfec3fbf812017-06-15 14:29:53 +0200956 struct strbuf munged_fmt = STRBUF_INIT;
Jeff Kinge4f031e2015-06-30 09:26:53 -0400957 size_t hint = 128;
Jeff Kingaa1462c2015-06-25 12:55:45 -0400958 size_t len;
959
Jeff Kinge4f031e2015-06-30 09:26:53 -0400960 if (!*fmt)
961 return;
962
René Scharfec3fbf812017-06-15 14:29:53 +0200963 /*
964 * There is no portable way to pass timezone information to
Jeff King9b591b92021-11-02 07:35:34 -0400965 * strftime, so we handle %z and %Z here. Likewise '%s', because
966 * going back to an epoch time requires knowing the zone.
967 *
968 * Note that tz_offset is in the "[-+]HHMM" decimal form; this is what
969 * we want for %z, but the computation for %s has to convert to number
970 * of seconds.
René Scharfec3fbf812017-06-15 14:29:53 +0200971 */
René Scharfe44ccb332023-06-17 22:41:44 +0200972 while (strbuf_expand_step(&munged_fmt, &fmt)) {
René Scharfe945c7222023-07-16 10:52:33 +0200973 if (skip_prefix(fmt, "%", &fmt))
René Scharfec3fbf812017-06-15 14:29:53 +0200974 strbuf_addstr(&munged_fmt, "%%");
René Scharfe945c7222023-07-16 10:52:33 +0200975 else if (skip_prefix(fmt, "s", &fmt))
Jeff King9b591b92021-11-02 07:35:34 -0400976 strbuf_addf(&munged_fmt, "%"PRItime,
977 (timestamp_t)tm_to_time_t(tm) -
978 3600 * (tz_offset / 100) -
979 60 * (tz_offset % 100));
René Scharfe945c7222023-07-16 10:52:33 +0200980 else if (skip_prefix(fmt, "z", &fmt))
René Scharfec3fbf812017-06-15 14:29:53 +0200981 strbuf_addf(&munged_fmt, "%+05d", tz_offset);
René Scharfe945c7222023-07-16 10:52:33 +0200982 else if (suppress_tz_name && skip_prefix(fmt, "Z", &fmt))
983 ; /* nothing */
984 else
René Scharfec3fbf812017-06-15 14:29:53 +0200985 strbuf_addch(&munged_fmt, '%');
René Scharfec3fbf812017-06-15 14:29:53 +0200986 }
987 fmt = munged_fmt.buf;
988
Jeff Kinge4f031e2015-06-30 09:26:53 -0400989 strbuf_grow(sb, hint);
Jeff Kingaa1462c2015-06-25 12:55:45 -0400990 len = strftime(sb->buf + sb->len, sb->alloc - sb->len, fmt, tm);
991
992 if (!len) {
993 /*
Jeff Kinge4f031e2015-06-30 09:26:53 -0400994 * strftime reports "0" if it could not fit the result in the buffer.
995 * Unfortunately, it also reports "0" if the requested time string
996 * takes 0 bytes. So our strategy is to munge the format so that the
997 * output contains at least one character, and then drop the extra
998 * character before returning.
Jeff Kingaa1462c2015-06-25 12:55:45 -0400999 */
René Scharfec3fbf812017-06-15 14:29:53 +02001000 strbuf_addch(&munged_fmt, ' ');
Jeff Kinge4f031e2015-06-30 09:26:53 -04001001 while (!len) {
1002 hint *= 2;
1003 strbuf_grow(sb, hint);
1004 len = strftime(sb->buf + sb->len, sb->alloc - sb->len,
1005 munged_fmt.buf, tm);
1006 }
Jeff Kinge4f031e2015-06-30 09:26:53 -04001007 len--; /* drop munged space */
Jeff Kingaa1462c2015-06-25 12:55:45 -04001008 }
René Scharfec3fbf812017-06-15 14:29:53 +02001009 strbuf_release(&munged_fmt);
Jeff Kinge4f031e2015-06-30 09:26:53 -04001010 strbuf_setlen(sb, sb->len + len);
Jeff Kingaa1462c2015-06-25 12:55:45 -04001011}
Jeff Kingaf49c6d2015-09-24 17:05:45 -04001012
Tobias Klauser63af4a82015-10-16 17:16:42 +02001013/*
1014 * Returns the length of a line, without trailing spaces.
1015 *
1016 * If the line ends with newline, it will be removed too.
1017 */
1018static size_t cleanup(char *line, size_t len)
1019{
1020 while (len) {
1021 unsigned char c = line[len - 1];
1022 if (!isspace(c))
1023 break;
1024 len--;
1025 }
1026
1027 return len;
1028}
1029
1030/*
1031 * Remove empty lines from the beginning and end
1032 * and also trailing spaces from every line.
1033 *
1034 * Turn multiple consecutive empty lines between paragraphs
1035 * into just one empty line.
1036 *
1037 * If the input has only empty lines and spaces,
1038 * no output will be produced.
1039 *
1040 * If last line does not have a newline at the end, one is added.
1041 *
Jeff King2982b652024-03-12 05:17:27 -04001042 * Pass a non-NULL comment_prefix to skip every line starting
Calvin Wan787cb8a2023-06-06 19:48:43 +00001043 * with it.
Tobias Klauser63af4a82015-10-16 17:16:42 +02001044 */
Jeff King2982b652024-03-12 05:17:27 -04001045void strbuf_stripspace(struct strbuf *sb, const char *comment_prefix)
Tobias Klauser63af4a82015-10-16 17:16:42 +02001046{
Jeff King26114c02018-07-24 06:51:08 -04001047 size_t empties = 0;
Tobias Klauser63af4a82015-10-16 17:16:42 +02001048 size_t i, j, len, newlen;
1049 char *eol;
1050
1051 /* We may have to add a newline. */
1052 strbuf_grow(sb, 1);
1053
1054 for (i = j = 0; i < sb->len; i += len, j += newlen) {
1055 eol = memchr(sb->buf + i, '\n', sb->len - i);
1056 len = eol ? eol - (sb->buf + i) + 1 : sb->len - i;
1057
Jeff King2786d052024-03-12 05:17:22 -04001058 if (comment_prefix && len &&
Jeff King2982b652024-03-12 05:17:27 -04001059 starts_with(sb->buf + i, comment_prefix)) {
Tobias Klauser63af4a82015-10-16 17:16:42 +02001060 newlen = 0;
1061 continue;
1062 }
1063 newlen = cleanup(sb->buf + i, len);
1064
1065 /* Not just an empty line? */
1066 if (newlen) {
1067 if (empties > 0 && j > 0)
1068 sb->buf[j++] = '\n';
1069 empties = 0;
1070 memmove(sb->buf + j, sb->buf + i, newlen);
1071 sb->buf[newlen + j++] = '\n';
1072 } else {
1073 empties++;
1074 }
1075 }
1076
1077 strbuf_setlen(sb, j);
1078}
Jeff King670c3592016-10-03 16:34:17 -04001079
Derrick Stolee9ea57962022-12-22 15:14:14 +00001080void strbuf_strip_file_from_path(struct strbuf *sb)
1081{
1082 char *path_sep = find_last_dir_sep(sb->buf);
1083 strbuf_setlen(sb, path_sep ? path_sep - sb->buf + 1 : 0);
1084}