op public repos

Blob

Date:: Sat Mar 6 19:10:19 2021 UTC
Message:: [gemtext] improve parse_link * add a mising `&& isspace(buf[0])' that would make the parser skip the link label * swap alt and line: line is the text, alt the URL * text is always defined, at worst is a copy of URL
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 /*
18  * A streaming gemtext parser.
19  *
20  * TODO:
21  *  - handle NULs
22  *  - UTF8
23  */
24 
25 #include <telescope.h>
26 
27 #include <ctype.h>
28 #include <string.h>
29 #include <stdlib.h>
30 
31 static int	gemtext_parse(struct parser*, const char*, size_t);
32 static int	gemtext_free(struct parser*);
33 
34 static int	parse_text(struct parser*, enum line_type, const char*, size_t);
35 static int	parse_link(struct parser*, enum line_type, const char*, size_t);
36 static int	parse_title(struct parser*, enum line_type, const char*, size_t);
37 static int	parse_item(struct parser*, enum line_type, const char*, size_t);
38 static int	parse_quote(struct parser*, enum line_type, const char*, size_t);
39 static int	parse_pre_start(struct parser*, enum line_type, const char*, size_t);
40 static int	parse_pre_cnt(struct parser*, enum line_type, const char*, size_t);
41 static int	parse_pre_end(struct parser*, enum line_type, const char*, size_t);
42 
43 typedef int (parselinefn)(struct parser*, enum line_type, const char*, size_t);
44 
45 static parselinefn *parsers[] = {
46 	parse_text,		/* LINE_TEXT */
47 	parse_link,		/* LINE_LINK */
48 	parse_title,		/* LINE_TITLE_1 */
49 	parse_title,		/* LINE_TITLE_2 */
50 	parse_title,		/* LINE_TITLE_3 */
51 	parse_item,		/* LINE_ITEM */
52 	parse_quote,		/* LINE_QUOTE */
53 	parse_pre_start,	/* LINE_PRE_START */
54 	parse_pre_cnt,		/* LINE_PRE_CONTENT */
55 	parse_pre_end,		/* LINE_PRE_END */
56 };
57 
58 void
59 gemtext_initparser(struct parser *p)
60 {
61 	memset(p, 0, sizeof(*p));
62 
63 	p->parse = &gemtext_parse;
64 	p->free  = &gemtext_free;
65 }
66 
67 static inline int
68 emit_line(struct parser *p, enum line_type type, char *line, char *alt)
69 {
70 	struct line *l;
71 
72 	if ((l = calloc(1, sizeof(*l))) == NULL)
73 		return 0;
74 
75 	l->type = type;
76 	l->line = line;
77 	l->alt = alt;
78 
79 	if (TAILQ_EMPTY(&p->head))
80 		TAILQ_INSERT_HEAD(&p->head, l, lines);
81 	else
82 		TAILQ_INSERT_TAIL(&p->head, l, lines);
83 
84 	return 1;
85 }
86 
87 static int
88 parse_text(struct parser *p, enum line_type t, const char *buf, size_t len)
89 {
90 	char *l;
91 
92 	if ((l = calloc(1, len+1)) == NULL)
93 		return 0;
94 	memcpy(l, buf, len);
95 	return emit_line(p, t, l, NULL);
96 }
97 
98 static int
99 parse_link(struct parser *p, enum line_type t, const char *buf, size_t len)
100 {
101 	char *l, *u;
102 	const char *url_start;
103 
104 	if (len <= 2)
105 		return emit_line(p, t, NULL, NULL);
106 	buf += 2;
107 	len -= 2;
108 
109 	while (len > 0 && isspace(buf[0])) {
110 		buf++;
111 		len--;
112 	}
113 
114 	if (len == 0)
115 		return emit_line(p, t, NULL, NULL);
116 
117 	url_start = buf;
118 	while (len > 0 && !isspace(buf[0])) {
119 		buf++;
120 		len--;
121 	}
122 
123 	if ((u = calloc(1, buf - url_start + 1)) == NULL)
124 		return 0;
125 	memcpy(u, url_start, buf - url_start);
126 
127 	if (len == 0)
128 		goto nolabel;
129 
130 	while (len > 0 && isspace(buf[0])) {
131 		buf++;
132 		len--;
133 	}
134 
135 	if (len == 0)
136 		goto nolabel;
137 
138 	if ((l = calloc(1, len + 1)) == NULL)
139 		return 0;
140 
141 	memcpy(l, buf, len);
142 	return emit_line(p, t, l, u);
143 
144 nolabel:
145 	if ((l = strdup(u)) == NULL)
146 		return 0;
147 	return emit_line(p, t, l, u);
148 }
149 
150 static int
151 parse_title(struct parser *p, enum line_type t, const char *buf, size_t len)
152 {
153 	char *l;
154 
155 	switch (t) {
156 	case LINE_TITLE_1:
157 		if (len <= 1)
158 			return emit_line(p, t, NULL, NULL);
159 		buf++;
160 		len--;
161 		break;
162 	case LINE_TITLE_2:
163 		if (len <= 2)
164 			return emit_line(p, t, NULL, NULL);
165 		buf += 2;
166 		len -= 2;
167 		break;
168 	case LINE_TITLE_3:
169 		if (len <= 3)
170 			return emit_line(p, t, NULL, NULL);
171 		buf += 3;
172 		len -= 3;
173 		break;
174 	default:
175 		/* unreachable */
176 		abort();
177 	}
178 
179 	while (len > 0 && isspace(buf[0])) {
180 		buf++;
181 		len--;
182 	}
183 
184 	if (len == 0)
185 		return emit_line(p, t, NULL, NULL);
186 
187 	if ((l = calloc(1, len+1)) == NULL)
188 		return 0;
189 	memcpy(l, buf, len);
190 	return emit_line(p, t, l, NULL);
191 }
192 
193 static int
194 parse_item(struct parser *p, enum line_type t, const char *buf, size_t len)
195 {
196 	char *l;
197 
198 	if (len == 1)
199 		return emit_line(p, t, NULL, NULL);
200 
201 	buf++;
202 	len--;
203 
204 	while (len > 0 && isspace(buf[0])) {
205 		buf++;
206 		len--;
207 	}
208 
209 	if (len == 0)
210 		return emit_line(p, t, NULL, NULL);
211 
212 	if ((l = calloc(1, len+1)) == NULL)
213 		return 0;
214 	memcpy(l, buf, len);
215 	return emit_line(p, t, l, NULL);
216 }
217 
218 static int
219 parse_quote(struct parser *p, enum line_type t, const char *buf, size_t len)
220 {
221 	char *l;
222 
223 	if (len == 1)
224 		return emit_line(p, t, NULL, NULL);
225 
226 	buf++;
227 	len--;
228 
229 	while (len > 0 && isspace(buf[0])) {
230 		buf++;
231 		len--;
232 	}
233 
234 	if (len == 0)
235 		return emit_line(p, t, NULL, NULL);
236 
237 	if ((l = calloc(1, len+1)) == NULL)
238 		return 0;
239 	memcpy(l, buf, len);
240 	return emit_line(p, t, l, NULL);
241 }
242 
243 static int
244 parse_pre_start(struct parser *p, enum line_type t, const char *buf, size_t len)
245 {
246 	char *l;
247 
248 	if (len <= 3)
249 		return emit_line(p, t, NULL, NULL);
250 
251 	buf += 3;
252 	len += 3;
253 
254 	while (len > 0 && isspace(buf[0])) {
255 		buf++;
256 		len--;
257 	}
258 
259 	if (len == 0)
260 		return emit_line(p, t, NULL, NULL);
261 
262 	if ((l = calloc(1, len+1)) == NULL)
263 		return 0;
264 
265 	memcpy(l, buf, len);
266 	return emit_line(p, t, NULL, l);
267 }
268 
269 static int
270 parse_pre_cnt(struct parser *p, enum line_type t, const char *buf, size_t len)
271 {
272 	char *l;
273 
274 	if (len == 0)
275 		return emit_line(p, t, NULL, NULL);
276 
277 	if ((l = calloc(1, len+1)) == NULL)
278 		return 0;
279 	memcpy(l, buf, len);
280 	return emit_line(p, t, l, NULL);
281 }
282 
283 static int
284 parse_pre_end(struct parser *p, enum line_type t, const char *buf, size_t len)
285 {
286 	return emit_line(p, t, NULL, NULL);
287 }
288 
289 static inline enum line_type
290 detect_line_type(const char *buf, size_t len, int in_pre)
291 {
292 	size_t i;
293 
294 	if (len == 0)
295 		return LINE_TEXT;
296 
297 	if (in_pre) {
298 		if (len >= 3 &&
299 		    buf[0] == '`' && buf[1] == '`' && buf[2] == '`')
300 			return LINE_PRE_END;
301 		else
302 			return LINE_PRE_CONTENT;
303 	}
304 
305 	switch (*buf) {
306 	case '*': return LINE_ITEM;
307 	case '>': return LINE_QUOTE;
308 	case '=':
309 		if (len >= 1 && buf[1] == '>')
310 			return LINE_LINK;
311 		break;
312 	case '#':
313 		if (len == 1)
314 			return LINE_TEXT;
315 		if (buf[1] != '#')
316 			return LINE_TITLE_1;
317 		if (len == 2)
318 			return LINE_TEXT;
319 		if (buf[2] != '#')
320 			return LINE_TITLE_2;
321 		if (len == 3)
322 			return LINE_TEXT;
323 		return LINE_TITLE_3;
324 	case '`':
325 		if (len < 3)
326 			return LINE_TEXT;
327 		if (buf[0] == '`' && buf[1] == '`' && buf[2] == '`')
328 			return LINE_PRE_START;
329 		break;
330 	}
331 
332 	return LINE_TEXT;
333 }
334 
335 static inline int
336 append(struct parser *p, const char *buf, size_t len)
337 {
338 	size_t newlen;
339 	char *t;
340 
341 	newlen = len + p->len;
342 	if ((t = calloc(1, newlen)) == NULL)
343 		return 0;
344 	memcpy(t, p->buf, p->len);
345 	memcpy(t + p->len, buf, len);
346 	free(p->buf);
347 	p->buf = t;
348 	p->len = newlen;
349 	return 1;
350 }
351 
352 static inline int
353 set_buf(struct parser *p, const char *buf, size_t len)
354 {
355 	free(p->buf);
356 	p->buf = NULL;
357 
358 	if (len == 0) {
359 		p->len = 0;
360 		return 1;
361 	}
362 
363 	if ((p->buf = calloc(1, len)) == NULL)
364 		return 0;
365 	memcpy(p->buf, buf, len);
366 	p->len = len;
367 	return 1;
368 }
369 
370 static int
371 gemtext_parse(struct parser *p, const char *buf, size_t size)
372 {
373 	const char	*b, *e;
374 	enum line_type	 t;
375 	size_t		 len, l;
376 
377 	if (p->len == 0) {
378 		b = buf;
379 		len = size;
380 	} else {
381 		if (!append(p, buf, size))
382 			return 0;
383 		b = p->buf;
384 		len = p->len;
385 	}
386 
387 	while (len > 0) {
388 		if ((e = telescope_strnchr((char*)b, '\n', len)) == NULL)
389 			break;
390 		l = e - b;
391 		t = detect_line_type(b, l, p->flags);
392 		if (t == LINE_PRE_START)
393 			p->flags = 1;
394 		if (t == LINE_PRE_END)
395 			p->flags = 0;
396 		if (!parsers[t](p, t, b, l))
397 			return 0;
398 
399 		len -= l;
400 		b += l;
401 
402 		if (len > 0) {
403 			/* skip \n */
404 			len--;
405 			b++;
406 		}
407 	}
408 
409 	return set_buf(p, b, len);
410 }
411 
412 static int
413 gemtext_free(struct parser *p)
414 {
415 	enum line_type	t;
416 
417 	/* flush the buffer */
418 	if (p->len != 0) {
419 		t = detect_line_type(p->buf, p->len, p->flags);
420 		if (!parsers[t](p, t, p->buf, p->len))
421 			return 0;
422 		if (p->flags && !emit_line(p, LINE_PRE_END, NULL, NULL))
423 			return 0;
424 	}
425 
426 	free(p->buf);
427 	return 1;
428 }