@@ -5,41 +5,23 @@
55
66 #include "util.h"
77 #include "highlight.h"
8-#include "util.h"
9-
10-static void strv_clear(char **v, size_t *n) {
11- for (size_t i = 0; i < *n; i++) free(v[i]);
12- *n = 0;
13-}
14-
15-static void strv_free(char **v, size_t n) {
16- for (size_t i = 0; i < n; i++) free(v[i]);
17- free(v);
18-}
198
209 // ---- body line lists -------------------------------------------------------
2110
2211 void bl_push(tiny_blist *l, char *text, tiny_fg_fn style, const char *bg) {
2312 if (l->n == l->cap) {
2413 l->cap = l->cap ? l->cap * 2 : 16;
25- l->v = realloc(l->v, l->cap * sizeof *l->v);
26- if (!l->v) abort();
14+ l->v = xrealloc(l->v, l->cap * sizeof *l->v);
2715 }
2816 l->v[l->n++] = (tiny_body_line){text, style, bg};
2917 }
3018
31-tiny_body_line *bl_take(tiny_blist *l, size_t *count) {
32- *count = l->n;
33- if (l->n == 0) {
34- free(l->v);
35- return NULL;
36- }
37- return l->v;
38-}
39-
40-void tiny_body_lines_free(tiny_body_line *lines, size_t count) {
41- for (size_t i = 0; i < count; i++) free(lines[i].text);
42- free(lines);
19+void bl_free(tiny_blist *l) {
20+ for (size_t i = 0; i < l->n; i++) free(l->v[i].text);
21+ free(l->v);
22+ l->v = NULL;
23+ l->n = 0;
24+ l->cap = 0;
4325 }
4426
4527 // ---- fence parsing ---------------------------------------------------------
@@ -96,10 +78,8 @@ void tiny_mdstream_free(tiny_mdstream *s) {
9678 free(s->rest);
9779 free(s->fence_marker);
9880 free(s->fence_info);
99- strv_clear(s->fence_lines, &s->fence_n);
100- free(s->fence_lines);
101- strv_clear(s->prose, &s->prose_n);
102- free(s->prose);
81+ strv_free(&s->fence_lines);
82+ strv_free(&s->prose);
10383 memset(s, 0, sizeof *s);
10484 }
10585
@@ -110,29 +90,26 @@ void tiny_mdstream_reset(tiny_mdstream *s) {
11090 s->fence_marker = NULL;
11191 free(s->fence_info);
11292 s->fence_info = NULL;
113- strv_clear(s->fence_lines, &s->fence_n);
114- strv_clear(s->prose, &s->prose_n);
93+ strv_free(&s->fence_lines);
94+ strv_free(&s->prose);
11595 }
11696
11797 // Emits the held prose as one highlighted block.
11898 static void release_prose(tiny_mdstream *s, const char *tail, tiny_blist *out) {
119- char **prose = s->prose;
120- size_t n = s->prose_n;
121- s->prose = NULL;
122- s->prose_n = 0;
123- s->prose_cap = 0;
99+ tiny_strv prose = s->prose;
100+ memset(&s->prose, 0, sizeof s->prose);
124101
125102 tui_buf joined;
126103 buf_init(&joined);
127- for (size_t i = 0; i < n; i++) {
104+ for (size_t i = 0; i < prose.n; i++) {
128105 if (i) buf_addc(&joined, '\n');
129- buf_adds(&joined, prose[i]);
106+ buf_adds(&joined, prose.v[i]);
130107 }
131108 if (tail[0]) {
132- if (n) buf_addc(&joined, '\n');
109+ if (prose.n) buf_addc(&joined, '\n');
133110 buf_adds(&joined, tail);
134111 }
135- strv_free(prose, n);
112+ strv_free(&prose);
136113 if (joined.len == 0) {
137114 buf_free(&joined);
138115 return;
@@ -142,49 +119,45 @@ static void release_prose(tiny_mdstream *s, const char *tail, tiny_blist *out) {
142119 buf_addc(&joined, '\n');
143120 char *colored = tiny_highlight_markdown(joined.data);
144121 buf_free(&joined);
145- size_t nlines;
146- char **lines = tiny_split_lines(colored, &nlines);
122+ tiny_strv lines = tiny_split_lines(colored);
147123 // The split adds a trailing line holding the closing reset; attach it.
148- if (nlines > 1) {
149- char *reset = lines[nlines - 1];
124+ if (lines.n > 1) {
125+ char *reset = lines.v[lines.n - 1];
150126 tui_buf last;
151127 buf_init(&last);
152- buf_adds(&last, lines[nlines - 2]);
128+ buf_adds(&last, lines.v[lines.n - 2]);
153129 buf_adds(&last, reset);
154- free(lines[nlines - 2]);
130+ free(lines.v[lines.n - 2]);
155131 free(reset);
156- lines[nlines - 2] = buf_steal(&last);
157- buf_free(&last);
158- nlines--;
132+ lines.v[lines.n - 2] = buf_steal(&last);
133+ lines.n--;
159134 }
160- for (size_t i = 0; i < nlines; i++) bl_push(out, lines[i], NULL, NULL);
161- free(lines);
135+ for (size_t i = 0; i < lines.n; i++) bl_push(out, lines.v[i], NULL, NULL);
136+ free(lines.v);
162137 free(colored);
163138 }
164139
165140 static void release_fence(tiny_mdstream *s, const char *closing, tiny_blist *out) {
166141 // The opening fence line, colored as markdown.
167- char *first = s->fence_lines[0];
142+ char *first = s->fence_lines.v[0];
168143 char *first_col = tiny_highlight_markdown(first);
169144 bl_push(out, first_col, NULL, NULL);
170- size_t n = s->fence_n;
145+ size_t n = s->fence_lines.n;
171146 if (n > 1) {
172147 tui_buf body;
173148 buf_init(&body);
174149 for (size_t i = 1; i < n; i++) {
175150 if (i > 1) buf_addc(&body, '\n');
176- buf_adds(&body, s->fence_lines[i]);
151+ buf_adds(&body, s->fence_lines.v[i]);
177152 }
178153 char *colored = tiny_highlight_code(s->fence_info, body.data);
179154 buf_free(&body);
180- size_t nlines;
181- char **lines = tiny_split_lines(colored, &nlines);
182- for (size_t i = 0; i < nlines; i++) bl_push(out, lines[i], NULL, NULL);
183- free(lines);
155+ tiny_strv lines = tiny_split_lines(colored);
156+ for (size_t i = 0; i < lines.n; i++) bl_push(out, lines.v[i], NULL, NULL);
157+ free(lines.v);
184158 free(colored);
185159 }
186- for (size_t i = 0; i < n; i++) free(s->fence_lines[i]);
187- s->fence_n = 0;
160+ strv_free(&s->fence_lines);
188161 free(s->fence_marker);
189162 s->fence_marker = NULL;
190163 free(s->fence_info);
@@ -205,14 +178,14 @@ static void commit_line(tiny_mdstream *s, const char *line, tiny_blist *out) {
205178 return;
206179 }
207180 free(close);
208- tiny_strv_push(&s->fence_lines, &s->fence_n, &s->fence_cap, xstrdup(line));
181+ strv_push(&s->fence_lines, xstrdup(line));
209182 return;
210183 }
211184 char *marker = NULL, *info = NULL;
212185 if (fence_open(line, &marker, &info)) {
213186 s->fence_marker = marker;
214187 s->fence_info = info;
215- tiny_strv_push(&s->fence_lines, &s->fence_n, &s->fence_cap, xstrdup(line));
188+ strv_push(&s->fence_lines, xstrdup(line));
216189 release_prose(s, "", out);
217190 return;
218191 }
@@ -223,10 +196,10 @@ static void commit_line(tiny_mdstream *s, const char *line, tiny_blist *out) {
223196 bl_push(out, xstrdup(line), NULL, NULL);
224197 return;
225198 }
226- tiny_strv_push(&s->prose, &s->prose_n, &s->prose_cap, xstrdup(line));
199+ strv_push(&s->prose, xstrdup(line));
227200 }
228201
229-tiny_body_line *tiny_mdstream_feed(tiny_mdstream *s, const char *delta, size_t *count) {
202+tiny_blist tiny_mdstream_feed(tiny_mdstream *s, const char *delta) {
230203 tiny_blist out = {0};
231204 size_t rest_len = strlen(s->rest);
232205 size_t dl = strlen(delta);
@@ -235,29 +208,27 @@ tiny_body_line *tiny_mdstream_feed(tiny_mdstream *s, const char *delta, size_t *
235208 memcpy(joined + rest_len, delta, dl + 1);
236209 free(s->rest);
237210
238- size_t nlines;
239- char **lines = tiny_split_lines(joined, &nlines);
211+ tiny_strv lines = tiny_split_lines(joined);
240212 // The last split part is the still-incomplete tail.
241- s->rest = lines[nlines - 1];
242- for (size_t i = 0; i + 1 < nlines; i++) {
243- commit_line(s, lines[i], &out);
244- free(lines[i]);
213+ s->rest = lines.v[lines.n - 1];
214+ for (size_t i = 0; i + 1 < lines.n; i++) {
215+ commit_line(s, lines.v[i], &out);
216+ free(lines.v[i]);
245217 }
246- free(lines);
218+ free(lines.v);
247219 free(joined);
248- return bl_take(&out, count);
220+ return out;
249221 }
250222
251-tiny_body_line *tiny_mdstream_pending(tiny_mdstream *s, size_t *count) {
223+tiny_blist tiny_mdstream_pending(tiny_mdstream *s) {
252224 tiny_blist out = {0};
253- char **held = s->fence_marker ? s->fence_lines : s->prose;
254- size_t n = s->fence_marker ? s->fence_n : s->prose_n;
255- for (size_t i = 0; i < n; i++) bl_push(&out, xstrdup(held[i]), NULL, NULL);
225+ tiny_strv *held = s->fence_marker ? &s->fence_lines : &s->prose;
226+ for (size_t i = 0; i < held->n; i++) bl_push(&out, xstrdup(held->v[i]), NULL, NULL);
256227 if (s->rest[0]) bl_push(&out, xstrdup(s->rest), NULL, NULL);
257- return bl_take(&out, count);
228+ return out;
258229 }
259230
260-tiny_body_line *tiny_mdstream_flush(tiny_mdstream *s, size_t *count) {
231+tiny_blist tiny_mdstream_flush(tiny_mdstream *s) {
261232 tiny_blist out = {0};
262233 if (!s->fence_marker) {
263234 release_prose(s, s->rest, &out);
@@ -266,15 +237,14 @@ tiny_body_line *tiny_mdstream_flush(tiny_mdstream *s, size_t *count) {
266237 if (s->rest[0]) {
267238 char *c = tiny_highlight_markdown(s->rest);
268239 // Split the possibly multi-line remainder.
269- size_t nlines;
270- char **lines = tiny_split_lines(c, &nlines);
271- for (size_t i = 0; i < nlines; i++) bl_push(&out, lines[i], NULL, NULL);
272- free(lines);
240+ tiny_strv lines = tiny_split_lines(c);
241+ for (size_t i = 0; i < lines.n; i++) bl_push(&out, lines.v[i], NULL, NULL);
242+ free(lines.v);
273243 free(c);
274244 }
275245 }
276246 tiny_mdstream_reset(s);
277- return bl_take(&out, count);
247+ return out;
278248 }
279249
280250 // ---- tail stream -----------------------------------------------------------
@@ -293,7 +263,7 @@ void tiny_tailstream_reset(tiny_tailstream *s) {
293263 s->rest = xstrdup("");
294264 }
295265
296-tiny_body_line *tiny_tailstream_feed(tiny_tailstream *s, const char *delta, size_t *count) {
266+tiny_blist tiny_tailstream_feed(tiny_tailstream *s, const char *delta) {
297267 size_t rl = strlen(s->rest), dl = strlen(delta);
298268 char *text = xmalloc(rl + dl + 1);
299269 memcpy(text, s->rest, rl);
@@ -307,18 +277,12 @@ tiny_body_line *tiny_tailstream_feed(tiny_tailstream *s, const char *delta, size
307277 text = NULL;
308278 }
309279 free(text);
310- *count = 0;
311- return NULL;
280+ return (tiny_blist){0};
312281 }
313282
314-tiny_body_line *tiny_tailstream_pending(tiny_tailstream *s, size_t *count) {
315- if (s->rest[0] == '\0') {
316- *count = 0;
317- return NULL;
318- }
319- tiny_body_line *v = xmalloc(sizeof *v);
320- v[0] = (tiny_body_line){xstrdup(s->rest), fg_dim, NULL};
321- *count = 1;
322- return v;
283+tiny_blist tiny_tailstream_pending(tiny_tailstream *s) {
284+ tiny_blist out = {0};
285+ if (s->rest[0] != '\0') bl_push(&out, xstrdup(s->rest), fg_dim, NULL);
286+ return out;
323287 }
324288