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

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