]>
Commit | Line | Data |
---|---|---|
812666c8 | 1 | #include "cache.h" |
d1df5743 | 2 | |
b315c5c0 PH |
3 | /* |
4 | * Used as the default ->buf value, so that people can always assume | |
5 | * buf is non NULL and ->buf is NUL terminated even for a freshly | |
6 | * initialized strbuf. | |
7 | */ | |
8 | char strbuf_slopbuf[1]; | |
9 | ||
917c9a71 PH |
10 | void strbuf_init(struct strbuf *sb, size_t hint) |
11 | { | |
b315c5c0 PH |
12 | sb->alloc = sb->len = 0; |
13 | sb->buf = strbuf_slopbuf; | |
f1696ee3 PH |
14 | if (hint) |
15 | strbuf_grow(sb, hint); | |
d1df5743 JH |
16 | } |
17 | ||
917c9a71 PH |
18 | void strbuf_release(struct strbuf *sb) |
19 | { | |
b315c5c0 PH |
20 | if (sb->alloc) { |
21 | free(sb->buf); | |
22 | strbuf_init(sb, 0); | |
23 | } | |
b449f4cf PH |
24 | } |
25 | ||
b315c5c0 | 26 | char *strbuf_detach(struct strbuf *sb, size_t *sz) |
917c9a71 | 27 | { |
b315c5c0 PH |
28 | char *res = sb->alloc ? sb->buf : NULL; |
29 | if (sz) | |
30 | *sz = sb->len; | |
f1696ee3 | 31 | strbuf_init(sb, 0); |
b449f4cf PH |
32 | return res; |
33 | } | |
34 | ||
917c9a71 PH |
35 | void strbuf_attach(struct strbuf *sb, void *buf, size_t len, size_t alloc) |
36 | { | |
37 | strbuf_release(sb); | |
38 | sb->buf = buf; | |
39 | sb->len = len; | |
40 | sb->alloc = alloc; | |
41 | strbuf_grow(sb, 0); | |
42 | sb->buf[sb->len] = '\0'; | |
43 | } | |
44 | ||
45 | void strbuf_grow(struct strbuf *sb, size_t extra) | |
46 | { | |
b449f4cf PH |
47 | if (sb->len + extra + 1 <= sb->len) |
48 | die("you want to use way too much memory"); | |
b315c5c0 PH |
49 | if (!sb->alloc) |
50 | sb->buf = NULL; | |
b449f4cf PH |
51 | ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc); |
52 | } | |
53 | ||
f1696ee3 PH |
54 | void strbuf_rtrim(struct strbuf *sb) |
55 | { | |
56 | while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1])) | |
57 | sb->len--; | |
58 | sb->buf[sb->len] = '\0'; | |
59 | } | |
60 | ||
45f66f64 PH |
61 | int strbuf_cmp(struct strbuf *a, struct strbuf *b) |
62 | { | |
63 | int cmp; | |
64 | if (a->len < b->len) { | |
65 | cmp = memcmp(a->buf, b->buf, a->len); | |
66 | return cmp ? cmp : -1; | |
67 | } else { | |
68 | cmp = memcmp(a->buf, b->buf, b->len); | |
69 | return cmp ? cmp : a->len != b->len; | |
70 | } | |
71 | } | |
72 | ||
917c9a71 PH |
73 | void strbuf_splice(struct strbuf *sb, size_t pos, size_t len, |
74 | const void *data, size_t dlen) | |
75 | { | |
76 | if (pos + len < pos) | |
77 | die("you want to use way too much memory"); | |
78 | if (pos > sb->len) | |
79 | die("`pos' is too far after the end of the buffer"); | |
80 | if (pos + len > sb->len) | |
81 | die("`pos + len' is too far after the end of the buffer"); | |
82 | ||
83 | if (dlen >= len) | |
84 | strbuf_grow(sb, dlen - len); | |
85 | memmove(sb->buf + pos + dlen, | |
86 | sb->buf + pos + len, | |
87 | sb->len - pos - len); | |
88 | memcpy(sb->buf + pos, data, dlen); | |
89 | strbuf_setlen(sb, sb->len + dlen - len); | |
90 | } | |
91 | ||
c76689df PH |
92 | void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len) |
93 | { | |
94 | strbuf_splice(sb, pos, 0, data, len); | |
95 | } | |
96 | ||
97 | void strbuf_remove(struct strbuf *sb, size_t pos, size_t len) | |
98 | { | |
99 | strbuf_splice(sb, pos, len, NULL, 0); | |
100 | } | |
101 | ||
917c9a71 PH |
102 | void strbuf_add(struct strbuf *sb, const void *data, size_t len) |
103 | { | |
b449f4cf PH |
104 | strbuf_grow(sb, len); |
105 | memcpy(sb->buf + sb->len, data, len); | |
106 | strbuf_setlen(sb, sb->len + len); | |
107 | } | |
108 | ||
917c9a71 PH |
109 | void strbuf_addf(struct strbuf *sb, const char *fmt, ...) |
110 | { | |
b449f4cf PH |
111 | int len; |
112 | va_list ap; | |
113 | ||
114 | va_start(ap, fmt); | |
115 | len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap); | |
116 | va_end(ap); | |
117 | if (len < 0) { | |
118 | len = 0; | |
119 | } | |
f1696ee3 | 120 | if (len > strbuf_avail(sb)) { |
b449f4cf PH |
121 | strbuf_grow(sb, len); |
122 | va_start(ap, fmt); | |
123 | len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap); | |
124 | va_end(ap); | |
f1696ee3 | 125 | if (len > strbuf_avail(sb)) { |
b449f4cf PH |
126 | die("this should not happen, your snprintf is broken"); |
127 | } | |
128 | } | |
129 | strbuf_setlen(sb, sb->len + len); | |
d1df5743 JH |
130 | } |
131 | ||
917c9a71 PH |
132 | size_t strbuf_fread(struct strbuf *sb, size_t size, FILE *f) |
133 | { | |
b449f4cf PH |
134 | size_t res; |
135 | ||
136 | strbuf_grow(sb, size); | |
137 | res = fread(sb->buf + sb->len, 1, size, f); | |
138 | if (res > 0) { | |
139 | strbuf_setlen(sb, sb->len + res); | |
d1df5743 | 140 | } |
b449f4cf | 141 | return res; |
d1df5743 JH |
142 | } |
143 | ||
f1696ee3 | 144 | ssize_t strbuf_read(struct strbuf *sb, int fd, size_t hint) |
b449f4cf PH |
145 | { |
146 | size_t oldlen = sb->len; | |
147 | ||
f1696ee3 | 148 | strbuf_grow(sb, hint ? hint : 8192); |
b449f4cf PH |
149 | for (;;) { |
150 | ssize_t cnt; | |
151 | ||
b449f4cf PH |
152 | cnt = xread(fd, sb->buf + sb->len, sb->alloc - sb->len - 1); |
153 | if (cnt < 0) { | |
154 | strbuf_setlen(sb, oldlen); | |
155 | return -1; | |
156 | } | |
157 | if (!cnt) | |
158 | break; | |
159 | sb->len += cnt; | |
f1696ee3 | 160 | strbuf_grow(sb, 8192); |
b449f4cf PH |
161 | } |
162 | ||
163 | sb->buf[sb->len] = '\0'; | |
164 | return sb->len - oldlen; | |
d1df5743 JH |
165 | } |
166 | ||
e6c019d0 | 167 | int strbuf_getline(struct strbuf *sb, FILE *fp, int term) |
917c9a71 | 168 | { |
d1df5743 | 169 | int ch; |
e6c019d0 PH |
170 | |
171 | strbuf_grow(sb, 0); | |
172 | if (feof(fp)) | |
173 | return EOF; | |
b449f4cf PH |
174 | |
175 | strbuf_reset(sb); | |
d1df5743 JH |
176 | while ((ch = fgetc(fp)) != EOF) { |
177 | if (ch == term) | |
178 | break; | |
b449f4cf PH |
179 | strbuf_grow(sb, 1); |
180 | sb->buf[sb->len++] = ch; | |
d1df5743 | 181 | } |
e6c019d0 PH |
182 | if (ch == EOF && sb->len == 0) |
183 | return EOF; | |
b449f4cf | 184 | |
b449f4cf | 185 | sb->buf[sb->len] = '\0'; |
e6c019d0 | 186 | return 0; |
d1df5743 | 187 | } |
a9390b9f | 188 | |
387e7e19 | 189 | int strbuf_read_file(struct strbuf *sb, const char *path, size_t hint) |
a9390b9f KH |
190 | { |
191 | int fd, len; | |
192 | ||
193 | fd = open(path, O_RDONLY); | |
194 | if (fd < 0) | |
195 | return -1; | |
387e7e19 | 196 | len = strbuf_read(sb, fd, hint); |
a9390b9f KH |
197 | close(fd); |
198 | if (len < 0) | |
199 | return -1; | |
200 | ||
201 | return len; | |
202 | } |