2005-04-26 19:00:58 +00:00
|
|
|
#include "cache.h"
|
2009-03-21 21:35:51 +00:00
|
|
|
#include "refs.h"
|
2005-04-26 01:26:45 +00:00
|
|
|
|
2008-01-03 09:23:12 +00:00
|
|
|
int prefixcmp(const char *str, const char *prefix)
|
|
|
|
{
|
|
|
|
for (; ; str++, prefix++)
|
|
|
|
if (!*prefix)
|
|
|
|
return 0;
|
|
|
|
else if (*str != *prefix)
|
|
|
|
return (unsigned char)*prefix - (unsigned char)*str;
|
|
|
|
}
|
|
|
|
|
2009-11-26 02:23:55 +00:00
|
|
|
int suffixcmp(const char *str, const char *suffix)
|
|
|
|
{
|
|
|
|
int len = strlen(str), suflen = strlen(suffix);
|
|
|
|
if (len < suflen)
|
|
|
|
return -1;
|
|
|
|
else
|
|
|
|
return strcmp(str + len - suflen, suffix);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2007-09-27 10:58:23 +00:00
|
|
|
char *res = sb->alloc ? sb->buf : NULL;
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
char *b = sb->buf;
|
|
|
|
while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
|
|
|
|
sb->len--;
|
|
|
|
while (sb->len > 0 && isspace(*b)) {
|
|
|
|
b++;
|
|
|
|
sb->len--;
|
|
|
|
}
|
|
|
|
memmove(sb->buf, b, sb->len);
|
|
|
|
sb->buf[sb->len] = '\0';
|
|
|
|
}
|
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';
|
|
|
|
}
|
|
|
|
|
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';
|
|
|
|
}
|
|
|
|
|
2011-06-09 15:54:58 +00:00
|
|
|
struct strbuf **strbuf_split_buf(const char *str, size_t slen, int delim, int max)
|
2008-07-13 18:29:18 +00:00
|
|
|
{
|
|
|
|
int alloc = 2, pos = 0;
|
2011-06-09 15:54:58 +00:00
|
|
|
const char *n, *p;
|
2008-07-13 18:29:18 +00:00
|
|
|
struct strbuf **ret;
|
|
|
|
struct strbuf *t;
|
|
|
|
|
|
|
|
ret = xcalloc(alloc, sizeof(struct strbuf *));
|
2011-06-09 15:54:58 +00:00
|
|
|
p = n = str;
|
|
|
|
while (n < str + slen) {
|
2008-07-13 18:29:18 +00:00
|
|
|
int len;
|
2011-06-09 15:51:22 +00:00
|
|
|
if (max <= 0 || pos + 1 < max)
|
2011-06-09 15:54:58 +00:00
|
|
|
n = memchr(n, delim, slen - (n - str));
|
2011-06-09 15:51:22 +00:00
|
|
|
else
|
|
|
|
n = NULL;
|
2008-07-13 18:29:18 +00:00
|
|
|
if (pos + 1 >= alloc) {
|
|
|
|
alloc = alloc * 2;
|
|
|
|
ret = xrealloc(ret, sizeof(struct strbuf *) * alloc);
|
|
|
|
}
|
|
|
|
if (!n)
|
2011-06-09 15:54:58 +00:00
|
|
|
n = str + slen - 1;
|
2008-07-13 18:29:18 +00:00
|
|
|
len = n - p + 1;
|
|
|
|
t = xmalloc(sizeof(struct strbuf));
|
|
|
|
strbuf_init(t, len);
|
|
|
|
strbuf_add(t, p, len);
|
|
|
|
ret[pos] = t;
|
|
|
|
ret[++pos] = NULL;
|
|
|
|
p = ++n;
|
|
|
|
}
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
strbuf_splice(sb, pos, len, NULL, 0);
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-11-10 11:16:05 +00:00
|
|
|
void strbuf_adddup(struct strbuf *sb, size_t pos, size_t len)
|
|
|
|
{
|
|
|
|
strbuf_grow(sb, len);
|
|
|
|
memcpy(sb->buf + sb->len, sb->buf + pos, len);
|
|
|
|
strbuf_setlen(sb, sb->len + len);
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 (;;) {
|
|
|
|
ssize_t cnt;
|
|
|
|
|
|
|
|
cnt = xread(fd, sb->buf + sb->len, sb->alloc - sb->len - 1);
|
|
|
|
if (cnt < 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;
|
|
|
|
}
|
|
|
|
if (!cnt)
|
|
|
|
break;
|
|
|
|
sb->len += cnt;
|
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
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
|
|
|
strbuf_grow(sb, 0);
|
|
|
|
if (feof(fp))
|
|
|
|
return EOF;
|
2007-09-06 11:20:05 +00:00
|
|
|
|
|
|
|
strbuf_reset(sb);
|
2005-04-26 01:26:45 +00:00
|
|
|
while ((ch = fgetc(fp)) != EOF) {
|
2007-09-06 11:20:05 +00:00
|
|
|
strbuf_grow(sb, 1);
|
|
|
|
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
|
|
|
}
|
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
|
|
|
}
|
2007-09-18 00:06:46 +00:00
|
|
|
|
2009-08-05 03:31:56 +00:00
|
|
|
int strbuf_getline(struct strbuf *sb, FILE *fp, int term)
|
|
|
|
{
|
|
|
|
if (strbuf_getwholeline(sb, fp, term))
|
|
|
|
return EOF;
|
|
|
|
if (sb->buf[sb->len-1] == term)
|
|
|
|
strbuf_setlen(sb, sb->len-1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-27 13:25:55 +00:00
|
|
|
int strbuf_read_file(struct strbuf *sb, const char *path, size_t hint)
|
2007-09-18 00:06:46 +00:00
|
|
|
{
|
|
|
|
int fd, len;
|
|
|
|
|
|
|
|
fd = open(path, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return -1;
|
2007-09-27 13:25:55 +00:00
|
|
|
len = strbuf_read(sb, fd, hint);
|
2007-09-18 00:06:46 +00:00
|
|
|
close(fd);
|
|
|
|
if (len < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|