LXR linux/tools/perf/util/strbuf.c

   1#include "cache.h"
   2
   3int prefixcmp(const char *str, const char *prefix)
   4{
   5        for (; ; str++, prefix++)
   6                if (!*prefix)
   7                        return 0;
   8                else if (*str != *prefix)
   9                        return (unsigned char)*prefix - (unsigned char)*str;
  10}
  11
  12/*
  13 * Used as the default ->buf value, so that people can always assume
  14 * buf is non NULL and ->buf is NUL terminated even for a freshly
  15 * initialized strbuf.
  16 */
  17char strbuf_slopbuf[1];
  18
  19void strbuf_init(struct strbuf *sb, ssize_t hint)
  20{
  21        sb->alloc = sb->len = 0;
  22        sb->buf = strbuf_slopbuf;
  23        if (hint)
  24                strbuf_grow(sb, hint);
  25}
  26
  27void strbuf_release(struct strbuf *sb)
  28{
  29        if (sb->alloc) {
  30                free(sb->buf);
  31                strbuf_init(sb, 0);
  32        }
  33}
  34
  35char *strbuf_detach(struct strbuf *sb, size_t *sz)
  36{
  37        char *res = sb->alloc ? sb->buf : NULL;
  38        if (sz)
  39                *sz = sb->len;
  40        strbuf_init(sb, 0);
  41        return res;
  42}
  43
  44void strbuf_grow(struct strbuf *sb, size_t extra)
  45{
  46        if (sb->len + extra + 1 <= sb->len)
  47                die("you want to use way too much memory");
  48        if (!sb->alloc)
  49                sb->buf = NULL;
  50        ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);
  51}
  52
  53static void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
  54                                   const void *data, size_t dlen)
  55{
  56        if (pos + len < pos)
  57                die("you want to use way too much memory");
  58        if (pos > sb->len)
  59                die("`pos' is too far after the end of the buffer");
  60        if (pos + len > sb->len)
  61                die("`pos + len' is too far after the end of the buffer");
  62
  63        if (dlen >= len)
  64                strbuf_grow(sb, dlen - len);
  65        memmove(sb->buf + pos + dlen,
  66                        sb->buf + pos + len,
  67                        sb->len - pos - len);
  68        memcpy(sb->buf + pos, data, dlen);
  69        strbuf_setlen(sb, sb->len + dlen - len);
  70}
  71
  72void strbuf_remove(struct strbuf *sb, size_t pos, size_t len)
  73{
  74        strbuf_splice(sb, pos, len, NULL, 0);
  75}
  76
  77void strbuf_add(struct strbuf *sb, const void *data, size_t len)
  78{
  79        strbuf_grow(sb, len);
  80        memcpy(sb->buf + sb->len, data, len);
  81        strbuf_setlen(sb, sb->len + len);
  82}
  83
  84void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
  85{
  86        int len;
  87        va_list ap;
  88
  89        if (!strbuf_avail(sb))
  90                strbuf_grow(sb, 64);
  91        va_start(ap, fmt);
  92        len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
  93        va_end(ap);
  94        if (len < 0)
  95                die("your vsnprintf is broken");
  96        if (len > strbuf_avail(sb)) {
  97                strbuf_grow(sb, len);
  98                va_start(ap, fmt);
  99                len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
 100                va_end(ap);
 101                if (len > strbuf_avail(sb)) {
 102                        die("this should not happen, your snprintf is broken");
 103                }
 104        }
 105        strbuf_setlen(sb, sb->len + len);
 106}
 107
 108ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint)
 109{
 110        size_t oldlen = sb->len;
 111        size_t oldalloc = sb->alloc;
 112
 113        strbuf_grow(sb, hint ? hint : 8192);
 114        for (;;) {
 115                ssize_t cnt;
 116
 117                cnt = read(fd, sb->buf + sb->len, sb->alloc - sb->len - 1);
 118                if (cnt < 0) {
 119                        if (oldalloc == 0)
 120                                strbuf_release(sb);
 121                        else
 122                                strbuf_setlen(sb, oldlen);
 123                        return -1;
 124                }
 125                if (!cnt)
 126                        break;
 127                sb->len += cnt;
 128                strbuf_grow(sb, 8192);
 129        }
 130
 131        sb->buf[sb->len] = '\0';
 132        return sb->len - oldlen;
 133}
 134