2005-04-26 19:00:58 +00:00
|
|
|
#include "cache.h"
|
2009-03-21 21:35:51 +00:00
|
|
|
#include "refs.h"
|
2014-05-22 09:30:14 +00:00
|
|
|
#include "utf8.h"
|
2005-04-26 01:26:45 +00:00
|
|
|
|
2013-12-01 07:49:16 +00:00
|
|
|
int starts_with(const char *str, const char *prefix)
|
|
|
|
{
|
|
|
|
for (; ; str++, prefix++)
|
|
|
|
if (!*prefix)
|
|
|
|
return 1;
|
|
|
|
else if (*str != *prefix)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-03-09 17:35:29 +00:00
|
|
|
int istarts_with(const char *str, const char *prefix)
|
|
|
|
{
|
|
|
|
for (; ; str++, prefix++)
|
|
|
|
if (!*prefix)
|
|
|
|
return 1;
|
|
|
|
else if (tolower(*str) != tolower(*prefix))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-12-09 20:40:07 +00:00
|
|
|
int skip_to_optional_arg_default(const char *str, const char *prefix,
|
|
|
|
const char **arg, const char *def)
|
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
if (!skip_prefix(str, prefix, &p))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!*p) {
|
|
|
|
if (arg)
|
|
|
|
*arg = def;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*p != '=')
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (arg)
|
|
|
|
*arg = p + 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-09-27 10:58:23 +00:00
|
|
|
/*
|
|
|
|
* Used as the default ->buf value, so that people can always assume
|
|
|
|
* buf is non NULL and ->buf is NUL terminated even for a freshly
|
|
|
|
* initialized strbuf.
|
|
|
|
*/
|
|
|
|
char strbuf_slopbuf[1];
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_init(struct strbuf *sb, size_t hint)
|
|
|
|
{
|
2007-09-27 10:58:23 +00:00
|
|
|
sb->alloc = sb->len = 0;
|
|
|
|
sb->buf = strbuf_slopbuf;
|
strbuf_grow(): maintain nul-termination even for new buffer
In the case where sb is initialized to the slopbuf (through
strbuf_init(sb,0) or STRBUF_INIT), strbuf_grow() loses the terminating
nul: it grows the buffer, but gives ALLOC_GROW a NULL source to avoid
it being freed. So ALLOC_GROW does not copy anything to the new
memory area.
This subtly broke the call to strbuf_getline in read_next_command()
[fast-import.c:1855], which goes
strbuf_detach(&command_buf, NULL); # command_buf is now = STRBUF_INIT
stdin_eof = strbuf_getline(&command_buf, stdin, '\n');
if (stdin_eof)
return EOF;
In strbuf_getwholeline, this did
strbuf_grow(sb, 0); # loses nul-termination
if (feof(fp))
return EOF;
strbuf_reset(sb); # this would have nul-terminated!
Valgrind found this because fast-import subsequently uses prefixcmp()
on command_buf.buf, which after the EOF exit contains only
uninitialized memory.
Arguably strbuf_getwholeline is also broken, in that it touches the
buffer before deciding whether to do any work. However, it seems more
futureproof to not let the strbuf API lose the nul-termination by its
own fault.
So make sure that strbuf_grow() puts in a nul even if it has nowhere
to copy it from. This makes strbuf_grow(sb, 0) a semantic no-op as
far as readers of the buffer are concerned.
Also remove the nul-termination added by strbuf_init, which is made
redudant.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-29 21:16:12 +00:00
|
|
|
if (hint)
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_grow(sb, hint);
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_release(struct strbuf *sb)
|
|
|
|
{
|
2007-09-27 10:58:23 +00:00
|
|
|
if (sb->alloc) {
|
|
|
|
free(sb->buf);
|
|
|
|
strbuf_init(sb, 0);
|
|
|
|
}
|
2007-09-06 11:20:05 +00:00
|
|
|
}
|
|
|
|
|
2007-09-27 10:58:23 +00:00
|
|
|
char *strbuf_detach(struct strbuf *sb, size_t *sz)
|
2007-09-15 13:56:50 +00:00
|
|
|
{
|
2012-10-18 10:00:12 +00:00
|
|
|
char *res;
|
|
|
|
strbuf_grow(sb, 0);
|
|
|
|
res = sb->buf;
|
2007-09-27 10:58:23 +00:00
|
|
|
if (sz)
|
|
|
|
*sz = sb->len;
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_init(sb, 0);
|
2007-09-06 11:20:05 +00:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_attach(struct strbuf *sb, void *buf, size_t len, size_t alloc)
|
|
|
|
{
|
|
|
|
strbuf_release(sb);
|
|
|
|
sb->buf = buf;
|
|
|
|
sb->len = len;
|
|
|
|
sb->alloc = alloc;
|
|
|
|
strbuf_grow(sb, 0);
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_grow(struct strbuf *sb, size_t extra)
|
|
|
|
{
|
strbuf_grow(): maintain nul-termination even for new buffer
In the case where sb is initialized to the slopbuf (through
strbuf_init(sb,0) or STRBUF_INIT), strbuf_grow() loses the terminating
nul: it grows the buffer, but gives ALLOC_GROW a NULL source to avoid
it being freed. So ALLOC_GROW does not copy anything to the new
memory area.
This subtly broke the call to strbuf_getline in read_next_command()
[fast-import.c:1855], which goes
strbuf_detach(&command_buf, NULL); # command_buf is now = STRBUF_INIT
stdin_eof = strbuf_getline(&command_buf, stdin, '\n');
if (stdin_eof)
return EOF;
In strbuf_getwholeline, this did
strbuf_grow(sb, 0); # loses nul-termination
if (feof(fp))
return EOF;
strbuf_reset(sb); # this would have nul-terminated!
Valgrind found this because fast-import subsequently uses prefixcmp()
on command_buf.buf, which after the EOF exit contains only
uninitialized memory.
Arguably strbuf_getwholeline is also broken, in that it touches the
buffer before deciding whether to do any work. However, it seems more
futureproof to not let the strbuf API lose the nul-termination by its
own fault.
So make sure that strbuf_grow() puts in a nul even if it has nowhere
to copy it from. This makes strbuf_grow(sb, 0) a semantic no-op as
far as readers of the buffer are concerned.
Also remove the nul-termination added by strbuf_init, which is made
redudant.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-29 21:16:12 +00:00
|
|
|
int new_buf = !sb->alloc;
|
2010-10-11 02:59:26 +00:00
|
|
|
if (unsigned_add_overflows(extra, 1) ||
|
|
|
|
unsigned_add_overflows(sb->len, extra + 1))
|
2007-09-06 11:20:05 +00:00
|
|
|
die("you want to use way too much memory");
|
strbuf_grow(): maintain nul-termination even for new buffer
In the case where sb is initialized to the slopbuf (through
strbuf_init(sb,0) or STRBUF_INIT), strbuf_grow() loses the terminating
nul: it grows the buffer, but gives ALLOC_GROW a NULL source to avoid
it being freed. So ALLOC_GROW does not copy anything to the new
memory area.
This subtly broke the call to strbuf_getline in read_next_command()
[fast-import.c:1855], which goes
strbuf_detach(&command_buf, NULL); # command_buf is now = STRBUF_INIT
stdin_eof = strbuf_getline(&command_buf, stdin, '\n');
if (stdin_eof)
return EOF;
In strbuf_getwholeline, this did
strbuf_grow(sb, 0); # loses nul-termination
if (feof(fp))
return EOF;
strbuf_reset(sb); # this would have nul-terminated!
Valgrind found this because fast-import subsequently uses prefixcmp()
on command_buf.buf, which after the EOF exit contains only
uninitialized memory.
Arguably strbuf_getwholeline is also broken, in that it touches the
buffer before deciding whether to do any work. However, it seems more
futureproof to not let the strbuf API lose the nul-termination by its
own fault.
So make sure that strbuf_grow() puts in a nul even if it has nowhere
to copy it from. This makes strbuf_grow(sb, 0) a semantic no-op as
far as readers of the buffer are concerned.
Also remove the nul-termination added by strbuf_init, which is made
redudant.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-29 21:16:12 +00:00
|
|
|
if (new_buf)
|
2007-09-27 10:58:23 +00:00
|
|
|
sb->buf = NULL;
|
2007-09-06 11:20:05 +00:00
|
|
|
ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);
|
strbuf_grow(): maintain nul-termination even for new buffer
In the case where sb is initialized to the slopbuf (through
strbuf_init(sb,0) or STRBUF_INIT), strbuf_grow() loses the terminating
nul: it grows the buffer, but gives ALLOC_GROW a NULL source to avoid
it being freed. So ALLOC_GROW does not copy anything to the new
memory area.
This subtly broke the call to strbuf_getline in read_next_command()
[fast-import.c:1855], which goes
strbuf_detach(&command_buf, NULL); # command_buf is now = STRBUF_INIT
stdin_eof = strbuf_getline(&command_buf, stdin, '\n');
if (stdin_eof)
return EOF;
In strbuf_getwholeline, this did
strbuf_grow(sb, 0); # loses nul-termination
if (feof(fp))
return EOF;
strbuf_reset(sb); # this would have nul-terminated!
Valgrind found this because fast-import subsequently uses prefixcmp()
on command_buf.buf, which after the EOF exit contains only
uninitialized memory.
Arguably strbuf_getwholeline is also broken, in that it touches the
buffer before deciding whether to do any work. However, it seems more
futureproof to not let the strbuf API lose the nul-termination by its
own fault.
So make sure that strbuf_grow() puts in a nul even if it has nowhere
to copy it from. This makes strbuf_grow(sb, 0) a semantic no-op as
far as readers of the buffer are concerned.
Also remove the nul-termination added by strbuf_init, which is made
redudant.
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-29 21:16:12 +00:00
|
|
|
if (new_buf)
|
|
|
|
sb->buf[0] = '\0';
|
2007-09-06 11:20:05 +00:00
|
|
|
}
|
|
|
|
|
2008-07-13 18:29:18 +00:00
|
|
|
void strbuf_trim(struct strbuf *sb)
|
|
|
|
{
|
2014-04-30 08:58:06 +00:00
|
|
|
strbuf_rtrim(sb);
|
|
|
|
strbuf_ltrim(sb);
|
2008-07-13 18:29:18 +00:00
|
|
|
}
|
2018-02-12 09:49:37 +00:00
|
|
|
|
2007-09-10 10:35:04 +00:00
|
|
|
void strbuf_rtrim(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
|
|
|
|
sb->len--;
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
}
|
|
|
|
|
2018-02-12 09:49:37 +00:00
|
|
|
void strbuf_trim_trailing_dir_sep(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
while (sb->len > 0 && is_dir_sep((unsigned char)sb->buf[sb->len - 1]))
|
|
|
|
sb->len--;
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
}
|
|
|
|
|
2008-07-13 18:29:18 +00:00
|
|
|
void strbuf_ltrim(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
char *b = sb->buf;
|
|
|
|
while (sb->len > 0 && isspace(*b)) {
|
|
|
|
b++;
|
|
|
|
sb->len--;
|
|
|
|
}
|
|
|
|
memmove(sb->buf, b, sb->len);
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
}
|
|
|
|
|
2014-05-22 09:30:14 +00:00
|
|
|
int strbuf_reencode(struct strbuf *sb, const char *from, const char *to)
|
|
|
|
{
|
|
|
|
char *out;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (same_encoding(from, to))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out = reencode_string_len(sb->buf, sb->len, to, from, &len);
|
|
|
|
if (!out)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
strbuf_attach(sb, out, len, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-23 20:03:47 +00:00
|
|
|
void strbuf_tolower(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
char *p = sb->buf, *end = sb->buf + sb->len;
|
|
|
|
for (; p < end; p++)
|
|
|
|
*p = tolower(*p);
|
|
|
|
}
|
|
|
|
|
2012-11-04 06:46:53 +00:00
|
|
|
struct strbuf **strbuf_split_buf(const char *str, size_t slen,
|
|
|
|
int terminator, int max)
|
2008-07-13 18:29:18 +00:00
|
|
|
{
|
2012-11-04 06:46:51 +00:00
|
|
|
struct strbuf **ret = NULL;
|
|
|
|
size_t nr = 0, alloc = 0;
|
2008-07-13 18:29:18 +00:00
|
|
|
struct strbuf *t;
|
|
|
|
|
2012-11-04 06:46:52 +00:00
|
|
|
while (slen) {
|
|
|
|
int len = slen;
|
|
|
|
if (max <= 0 || nr + 1 < max) {
|
2012-11-04 06:46:53 +00:00
|
|
|
const char *end = memchr(str, terminator, slen);
|
2012-11-04 06:46:52 +00:00
|
|
|
if (end)
|
|
|
|
len = end - str + 1;
|
|
|
|
}
|
2008-07-13 18:29:18 +00:00
|
|
|
t = xmalloc(sizeof(struct strbuf));
|
|
|
|
strbuf_init(t, len);
|
2012-11-04 06:46:52 +00:00
|
|
|
strbuf_add(t, str, len);
|
2012-11-04 06:46:51 +00:00
|
|
|
ALLOC_GROW(ret, nr + 2, alloc);
|
|
|
|
ret[nr++] = t;
|
2012-11-04 06:46:52 +00:00
|
|
|
str += len;
|
|
|
|
slen -= len;
|
2008-07-13 18:29:18 +00:00
|
|
|
}
|
2012-11-04 06:46:51 +00:00
|
|
|
ALLOC_GROW(ret, nr + 1, alloc); /* In case string was empty */
|
|
|
|
ret[nr] = NULL;
|
2008-07-13 18:29:18 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_list_free(struct strbuf **sbs)
|
|
|
|
{
|
|
|
|
struct strbuf **s = sbs;
|
|
|
|
|
|
|
|
while (*s) {
|
|
|
|
strbuf_release(*s);
|
|
|
|
free(*s++);
|
|
|
|
}
|
|
|
|
free(sbs);
|
|
|
|
}
|
|
|
|
|
2008-07-13 18:28:24 +00:00
|
|
|
int strbuf_cmp(const struct strbuf *a, const struct strbuf *b)
|
2007-09-24 09:25:03 +00:00
|
|
|
{
|
2009-03-19 22:27:32 +00:00
|
|
|
int len = a->len < b->len ? a->len: b->len;
|
|
|
|
int cmp = memcmp(a->buf, b->buf, len);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
return a->len < b->len ? -1: a->len != b->len;
|
2007-09-24 09:25:03 +00:00
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
|
|
|
|
const void *data, size_t dlen)
|
|
|
|
{
|
2010-10-11 02:59:26 +00:00
|
|
|
if (unsigned_add_overflows(pos, len))
|
2007-09-15 13:56:50 +00:00
|
|
|
die("you want to use way too much memory");
|
|
|
|
if (pos > sb->len)
|
|
|
|
die("`pos' is too far after the end of the buffer");
|
|
|
|
if (pos + len > sb->len)
|
|
|
|
die("`pos + len' is too far after the end of the buffer");
|
|
|
|
|
|
|
|
if (dlen >= len)
|
|
|
|
strbuf_grow(sb, dlen - len);
|
|
|
|
memmove(sb->buf + pos + dlen,
|
|
|
|
sb->buf + pos + len,
|
|
|
|
sb->len - pos - len);
|
|
|
|
memcpy(sb->buf + pos, data, dlen);
|
|
|
|
strbuf_setlen(sb, sb->len + dlen - len);
|
|
|
|
}
|
|
|
|
|
2007-09-19 22:42:12 +00:00
|
|
|
void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len)
|
|
|
|
{
|
|
|
|
strbuf_splice(sb, pos, 0, data, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_remove(struct strbuf *sb, size_t pos, size_t len)
|
|
|
|
{
|
2016-09-13 16:40:22 +00:00
|
|
|
strbuf_splice(sb, pos, len, "", 0);
|
2007-09-19 22:42:12 +00:00
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_add(struct strbuf *sb, const void *data, size_t len)
|
|
|
|
{
|
2007-09-06 11:20:05 +00:00
|
|
|
strbuf_grow(sb, len);
|
|
|
|
memcpy(sb->buf + sb->len, data, len);
|
|
|
|
strbuf_setlen(sb, sb->len + len);
|
|
|
|
}
|
|
|
|
|
2016-07-21 16:46:44 +00:00
|
|
|
void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2)
|
|
|
|
{
|
|
|
|
strbuf_grow(sb, sb2->len);
|
|
|
|
memcpy(sb->buf + sb->len, sb2->buf, sb2->len);
|
|
|
|
strbuf_setlen(sb, sb->len + sb2->len);
|
|
|
|
}
|
|
|
|
|
2014-09-07 07:03:32 +00:00
|
|
|
void strbuf_addchars(struct strbuf *sb, int c, size_t n)
|
|
|
|
{
|
|
|
|
strbuf_grow(sb, n);
|
|
|
|
memset(sb->buf + sb->len, c, n);
|
|
|
|
strbuf_setlen(sb, sb->len + n);
|
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
|
|
|
|
{
|
2007-09-06 11:20:05 +00:00
|
|
|
va_list ap;
|
2011-02-26 05:08:53 +00:00
|
|
|
va_start(ap, fmt);
|
|
|
|
strbuf_vaddf(sb, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2013-01-16 19:18:48 +00:00
|
|
|
static void add_lines(struct strbuf *out,
|
|
|
|
const char *prefix1,
|
|
|
|
const char *prefix2,
|
|
|
|
const char *buf, size_t size)
|
|
|
|
{
|
|
|
|
while (size) {
|
|
|
|
const char *prefix;
|
|
|
|
const char *next = memchr(buf, '\n', size);
|
|
|
|
next = next ? (next + 1) : (buf + size);
|
|
|
|
|
2014-10-27 21:13:15 +00:00
|
|
|
prefix = ((prefix2 && (buf[0] == '\n' || buf[0] == '\t'))
|
|
|
|
? prefix2 : prefix1);
|
2013-01-16 19:18:48 +00:00
|
|
|
strbuf_addstr(out, prefix);
|
|
|
|
strbuf_add(out, buf, next - buf);
|
|
|
|
size -= next - buf;
|
|
|
|
buf = next;
|
|
|
|
}
|
|
|
|
strbuf_complete_line(out);
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_add_commented_lines(struct strbuf *out, const char *buf, size_t size)
|
|
|
|
{
|
|
|
|
static char prefix1[3];
|
|
|
|
static char prefix2[2];
|
|
|
|
|
|
|
|
if (prefix1[0] != comment_line_char) {
|
2015-09-24 21:06:08 +00:00
|
|
|
xsnprintf(prefix1, sizeof(prefix1), "%c ", comment_line_char);
|
|
|
|
xsnprintf(prefix2, sizeof(prefix2), "%c", comment_line_char);
|
2013-01-16 19:18:48 +00:00
|
|
|
}
|
|
|
|
add_lines(out, prefix1, prefix2, buf, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_commented_addf(struct strbuf *sb, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list params;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int incomplete_line = sb->len && sb->buf[sb->len - 1] != '\n';
|
|
|
|
|
|
|
|
va_start(params, fmt);
|
|
|
|
strbuf_vaddf(&buf, fmt, params);
|
|
|
|
va_end(params);
|
|
|
|
|
|
|
|
strbuf_add_commented_lines(sb, buf.buf, buf.len);
|
|
|
|
if (incomplete_line)
|
|
|
|
sb->buf[--sb->len] = '\0';
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
|
2011-02-26 05:08:53 +00:00
|
|
|
void strbuf_vaddf(struct strbuf *sb, const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
va_list cp;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
2007-11-13 08:22:44 +00:00
|
|
|
if (!strbuf_avail(sb))
|
|
|
|
strbuf_grow(sb, 64);
|
2011-02-26 05:08:53 +00:00
|
|
|
va_copy(cp, ap);
|
|
|
|
len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, cp);
|
|
|
|
va_end(cp);
|
2007-11-13 08:22:44 +00:00
|
|
|
if (len < 0)
|
2011-02-26 05:08:53 +00:00
|
|
|
die("BUG: your vsnprintf is broken (returned %d)", len);
|
2007-09-10 10:35:04 +00:00
|
|
|
if (len > strbuf_avail(sb)) {
|
2007-09-06 11:20:05 +00:00
|
|
|
strbuf_grow(sb, len);
|
|
|
|
len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
|
2011-02-26 05:08:53 +00:00
|
|
|
if (len > strbuf_avail(sb))
|
|
|
|
die("BUG: your vsnprintf is broken (insatiable)");
|
2007-09-06 11:20:05 +00:00
|
|
|
}
|
|
|
|
strbuf_setlen(sb, sb->len + len);
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
|
|
|
|
2008-02-09 14:40:19 +00:00
|
|
|
void strbuf_expand(struct strbuf *sb, const char *format, expand_fn_t fn,
|
|
|
|
void *context)
|
2007-11-09 00:49:42 +00:00
|
|
|
{
|
|
|
|
for (;;) {
|
2008-02-09 14:40:19 +00:00
|
|
|
const char *percent;
|
|
|
|
size_t consumed;
|
2007-11-09 00:49:42 +00:00
|
|
|
|
|
|
|
percent = strchrnul(format, '%');
|
|
|
|
strbuf_add(sb, format, percent - format);
|
|
|
|
if (!*percent)
|
|
|
|
break;
|
|
|
|
format = percent + 1;
|
|
|
|
|
2010-01-13 17:35:31 +00:00
|
|
|
if (*format == '%') {
|
|
|
|
strbuf_addch(sb, '%');
|
|
|
|
format++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-02-09 14:40:19 +00:00
|
|
|
consumed = fn(sb, format, context);
|
|
|
|
if (consumed)
|
|
|
|
format += consumed;
|
|
|
|
else
|
2007-11-09 00:49:42 +00:00
|
|
|
strbuf_addch(sb, '%');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-22 23:09:30 +00:00
|
|
|
size_t strbuf_expand_dict_cb(struct strbuf *sb, const char *placeholder,
|
|
|
|
void *context)
|
|
|
|
{
|
|
|
|
struct strbuf_expand_dict_entry *e = context;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
for (; e->placeholder && (len = strlen(e->placeholder)); e++) {
|
|
|
|
if (!strncmp(placeholder, e->placeholder, len)) {
|
|
|
|
if (e->value)
|
|
|
|
strbuf_addstr(sb, e->value);
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-13 17:36:42 +00:00
|
|
|
void strbuf_addbuf_percentquote(struct strbuf *dst, const struct strbuf *src)
|
|
|
|
{
|
|
|
|
int i, len = src->len;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (src->buf[i] == '%')
|
|
|
|
strbuf_addch(dst, '%');
|
|
|
|
strbuf_addch(dst, src->buf[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-15 13:56:50 +00:00
|
|
|
size_t strbuf_fread(struct strbuf *sb, size_t size, FILE *f)
|
|
|
|
{
|
2007-09-06 11:20:05 +00:00
|
|
|
size_t res;
|
2009-01-06 20:41:14 +00:00
|
|
|
size_t oldalloc = sb->alloc;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
|
|
|
strbuf_grow(sb, size);
|
|
|
|
res = fread(sb->buf + sb->len, 1, size, f);
|
2009-01-06 20:41:14 +00:00
|
|
|
if (res > 0)
|
2007-09-06 11:20:05 +00:00
|
|
|
strbuf_setlen(sb, sb->len + res);
|
2009-06-22 16:42:33 +00:00
|
|
|
else if (oldalloc == 0)
|
2009-01-06 20:41:14 +00:00
|
|
|
strbuf_release(sb);
|
2007-09-06 11:20:05 +00:00
|
|
|
return res;
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
|
|
|
|
2007-09-10 10:35:04 +00:00
|
|
|
ssize_t strbuf_read(struct strbuf *sb, int fd, size_t hint)
|
2007-09-06 11:20:05 +00:00
|
|
|
{
|
|
|
|
size_t oldlen = sb->len;
|
2009-01-06 20:41:14 +00:00
|
|
|
size_t oldalloc = sb->alloc;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_grow(sb, hint ? hint : 8192);
|
2007-09-06 11:20:05 +00:00
|
|
|
for (;;) {
|
2015-05-31 18:16:45 +00:00
|
|
|
ssize_t want = sb->alloc - sb->len - 1;
|
|
|
|
ssize_t got = read_in_full(fd, sb->buf + sb->len, want);
|
2007-09-06 11:20:05 +00:00
|
|
|
|
2015-05-31 18:16:45 +00:00
|
|
|
if (got < 0) {
|
2009-01-06 20:41:14 +00:00
|
|
|
if (oldalloc == 0)
|
|
|
|
strbuf_release(sb);
|
|
|
|
else
|
|
|
|
strbuf_setlen(sb, oldlen);
|
2007-09-06 11:20:05 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2015-05-31 18:16:45 +00:00
|
|
|
sb->len += got;
|
|
|
|
if (got < want)
|
2007-09-06 11:20:05 +00:00
|
|
|
break;
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_grow(sb, 8192);
|
2007-09-06 11:20:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
return sb->len - oldlen;
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
|
|
|
|
2015-12-16 00:04:08 +00:00
|
|
|
ssize_t strbuf_read_once(struct strbuf *sb, int fd, size_t hint)
|
|
|
|
{
|
2017-12-07 20:51:26 +00:00
|
|
|
size_t oldalloc = sb->alloc;
|
2015-12-16 00:04:08 +00:00
|
|
|
ssize_t cnt;
|
|
|
|
|
|
|
|
strbuf_grow(sb, hint ? hint : 8192);
|
|
|
|
cnt = xread(fd, sb->buf + sb->len, sb->alloc - sb->len - 1);
|
|
|
|
if (cnt > 0)
|
|
|
|
strbuf_setlen(sb, sb->len + cnt);
|
2017-12-07 20:51:26 +00:00
|
|
|
else if (oldalloc == 0)
|
|
|
|
strbuf_release(sb);
|
2015-12-16 00:04:08 +00:00
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
2016-03-01 02:07:15 +00:00
|
|
|
ssize_t strbuf_write(struct strbuf *sb, FILE *f)
|
|
|
|
{
|
|
|
|
return sb->len ? fwrite(sb->buf, 1, sb->len, f) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-12-17 17:36:40 +00:00
|
|
|
#define STRBUF_MAXLINK (2*PATH_MAX)
|
|
|
|
|
|
|
|
int strbuf_readlink(struct strbuf *sb, const char *path, size_t hint)
|
|
|
|
{
|
2009-01-06 20:41:14 +00:00
|
|
|
size_t oldalloc = sb->alloc;
|
|
|
|
|
2008-12-17 17:36:40 +00:00
|
|
|
if (hint < 32)
|
|
|
|
hint = 32;
|
|
|
|
|
|
|
|
while (hint < STRBUF_MAXLINK) {
|
|
|
|
int len;
|
|
|
|
|
|
|
|
strbuf_grow(sb, hint);
|
|
|
|
len = readlink(path, sb->buf, hint);
|
|
|
|
if (len < 0) {
|
|
|
|
if (errno != ERANGE)
|
|
|
|
break;
|
|
|
|
} else if (len < hint) {
|
|
|
|
strbuf_setlen(sb, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* .. the buffer was too small - try again */
|
|
|
|
hint *= 2;
|
|
|
|
}
|
2009-01-06 20:41:14 +00:00
|
|
|
if (oldalloc == 0)
|
|
|
|
strbuf_release(sb);
|
2008-12-17 17:36:40 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-07-28 18:24:29 +00:00
|
|
|
int strbuf_getcwd(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
size_t oldalloc = sb->alloc;
|
|
|
|
size_t guessed_len = 128;
|
|
|
|
|
|
|
|
for (;; guessed_len *= 2) {
|
|
|
|
strbuf_grow(sb, guessed_len);
|
|
|
|
if (getcwd(sb->buf, sb->alloc)) {
|
|
|
|
strbuf_setlen(sb, strlen(sb->buf));
|
|
|
|
return 0;
|
|
|
|
}
|
2017-03-26 13:43:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If getcwd(3) is implemented as a syscall that falls
|
|
|
|
* back to a regular lookup using readdir(3) etc. then
|
|
|
|
* we may be able to avoid EACCES by providing enough
|
|
|
|
* space to the syscall as it's not necessarily bound
|
|
|
|
* to the same restrictions as the fallback.
|
|
|
|
*/
|
|
|
|
if (errno == EACCES && guessed_len < PATH_MAX)
|
|
|
|
continue;
|
|
|
|
|
2014-07-28 18:24:29 +00:00
|
|
|
if (errno != ERANGE)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (oldalloc == 0)
|
|
|
|
strbuf_release(sb);
|
|
|
|
else
|
|
|
|
strbuf_reset(sb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-04-16 09:01:38 +00:00
|
|
|
#ifdef HAVE_GETDELIM
|
|
|
|
int strbuf_getwholeline(struct strbuf *sb, FILE *fp, int term)
|
|
|
|
{
|
|
|
|
ssize_t r;
|
|
|
|
|
|
|
|
if (feof(fp))
|
|
|
|
return EOF;
|
|
|
|
|
|
|
|
strbuf_reset(sb);
|
|
|
|
|
|
|
|
/* Translate slopbuf to NULL, as we cannot call realloc on it */
|
|
|
|
if (!sb->alloc)
|
|
|
|
sb->buf = NULL;
|
2017-08-10 20:56:40 +00:00
|
|
|
errno = 0;
|
2015-04-16 09:01:38 +00:00
|
|
|
r = getdelim(&sb->buf, &sb->alloc, term, fp);
|
|
|
|
|
|
|
|
if (r > 0) {
|
|
|
|
sb->len = r;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
assert(r == -1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Normally we would have called xrealloc, which will try to free
|
|
|
|
* memory and recover. But we have no way to tell getdelim() to do so.
|
|
|
|
* Worse, we cannot try to recover ENOMEM ourselves, because we have
|
|
|
|
* no idea how many bytes were read by getdelim.
|
|
|
|
*
|
|
|
|
* Dying here is reasonable. It mirrors what xrealloc would do on
|
|
|
|
* catastrophic memory failure. We skip the opportunity to free pack
|
|
|
|
* memory and retry, but that's unlikely to help for a malloc small
|
|
|
|
* enough to hold a single line of input, anyway.
|
|
|
|
*/
|
|
|
|
if (errno == ENOMEM)
|
|
|
|
die("Out of memory, getdelim failed");
|
|
|
|
|
strbuf_getwholeline: NUL-terminate getdelim buffer on error
Commit 0cc30e0 (strbuf_getwholeline: use getdelim if it is
available, 2015-04-16) tries to clean up after getdelim()
returns EOF, but gets one case wrong, which can lead in some
obscure cases to us reading uninitialized memory.
After getdelim() returns -1, we re-initialize the strbuf
only if sb->buf is NULL. The thinking was that either:
1. We fed an existing allocated buffer to getdelim(), and
at most it would have realloc'd, leaving our NUL in
place.
2. We didn't have a buffer to feed, so we gave getdelim()
NULL; sb->buf will remain NULL, and we just want to
restore the empty slopbuf.
But that second case isn't quite right. getdelim() may
allocate a buffer, write nothing into it, and then return
EOF. The resulting strbuf rightfully has sb->len set to "0",
but is missing the NUL terminator in the first byte.
Most call-sites are fine with this. They see the EOF and
don't bother looking at the strbuf. Or they notice that
sb->len is empty, and don't look at the contents. But
there's at least one case that does neither, and relies on
parsing the resulting (possibly zero-length) string:
fast-import. You can see this in action with the new test
(though we probably only notice failure there when run with
--valgrind or ASAN).
We can fix this by unconditionally resetting the strbuf when
we have a buffer after getdelim(). That fixes case 2 above.
Case 1 is probably already fine in practice, but it does not
hurt for us to re-assert our invariants (especially because
we are relying on whatever getdelim() happens to do, which
may vary from platform to platform). Our fix covers that
case, too.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-05 18:43:30 +00:00
|
|
|
/*
|
|
|
|
* Restore strbuf invariants; if getdelim left us with a NULL pointer,
|
|
|
|
* we can just re-init, but otherwise we should make sure that our
|
|
|
|
* length is empty, and that the result is NUL-terminated.
|
|
|
|
*/
|
2015-04-16 09:01:38 +00:00
|
|
|
if (!sb->buf)
|
|
|
|
strbuf_init(sb, 0);
|
strbuf_getwholeline: NUL-terminate getdelim buffer on error
Commit 0cc30e0 (strbuf_getwholeline: use getdelim if it is
available, 2015-04-16) tries to clean up after getdelim()
returns EOF, but gets one case wrong, which can lead in some
obscure cases to us reading uninitialized memory.
After getdelim() returns -1, we re-initialize the strbuf
only if sb->buf is NULL. The thinking was that either:
1. We fed an existing allocated buffer to getdelim(), and
at most it would have realloc'd, leaving our NUL in
place.
2. We didn't have a buffer to feed, so we gave getdelim()
NULL; sb->buf will remain NULL, and we just want to
restore the empty slopbuf.
But that second case isn't quite right. getdelim() may
allocate a buffer, write nothing into it, and then return
EOF. The resulting strbuf rightfully has sb->len set to "0",
but is missing the NUL terminator in the first byte.
Most call-sites are fine with this. They see the EOF and
don't bother looking at the strbuf. Or they notice that
sb->len is empty, and don't look at the contents. But
there's at least one case that does neither, and relies on
parsing the resulting (possibly zero-length) string:
fast-import. You can see this in action with the new test
(though we probably only notice failure there when run with
--valgrind or ASAN).
We can fix this by unconditionally resetting the strbuf when
we have a buffer after getdelim(). That fixes case 2 above.
Case 1 is probably already fine in practice, but it does not
hurt for us to re-assert our invariants (especially because
we are relying on whatever getdelim() happens to do, which
may vary from platform to platform). Our fix covers that
case, too.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-05 18:43:30 +00:00
|
|
|
else
|
|
|
|
strbuf_reset(sb);
|
2015-04-16 09:01:38 +00:00
|
|
|
return EOF;
|
|
|
|
}
|
|
|
|
#else
|
2009-08-05 03:31:56 +00:00
|
|
|
int strbuf_getwholeline(struct strbuf *sb, FILE *fp, int term)
|
2007-09-15 13:56:50 +00:00
|
|
|
{
|
2005-04-26 01:26:45 +00:00
|
|
|
int ch;
|
2007-09-17 09:19:04 +00:00
|
|
|
|
|
|
|
if (feof(fp))
|
|
|
|
return EOF;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
|
|
|
strbuf_reset(sb);
|
2015-04-16 08:49:06 +00:00
|
|
|
flockfile(fp);
|
|
|
|
while ((ch = getc_unlocked(fp)) != EOF) {
|
2015-04-16 08:58:54 +00:00
|
|
|
if (!strbuf_avail(sb))
|
|
|
|
strbuf_grow(sb, 1);
|
2007-09-06 11:20:05 +00:00
|
|
|
sb->buf[sb->len++] = ch;
|
2009-08-05 03:31:56 +00:00
|
|
|
if (ch == term)
|
|
|
|
break;
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
2015-04-16 08:49:06 +00:00
|
|
|
funlockfile(fp);
|
2007-09-17 09:19:04 +00:00
|
|
|
if (ch == EOF && sb->len == 0)
|
|
|
|
return EOF;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
|
|
|
sb->buf[sb->len] = '\0';
|
2007-09-17 09:19:04 +00:00
|
|
|
return 0;
|
2005-04-26 01:26:45 +00:00
|
|
|
}
|
2015-04-16 09:01:38 +00:00
|
|
|
#endif
|
2007-09-18 00:06:46 +00:00
|
|
|
|
2016-01-14 02:32:23 +00:00
|
|
|
static int strbuf_getdelim(struct strbuf *sb, FILE *fp, int term)
|
2009-08-05 03:31:56 +00:00
|
|
|
{
|
|
|
|
if (strbuf_getwholeline(sb, fp, term))
|
|
|
|
return EOF;
|
2016-01-13 23:10:45 +00:00
|
|
|
if (sb->buf[sb->len - 1] == term)
|
|
|
|
strbuf_setlen(sb, sb->len - 1);
|
2009-08-05 03:31:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-14 02:32:23 +00:00
|
|
|
int strbuf_getline(struct strbuf *sb, FILE *fp)
|
2015-10-28 20:17:29 +00:00
|
|
|
{
|
|
|
|
if (strbuf_getwholeline(sb, fp, '\n'))
|
|
|
|
return EOF;
|
|
|
|
if (sb->buf[sb->len - 1] == '\n') {
|
|
|
|
strbuf_setlen(sb, sb->len - 1);
|
|
|
|
if (sb->len && sb->buf[sb->len - 1] == '\r')
|
|
|
|
strbuf_setlen(sb, sb->len - 1);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-01-13 23:31:17 +00:00
|
|
|
int strbuf_getline_lf(struct strbuf *sb, FILE *fp)
|
|
|
|
{
|
2016-01-14 02:32:23 +00:00
|
|
|
return strbuf_getdelim(sb, fp, '\n');
|
2016-01-13 23:31:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int strbuf_getline_nul(struct strbuf *sb, FILE *fp)
|
|
|
|
{
|
2016-01-14 02:32:23 +00:00
|
|
|
return strbuf_getdelim(sb, fp, '\0');
|
2016-01-13 23:31:17 +00:00
|
|
|
}
|
|
|
|
|
2012-02-22 19:34:22 +00:00
|
|
|
int strbuf_getwholeline_fd(struct strbuf *sb, int fd, int term)
|
|
|
|
{
|
|
|
|
strbuf_reset(sb);
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
char ch;
|
|
|
|
ssize_t len = xread(fd, &ch, 1);
|
|
|
|
if (len <= 0)
|
|
|
|
return EOF;
|
|
|
|
strbuf_addch(sb, ch);
|
|
|
|
if (ch == term)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-03 13:59:32 +00:00
|
|
|
ssize_t strbuf_read_file(struct strbuf *sb, const char *path, size_t hint)
|
2007-09-18 00:06:46 +00:00
|
|
|
{
|
2015-07-03 13:59:32 +00:00
|
|
|
int fd;
|
|
|
|
ssize_t len;
|
2018-02-23 07:00:54 +00:00
|
|
|
int saved_errno;
|
2007-09-18 00:06:46 +00:00
|
|
|
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return -1;
|
2007-09-27 13:25:55 +00:00
|
|
|
len = strbuf_read(sb, fd, hint);
|
2018-02-23 07:00:54 +00:00
|
|
|
saved_errno = errno;
|
2007-09-18 00:06:46 +00:00
|
|
|
close(fd);
|
2018-02-23 07:00:54 +00:00
|
|
|
if (len < 0) {
|
|
|
|
errno = saved_errno;
|
2007-09-18 00:06:46 +00:00
|
|
|
return -1;
|
2018-02-23 07:00:54 +00:00
|
|
|
}
|
2007-09-18 00:06:46 +00:00
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
2011-11-05 04:06:30 +00:00
|
|
|
|
|
|
|
void strbuf_add_lines(struct strbuf *out, const char *prefix,
|
|
|
|
const char *buf, size_t size)
|
|
|
|
{
|
2013-01-16 19:18:48 +00:00
|
|
|
add_lines(out, prefix, NULL, buf, size);
|
2011-11-05 04:06:30 +00:00
|
|
|
}
|
2011-12-20 00:05:16 +00:00
|
|
|
|
2012-11-25 11:08:34 +00:00
|
|
|
void strbuf_addstr_xml_quoted(struct strbuf *buf, const char *s)
|
|
|
|
{
|
|
|
|
while (*s) {
|
|
|
|
size_t len = strcspn(s, "\"<>&");
|
|
|
|
strbuf_add(buf, s, len);
|
|
|
|
s += len;
|
|
|
|
switch (*s) {
|
|
|
|
case '"':
|
|
|
|
strbuf_addstr(buf, """);
|
|
|
|
break;
|
|
|
|
case '<':
|
|
|
|
strbuf_addstr(buf, "<");
|
|
|
|
break;
|
|
|
|
case '>':
|
|
|
|
strbuf_addstr(buf, ">");
|
|
|
|
break;
|
|
|
|
case '&':
|
|
|
|
strbuf_addstr(buf, "&");
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-10 10:34:20 +00:00
|
|
|
static int is_rfc3986_reserved(char ch)
|
|
|
|
{
|
|
|
|
switch (ch) {
|
|
|
|
case '!': case '*': case '\'': case '(': case ')': case ';':
|
|
|
|
case ':': case '@': case '&': case '=': case '+': case '$':
|
|
|
|
case ',': case '/': case '?': case '#': case '[': case ']':
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int is_rfc3986_unreserved(char ch)
|
|
|
|
{
|
|
|
|
return isalnum(ch) ||
|
|
|
|
ch == '-' || ch == '_' || ch == '.' || ch == '~';
|
|
|
|
}
|
|
|
|
|
2012-09-16 05:43:15 +00:00
|
|
|
static void strbuf_add_urlencode(struct strbuf *sb, const char *s, size_t len,
|
|
|
|
int reserved)
|
2011-12-10 10:34:20 +00:00
|
|
|
{
|
|
|
|
strbuf_grow(sb, len);
|
|
|
|
while (len--) {
|
|
|
|
char ch = *s++;
|
|
|
|
if (is_rfc3986_unreserved(ch) ||
|
|
|
|
(!reserved && is_rfc3986_reserved(ch)))
|
|
|
|
strbuf_addch(sb, ch);
|
|
|
|
else
|
2017-12-22 17:24:37 +00:00
|
|
|
strbuf_addf(sb, "%%%02x", (unsigned char)ch);
|
2011-12-10 10:34:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void strbuf_addstr_urlencode(struct strbuf *sb, const char *s,
|
|
|
|
int reserved)
|
|
|
|
{
|
|
|
|
strbuf_add_urlencode(sb, s, strlen(s), reserved);
|
|
|
|
}
|
2012-04-23 12:30:22 +00:00
|
|
|
|
2013-04-10 19:03:23 +00:00
|
|
|
void strbuf_humanise_bytes(struct strbuf *buf, off_t bytes)
|
|
|
|
{
|
|
|
|
if (bytes > 1 << 30) {
|
|
|
|
strbuf_addf(buf, "%u.%2.2u GiB",
|
|
|
|
(int)(bytes >> 30),
|
|
|
|
(int)(bytes & ((1 << 30) - 1)) / 10737419);
|
|
|
|
} else if (bytes > 1 << 20) {
|
|
|
|
int x = bytes + 5243; /* for rounding */
|
|
|
|
strbuf_addf(buf, "%u.%2.2u MiB",
|
|
|
|
x >> 20, ((x & ((1 << 20) - 1)) * 100) >> 20);
|
|
|
|
} else if (bytes > 1 << 10) {
|
|
|
|
int x = bytes + 5; /* for rounding */
|
|
|
|
strbuf_addf(buf, "%u.%2.2u KiB",
|
|
|
|
x >> 10, ((x & ((1 << 10) - 1)) * 100) >> 10);
|
|
|
|
} else {
|
|
|
|
strbuf_addf(buf, "%u bytes", (int)bytes);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-28 18:33:55 +00:00
|
|
|
void strbuf_add_absolute_path(struct strbuf *sb, const char *path)
|
|
|
|
{
|
|
|
|
if (!*path)
|
|
|
|
die("The empty string is not a valid path");
|
|
|
|
if (!is_absolute_path(path)) {
|
|
|
|
struct stat cwd_stat, pwd_stat;
|
|
|
|
size_t orig_len = sb->len;
|
|
|
|
char *cwd = xgetcwd();
|
|
|
|
char *pwd = getenv("PWD");
|
|
|
|
if (pwd && strcmp(pwd, cwd) &&
|
|
|
|
!stat(cwd, &cwd_stat) &&
|
|
|
|
(cwd_stat.st_dev || cwd_stat.st_ino) &&
|
|
|
|
!stat(pwd, &pwd_stat) &&
|
|
|
|
pwd_stat.st_dev == cwd_stat.st_dev &&
|
|
|
|
pwd_stat.st_ino == cwd_stat.st_ino)
|
|
|
|
strbuf_addstr(sb, pwd);
|
|
|
|
else
|
|
|
|
strbuf_addstr(sb, cwd);
|
|
|
|
if (sb->len > orig_len && !is_dir_sep(sb->buf[sb->len - 1]))
|
|
|
|
strbuf_addch(sb, '/');
|
|
|
|
free(cwd);
|
|
|
|
}
|
|
|
|
strbuf_addstr(sb, path);
|
|
|
|
}
|
|
|
|
|
2017-02-25 16:00:33 +00:00
|
|
|
void strbuf_add_real_path(struct strbuf *sb, const char *path)
|
|
|
|
{
|
|
|
|
if (sb->len) {
|
|
|
|
struct strbuf resolved = STRBUF_INIT;
|
|
|
|
strbuf_realpath(&resolved, path, 1);
|
|
|
|
strbuf_addbuf(sb, &resolved);
|
|
|
|
strbuf_release(&resolved);
|
|
|
|
} else
|
|
|
|
strbuf_realpath(sb, path, 1);
|
|
|
|
}
|
|
|
|
|
2012-04-23 12:30:22 +00:00
|
|
|
int printf_ln(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
ret = vprintf(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
if (ret < 0 || putchar('\n') == EOF)
|
|
|
|
return -1;
|
|
|
|
return ret + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int fprintf_ln(FILE *fp, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
ret = vfprintf(fp, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
if (ret < 0 || putc('\n', fp) == EOF)
|
|
|
|
return -1;
|
|
|
|
return ret + 1;
|
|
|
|
}
|
2014-05-22 09:44:09 +00:00
|
|
|
|
|
|
|
char *xstrdup_tolower(const char *string)
|
|
|
|
{
|
|
|
|
char *result;
|
|
|
|
size_t len, i;
|
|
|
|
|
|
|
|
len = strlen(string);
|
2016-02-22 22:44:28 +00:00
|
|
|
result = xmallocz(len);
|
2014-05-22 09:44:09 +00:00
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
result[i] = tolower(string[i]);
|
|
|
|
return result;
|
|
|
|
}
|
strbuf: add xstrfmt helper
You can use a strbuf to build up a string from parts, and
then detach it. In the general case, you might use multiple
strbuf_add* functions to do the building. However, in many
cases, a single strbuf_addf is sufficient, and we end up
with:
struct strbuf buf = STRBUF_INIT;
...
strbuf_addf(&buf, fmt, some, args);
str = strbuf_detach(&buf, NULL);
We can make this much more readable (and avoid introducing
an extra variable, which can clutter the code) by
introducing a convenience function:
str = xstrfmt(fmt, some, args);
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 20:01:34 +00:00
|
|
|
|
2018-02-15 15:27:06 +00:00
|
|
|
char *xstrdup_toupper(const char *string)
|
|
|
|
{
|
|
|
|
char *result;
|
|
|
|
size_t len, i;
|
|
|
|
|
|
|
|
len = strlen(string);
|
|
|
|
result = xmallocz(len);
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
result[i] = toupper(string[i]);
|
2014-05-22 09:44:09 +00:00
|
|
|
return result;
|
|
|
|
}
|
strbuf: add xstrfmt helper
You can use a strbuf to build up a string from parts, and
then detach it. In the general case, you might use multiple
strbuf_add* functions to do the building. However, in many
cases, a single strbuf_addf is sufficient, and we end up
with:
struct strbuf buf = STRBUF_INIT;
...
strbuf_addf(&buf, fmt, some, args);
str = strbuf_detach(&buf, NULL);
We can make this much more readable (and avoid introducing
an extra variable, which can clutter the code) by
introducing a convenience function:
str = xstrfmt(fmt, some, args);
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 20:01:34 +00:00
|
|
|
|
|
|
|
char *xstrvfmt(const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
strbuf_vaddf(&buf, fmt, ap);
|
|
|
|
return strbuf_detach(&buf, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
char *xstrfmt(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
char *ret;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
ret = xstrvfmt(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2015-06-25 16:55:45 +00:00
|
|
|
|
2017-06-15 12:29:53 +00:00
|
|
|
void strbuf_addftime(struct strbuf *sb, const char *fmt, const struct tm *tm,
|
2017-07-01 13:15:47 +00:00
|
|
|
int tz_offset, int suppress_tz_name)
|
2015-06-25 16:55:45 +00:00
|
|
|
{
|
2017-06-15 12:29:53 +00:00
|
|
|
struct strbuf munged_fmt = STRBUF_INIT;
|
2015-06-30 13:26:53 +00:00
|
|
|
size_t hint = 128;
|
2015-06-25 16:55:45 +00:00
|
|
|
size_t len;
|
|
|
|
|
2015-06-30 13:26:53 +00:00
|
|
|
if (!*fmt)
|
|
|
|
return;
|
|
|
|
|
2017-06-15 12:29:53 +00:00
|
|
|
/*
|
|
|
|
* There is no portable way to pass timezone information to
|
|
|
|
* strftime, so we handle %z and %Z here.
|
|
|
|
*/
|
|
|
|
for (;;) {
|
|
|
|
const char *percent = strchrnul(fmt, '%');
|
|
|
|
strbuf_add(&munged_fmt, fmt, percent - fmt);
|
|
|
|
if (!*percent)
|
|
|
|
break;
|
|
|
|
fmt = percent + 1;
|
|
|
|
switch (*fmt) {
|
|
|
|
case '%':
|
|
|
|
strbuf_addstr(&munged_fmt, "%%");
|
|
|
|
fmt++;
|
|
|
|
break;
|
|
|
|
case 'z':
|
|
|
|
strbuf_addf(&munged_fmt, "%+05d", tz_offset);
|
|
|
|
fmt++;
|
|
|
|
break;
|
|
|
|
case 'Z':
|
2017-07-01 13:15:47 +00:00
|
|
|
if (suppress_tz_name) {
|
2017-06-15 12:29:53 +00:00
|
|
|
fmt++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
default:
|
|
|
|
strbuf_addch(&munged_fmt, '%');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fmt = munged_fmt.buf;
|
|
|
|
|
2015-06-30 13:26:53 +00:00
|
|
|
strbuf_grow(sb, hint);
|
2015-06-25 16:55:45 +00:00
|
|
|
len = strftime(sb->buf + sb->len, sb->alloc - sb->len, fmt, tm);
|
|
|
|
|
|
|
|
if (!len) {
|
|
|
|
/*
|
2015-06-30 13:26:53 +00:00
|
|
|
* strftime reports "0" if it could not fit the result in the buffer.
|
|
|
|
* Unfortunately, it also reports "0" if the requested time string
|
|
|
|
* takes 0 bytes. So our strategy is to munge the format so that the
|
|
|
|
* output contains at least one character, and then drop the extra
|
|
|
|
* character before returning.
|
2015-06-25 16:55:45 +00:00
|
|
|
*/
|
2017-06-15 12:29:53 +00:00
|
|
|
strbuf_addch(&munged_fmt, ' ');
|
2015-06-30 13:26:53 +00:00
|
|
|
while (!len) {
|
|
|
|
hint *= 2;
|
|
|
|
strbuf_grow(sb, hint);
|
|
|
|
len = strftime(sb->buf + sb->len, sb->alloc - sb->len,
|
|
|
|
munged_fmt.buf, tm);
|
|
|
|
}
|
|
|
|
len--; /* drop munged space */
|
2015-06-25 16:55:45 +00:00
|
|
|
}
|
2017-06-15 12:29:53 +00:00
|
|
|
strbuf_release(&munged_fmt);
|
2015-06-30 13:26:53 +00:00
|
|
|
strbuf_setlen(sb, sb->len + len);
|
2015-06-25 16:55:45 +00:00
|
|
|
}
|
2015-09-24 21:05:45 +00:00
|
|
|
|
strbuf: convert strbuf_add_unique_abbrev to use struct object_id
Convert the declaration and definition of strbuf_add_unique_abbrev to
make it take a pointer to struct object_id. Predeclare the struct in
strbuf.h, as cache.h includes strbuf.h before it declares the struct,
and otherwise the struct declaration would have the wrong scope.
Apply the following semantic patch, along with the standard object_id
transforms, to adjust the callers:
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2.hash, E3);
+ strbuf_add_unique_abbrev(E1, &E2, E3);
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2->hash, E3);
+ strbuf_add_unique_abbrev(E1, E2, E3);
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:28 +00:00
|
|
|
void strbuf_add_unique_abbrev(struct strbuf *sb, const struct object_id *oid,
|
2015-09-24 21:05:45 +00:00
|
|
|
int abbrev_len)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
strbuf_grow(sb, GIT_SHA1_HEXSZ + 1);
|
2018-03-12 02:27:30 +00:00
|
|
|
r = find_unique_abbrev_r(sb->buf + sb->len, oid, abbrev_len);
|
2015-09-24 21:05:45 +00:00
|
|
|
strbuf_setlen(sb, sb->len + r);
|
|
|
|
}
|
2015-10-26 22:55:20 +00:00
|
|
|
|
2015-10-16 15:16:42 +00:00
|
|
|
/*
|
|
|
|
* Returns the length of a line, without trailing spaces.
|
|
|
|
*
|
|
|
|
* If the line ends with newline, it will be removed too.
|
|
|
|
*/
|
|
|
|
static size_t cleanup(char *line, size_t len)
|
|
|
|
{
|
|
|
|
while (len) {
|
|
|
|
unsigned char c = line[len - 1];
|
|
|
|
if (!isspace(c))
|
|
|
|
break;
|
|
|
|
len--;
|
|
|
|
}
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove empty lines from the beginning and end
|
|
|
|
* and also trailing spaces from every line.
|
|
|
|
*
|
|
|
|
* Turn multiple consecutive empty lines between paragraphs
|
|
|
|
* into just one empty line.
|
|
|
|
*
|
|
|
|
* If the input has only empty lines and spaces,
|
|
|
|
* no output will be produced.
|
|
|
|
*
|
|
|
|
* If last line does not have a newline at the end, one is added.
|
|
|
|
*
|
|
|
|
* Enable skip_comments to skip every line starting with comment
|
|
|
|
* character.
|
|
|
|
*/
|
|
|
|
void strbuf_stripspace(struct strbuf *sb, int skip_comments)
|
|
|
|
{
|
|
|
|
int empties = 0;
|
|
|
|
size_t i, j, len, newlen;
|
|
|
|
char *eol;
|
|
|
|
|
|
|
|
/* We may have to add a newline. */
|
|
|
|
strbuf_grow(sb, 1);
|
|
|
|
|
|
|
|
for (i = j = 0; i < sb->len; i += len, j += newlen) {
|
|
|
|
eol = memchr(sb->buf + i, '\n', sb->len - i);
|
|
|
|
len = eol ? eol - (sb->buf + i) + 1 : sb->len - i;
|
|
|
|
|
|
|
|
if (skip_comments && len && sb->buf[i] == comment_line_char) {
|
|
|
|
newlen = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
newlen = cleanup(sb->buf + i, len);
|
|
|
|
|
|
|
|
/* Not just an empty line? */
|
|
|
|
if (newlen) {
|
|
|
|
if (empties > 0 && j > 0)
|
|
|
|
sb->buf[j++] = '\n';
|
|
|
|
empties = 0;
|
|
|
|
memmove(sb->buf + j, sb->buf + i, newlen);
|
|
|
|
sb->buf[newlen + j++] = '\n';
|
|
|
|
} else {
|
|
|
|
empties++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_setlen(sb, j);
|
|
|
|
}
|
link_alt_odb_entry: handle normalize_path errors
When we add a new alternate to the list, we try to normalize
out any redundant "..", etc. However, we do not look at the
return value of normalize_path_copy(), and will happily
continue with a path that could not be normalized. Worse,
the normalizing process is done in-place, so we are left
with whatever half-finished working state the normalizing
function was in.
Fortunately, this cannot cause us to read past the end of
our buffer, as that working state will always leave the
NUL from the original path in place. And we do tend to
notice problems when we check is_directory() on the path.
But you can see the nonsense that we feed to is_directory
with an entry like:
this/../../is/../../way/../../too/../../deep/../../to/../../resolve
in your objects/info/alternates, which yields:
error: object directory
/to/e/deep/too/way//ects/this/../../is/../../way/../../too/../../deep/../../to/../../resolve
does not exist; check .git/objects/info/alternates.
We can easily fix this just by checking the return value.
But that makes it hard to generate a good error message,
since we're normalizing in-place and our input value has
been overwritten by cruft.
Instead, let's provide a strbuf helper that does an in-place
normalize, but restores the original contents on error. This
uses a second buffer under the hood, which is slightly less
efficient, but this is not a performance-critical code path.
The strbuf helper can also properly set the "len" parameter
of the strbuf before returning. Just doing:
normalize_path_copy(buf.buf, buf.buf);
will shorten the string, but leave buf.len at the original
length. That may be confusing to later code which uses the
strbuf.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-10-03 20:34:17 +00:00
|
|
|
|
|
|
|
int strbuf_normalize_path(struct strbuf *src)
|
|
|
|
{
|
|
|
|
struct strbuf dst = STRBUF_INIT;
|
|
|
|
|
|
|
|
strbuf_grow(&dst, src->len);
|
|
|
|
if (normalize_path_copy(dst.buf, src->buf) < 0) {
|
|
|
|
strbuf_release(&dst);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* normalize_path does not tell us the new length, so we have to
|
|
|
|
* compute it by looking for the new NUL it placed
|
|
|
|
*/
|
|
|
|
strbuf_setlen(&dst, strlen(dst.buf));
|
|
|
|
strbuf_swap(src, &dst);
|
|
|
|
strbuf_release(&dst);
|
|
|
|
return 0;
|
|
|
|
}
|