Andrew's git - gitweb.git/blob

   1#include "cache.h"
   2
   3void strbuf_init(struct strbuf *sb, size_t hint)
   4{
   5        memset(sb, 0, sizeof(*sb));
   6        if (hint)
   7                strbuf_grow(sb, hint);
   8}
   9
  10void strbuf_release(struct strbuf *sb)
  11{
  12        free(sb->buf);
  13        memset(sb, 0, sizeof(*sb));
  14}
  15
  16void strbuf_reset(struct strbuf *sb)
  17{
  18        if (sb->len)
  19                strbuf_setlen(sb, 0);
  20        sb->eof = 0;
  21}
  22
  23char *strbuf_detach(struct strbuf *sb)
  24{
  25        char *res = sb->buf;
  26        strbuf_init(sb, 0);
  27        return res;
  28}
  29
  30void strbuf_attach(struct strbuf *sb, void *buf, size_t len, size_t alloc)
  31{
  32        strbuf_release(sb);
  33        sb->buf   = buf;
  34        sb->len   = len;
  35        sb->alloc = alloc;
  36        strbuf_grow(sb, 0);
  37        sb->buf[sb->len] = '\0';
  38}
  39
  40void strbuf_grow(struct strbuf *sb, size_t extra)
  41{
  42        if (sb->len + extra + 1 <= sb->len)
  43                die("you want to use way too much memory");
  44        ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);
  45}
  46
  47void strbuf_rtrim(struct strbuf *sb)
  48{
  49        while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
  50                sb->len--;
  51        sb->buf[sb->len] = '\0';
  52}
  53
  54void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len)
  55{
  56        strbuf_grow(sb, len);
  57        if (pos > sb->len)
  58                die("`pos' is too far after the end of the buffer");
  59        memmove(sb->buf + pos + len, sb->buf + pos, sb->len - pos);
  60        memcpy(sb->buf + pos, data, len);
  61        strbuf_setlen(sb, sb->len + len);
  62}
  63
  64void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
  65                                   const void *data, size_t dlen)
  66{
  67        if (pos + len < pos)
  68                die("you want to use way too much memory");
  69        if (pos > sb->len)
  70                die("`pos' is too far after the end of the buffer");
  71        if (pos + len > sb->len)
  72                die("`pos + len' is too far after the end of the buffer");
  73
  74        if (dlen >= len)
  75                strbuf_grow(sb, dlen - len);
  76        memmove(sb->buf + pos + dlen,
  77                        sb->buf + pos + len,
  78                        sb->len - pos - len);
  79        memcpy(sb->buf + pos, data, dlen);
  80        strbuf_setlen(sb, sb->len + dlen - len);
  81}
  82
  83void strbuf_add(struct strbuf *sb, const void *data, size_t len)
  84{
  85        strbuf_grow(sb, len);
  86        memcpy(sb->buf + sb->len, data, len);
  87        strbuf_setlen(sb, sb->len + len);
  88}
  89
  90void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
  91{
  92        int len;
  93        va_list ap;
  94
  95        va_start(ap, fmt);
  96        len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
  97        va_end(ap);
  98        if (len < 0) {
  99                len = 0;
 100        }
 101        if (len > strbuf_avail(sb)) {
 102                strbuf_grow(sb, len);
 103                va_start(ap, fmt);
 104                len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
 105                va_end(ap);
 106                if (len > strbuf_avail(sb)) {
 107                        die("this should not happen, your snprintf is broken");
 108                }
 109        }
 110        strbuf_setlen(sb, sb->len + len);
 111}
 112
 113size_t strbuf_fread(struct strbuf *sb, size_t size, FILE *f)
 114{
 115        size_t res;
 116
 117        strbuf_grow(sb, size);
 118        res = fread(sb->buf + sb->len, 1, size, f);
 119        if (res > 0) {
 120                strbuf_setlen(sb, sb->len + res);
 121        }
 122        return res;
 123}
 124
 125ssize_t strbuf_read(struct strbuf *sb, int fd, size_t hint)
 126{
 127        size_t oldlen = sb->len;
 128
 129        strbuf_grow(sb, hint ? hint : 8192);
 130        for (;;) {
 131                ssize_t cnt;
 132
 133                cnt = xread(fd, sb->buf + sb->len, sb->alloc - sb->len - 1);
 134                if (cnt < 0) {
 135                        strbuf_setlen(sb, oldlen);
 136                        return -1;
 137                }
 138                if (!cnt)
 139                        break;
 140                sb->len += cnt;
 141                strbuf_grow(sb, 8192);
 142        }
 143
 144        sb->buf[sb->len] = '\0';
 145        return sb->len - oldlen;
 146}
 147
 148void read_line(struct strbuf *sb, FILE *fp, int term)
 149{
 150        int ch;
 151        if (feof(fp)) {
 152                strbuf_release(sb);
 153                sb->eof = 1;
 154                return;
 155        }
 156
 157        strbuf_reset(sb);
 158        while ((ch = fgetc(fp)) != EOF) {
 159                if (ch == term)
 160                        break;
 161                strbuf_grow(sb, 1);
 162                sb->buf[sb->len++] = ch;
 163        }
 164        if (ch == EOF && sb->len == 0) {
 165                strbuf_release(sb);
 166                sb->eof = 1;
 167        }
 168
 169        strbuf_grow(sb, 1);
 170        sb->buf[sb->len] = '\0';
 171}