1 /*
2  * Copyright (c) 2021, 2022 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 "compat.h"
26 
27 #include <ctype.h>
28 #include <string.h>
29 #include <stdlib.h>
30 
31 #include "defaults.h"
32 #include "parser.h"
33 #include "utf8.h"
34 
35 static int	gemtext_parse(struct parser *, const char *, size_t);
36 static int	gemtext_foreach_line(struct parser *, const char *, size_t);
37 static int	gemtext_free(struct parser *);
38 static int	gemtext_serialize(struct parser *, FILE *);
39 
40 static int	parse_text(struct parser*, enum line_type, const char*, size_t);
41 static int	parse_link(struct parser*, enum line_type, const char*, size_t);
42 static int	parse_title(struct parser*, enum line_type, const char*, size_t);
43 static int	parse_item(struct parser*, enum line_type, const char*, size_t);
44 static int	parse_quote(struct parser*, enum line_type, const char*, size_t);
45 static int	parse_pre_start(struct parser*, enum line_type, const char*, size_t);
46 static int	parse_pre_cnt(struct parser*, enum line_type, const char*, size_t);
47 static int	parse_pre_end(struct parser*, enum line_type, const char*, size_t);
48 static void	search_title(struct parser*, enum line_type);
49 
50 typedef int (parselinefn)(struct parser*, enum line_type, const char*, size_t);
51 
52 static parselinefn *parsers[] = {
53 	[LINE_TEXT]		= parse_text,
54 	[LINE_LINK]		= parse_link,
55 	[LINE_TITLE_1]		= parse_title,
56 	[LINE_TITLE_2]		= parse_title,
57 	[LINE_TITLE_3]		= parse_title,
58 	[LINE_ITEM]		= parse_item,
59 	[LINE_QUOTE]		= parse_quote,
60 	[LINE_PRE_START]	= parse_pre_start,
61 	[LINE_PRE_CONTENT]	= parse_pre_cnt,
62 	[LINE_PRE_END]		= parse_pre_end,
63 };
64 
65 void
66 gemtext_initparser(struct parser *p)
67 {
68 	memset(p, 0, sizeof(*p));
69 
70 	p->name = "text/gemini";
71 	p->parse = &gemtext_parse;
72 	p->free  = &gemtext_free;
73 	p->serialize = &gemtext_serialize;
74 
75 	TAILQ_INIT(&p->head);
76 }
77 
78 static inline int
79 emit_line(struct parser *p, enum line_type type, char *line, char *alt)
80 {
81 	struct line *l;
82 
83 	if ((l = calloc(1, sizeof(*l))) == NULL)
84 		return 0;
85 
86 	l->type = type;
87 	l->line = line;
88 	l->alt = alt;
89 
90 	switch (l->type) {
91 	case LINE_PRE_START:
92 	case LINE_PRE_END:
93 		if (hide_pre_context)
94 			l->flags = L_HIDDEN;
95 		if (l->type == LINE_PRE_END &&
96 		    hide_pre_closing_line)
97 			l->flags = L_HIDDEN;
98 		break;
99 	case LINE_PRE_CONTENT:
100 		if (hide_pre_blocks)
101 			l->flags = L_HIDDEN;
102 		break;
103 	case LINE_LINK:
104 		if (emojify_link &&
105 		    !emojied_line(line, (const char **)&l->data))
106 			l->data = NULL;
107 		break;
108 	default:
109 		break;
110 	}
111 
112 	TAILQ_INSERT_TAIL(&p->head, l, lines);
113 
114 	return 1;
115 }
116 
117 static int
118 parse_text(struct parser *p, enum line_type t, const char *buf, size_t len)
119 {
120 	char *l;
121 
122 	if ((l = calloc(1, len+1)) == NULL)
123 		return 0;
124 	memcpy(l, buf, len);
125 	return emit_line(p, t, l, NULL);
126 }
127 
128 static int
129 parse_link(struct parser *p, enum line_type t, const char *buf, size_t len)
130 {
131 	char *l, *u;
132 	const char *url_start;
133 
134 	if (len <= 2)
135 		return emit_line(p, LINE_TEXT, NULL, NULL);
136 	buf += 2;
137 	len -= 2;
138 
139 	while (len > 0 && isspace(buf[0])) {
140 		buf++;
141 		len--;
142 	}
143 
144 	if (len == 0)
145 		return emit_line(p, LINE_TEXT, NULL, NULL);
146 
147 	url_start = buf;
148 	while (len > 0 && !isspace(buf[0])) {
149 		buf++;
150 		len--;
151 	}
152 
153 	if ((u = calloc(1, buf - url_start + 1)) == NULL)
154 		return 0;
155 	memcpy(u, url_start, buf - url_start);
156 
157 	if (len == 0)
158 		goto nolabel;
159 
160 	while (len > 0 && isspace(buf[0])) {
161 		buf++;
162 		len--;
163 	}
164 
165 	if (len == 0)
166 		goto nolabel;
167 
168 	if ((l = calloc(1, len + 1)) == NULL)
169 		return 0;
170 
171 	memcpy(l, buf, len);
172 	return emit_line(p, t, l, u);
173 
174 nolabel:
175 	if ((l = strdup(u)) == NULL)
176 		return 0;
177 	return emit_line(p, t, l, u);
178 }
179 
180 static int
181 parse_title(struct parser *p, enum line_type t, const char *buf, size_t len)
182 {
183 	char *l;
184 
185 	switch (t) {
186 	case LINE_TITLE_1:
187 		if (len <= 1)
188 			return emit_line(p, t, NULL, NULL);
189 		buf++;
190 		len--;
191 		break;
192 	case LINE_TITLE_2:
193 		if (len <= 2)
194 			return emit_line(p, t, NULL, NULL);
195 		buf += 2;
196 		len -= 2;
197 		break;
198 	case LINE_TITLE_3:
199 		if (len <= 3)
200 			return emit_line(p, t, NULL, NULL);
201 		buf += 3;
202 		len -= 3;
203 		break;
204 	default:
205 		/* unreachable */
206 		abort();
207 	}
208 
209 	while (len > 0 && isspace(buf[0])) {
210 		buf++;
211 		len--;
212 	}
213 
214 	if (len == 0)
215 		return emit_line(p, t, NULL, NULL);
216 
217 	if (t == LINE_TITLE_1 && *p->title == '\0')
218 		strncpy(p->title, buf, MIN(sizeof(p->title)-1, len));
219 
220 	if ((l = calloc(1, len+1)) == NULL)
221 		return 0;
222 	memcpy(l, buf, len);
223 	return emit_line(p, t, l, NULL);
224 }
225 
226 static int
227 parse_item(struct parser *p, enum line_type t, const char *buf, size_t len)
228 {
229 	char *l;
230 
231 	if (len == 1)
232 		return emit_line(p, t, NULL, NULL);
233 
234 	buf++;
235 	len--;
236 
237 	while (len > 0 && isspace(buf[0])) {
238 		buf++;
239 		len--;
240 	}
241 
242 	if (len == 0)
243 		return emit_line(p, t, NULL, NULL);
244 
245 	if ((l = calloc(1, len+1)) == NULL)
246 		return 0;
247 	memcpy(l, buf, len);
248 	return emit_line(p, t, l, NULL);
249 }
250 
251 static int
252 parse_quote(struct parser *p, enum line_type t, const char *buf, size_t len)
253 {
254 	char *l;
255 
256 	if (len == 1)
257 		return emit_line(p, t, NULL, NULL);
258 
259 	buf++;
260 	len--;
261 
262 	while (len > 0 && isspace(buf[0])) {
263 		buf++;
264 		len--;
265 	}
266 
267 	if (len == 0)
268 		return emit_line(p, t, NULL, NULL);
269 
270 	if ((l = calloc(1, len+1)) == NULL)
271 		return 0;
272 	memcpy(l, buf, len);
273 	return emit_line(p, t, l, NULL);
274 }
275 
276 static int
277 parse_pre_start(struct parser *p, enum line_type t, const char *buf, size_t len)
278 {
279 	char *l;
280 
281 	if (len <= 3)
282 		return emit_line(p, t, NULL, NULL);
283 
284 	buf += 3;
285 	len -= 3;
286 
287 	while (len > 0 && isspace(buf[0])) {
288 		buf++;
289 		len--;
290 	}
291 
292 	if (len == 0)
293 		return emit_line(p, t, NULL, NULL);
294 
295 	if ((l = calloc(1, len+1)) == NULL)
296 		return 0;
297 
298 	memcpy(l, buf, len);
299 	return emit_line(p, t, l, NULL);
300 }
301 
302 static int
303 parse_pre_cnt(struct parser *p, enum line_type t, const char *buf, size_t len)
304 {
305 	char *l;
306 
307 	if (len == 0)
308 		return emit_line(p, t, NULL, NULL);
309 
310 	if ((l = calloc(1, len+1)) == NULL)
311 		return 0;
312 	memcpy(l, buf, len);
313 	return emit_line(p, t, l, NULL);
314 }
315 
316 static int
317 parse_pre_end(struct parser *p, enum line_type t, const char *buf, size_t len)
318 {
319 	return emit_line(p, t, NULL, NULL);
320 }
321 
322 static inline enum line_type
323 detect_line_type(const char *buf, size_t len, int in_pre)
324 {
325 	if (in_pre) {
326 		if (len >= 3 &&
327 		    buf[0] == '`' && buf[1] == '`' && buf[2] == '`')
328 			return LINE_PRE_END;
329 		else
330 			return LINE_PRE_CONTENT;
331 	}
332 
333 	if (len == 0)
334 		return LINE_TEXT;
335 
336 	switch (*buf) {
337 	case '*':
338 		if (len > 1 && buf[1] == ' ')
339 			return LINE_ITEM;
340 		break;
341 	case '>': return LINE_QUOTE;
342 	case '=':
343 		if (len >= 1 && buf[1] == '>')
344 			return LINE_LINK;
345 		break;
346 	case '#':
347 		if (len == 1)
348 			return LINE_TEXT;
349 		if (buf[1] != '#')
350 			return LINE_TITLE_1;
351 		if (len == 2)
352 			return LINE_TEXT;
353 		if (buf[2] != '#')
354 			return LINE_TITLE_2;
355 		if (len == 3)
356 			return LINE_TEXT;
357 		return LINE_TITLE_3;
358 	case '`':
359 		if (len < 3)
360 			return LINE_TEXT;
361 		if (buf[0] == '`' && buf[1] == '`' && buf[2] == '`')
362 			return LINE_PRE_START;
363 		break;
364 	}
365 
366 	return LINE_TEXT;
367 }
368 
369 static int
370 gemtext_parse(struct parser *p, const char *buf, size_t size)
371 {
372 	return parser_foreach_line(p, buf, size, gemtext_foreach_line);
373 }
374 
375 static int
376 gemtext_foreach_line(struct parser *p, const char *line, size_t linelen)
377 {
378 	enum line_type t;
379 
380 	t = detect_line_type(line, linelen, p->flags & PARSER_IN_PRE);
381 	if (t == LINE_PRE_START)
382 		p->flags ^= PARSER_IN_PRE;
383 	if (t == LINE_PRE_END)
384 		p->flags ^= PARSER_IN_PRE;
385 	return parsers[t](p, t, line, linelen);
386 }
387 
388 static int
389 gemtext_free(struct parser *p)
390 {
391 	enum line_type	t;
392 
393 	/* flush the buffer */
394 	if (p->len != 0) {
395 		t = detect_line_type(p->buf, p->len, p->flags & PARSER_IN_PRE);
396 		if (!parsers[t](p, t, p->buf, p->len))
397 			return 0;
398 		if ((p->flags & PARSER_IN_PRE) &&
399 		    !emit_line(p, LINE_PRE_END, NULL, NULL))
400 			return 0;
401 	}
402 
403 	free(p->buf);
404 
405 	/*
406 	 * use the first level 2 or 3 header as page title if none
407 	 * found yet.
408 	 */
409 	if (*p->title == '\0')
410 		search_title(p, LINE_TITLE_2);
411 	if (*p->title == '\0')
412 		search_title(p, LINE_TITLE_3);
413 
414 	return 1;
415 }
416 
417 static void
418 search_title(struct parser *p, enum line_type level)
419 {
420 	struct line *l;
421 
422 	TAILQ_FOREACH(l, &p->head, lines) {
423 		if (l->type == level) {
424 			if (l->line == NULL)
425 				continue;
426 			strlcpy(p->title, l->line, sizeof(p->title));
427 			break;
428 		}
429 	}
430 }
431 
432 static const char *gemtext_prefixes[] = {
433 	[LINE_TEXT] = "",
434 	[LINE_TITLE_1] = "# ",
435 	[LINE_TITLE_2] = "## ",
436 	[LINE_TITLE_3] = "### ",
437 	[LINE_ITEM] = "* ",
438 	[LINE_QUOTE] = "> ",
439 	[LINE_PRE_START] = "``` ",
440 	[LINE_PRE_CONTENT] = "",
441 	[LINE_PRE_END] = "```",
442 };
443 
444 static int
445 gemtext_serialize(struct parser *p, FILE *fp)
446 {
447 	struct line	*line;
448 	const char	*text;
449 	const char	*alt;
450 	int		 r;
451 
452 	TAILQ_FOREACH(line, &p->head, lines) {
453 		if ((text = line->line) == NULL)
454 			text = "";
455 
456 		if ((alt = line->alt) == NULL)
457 			alt = "";
458 
459 		switch (line->type) {
460 		case LINE_TEXT:
461 		case LINE_TITLE_1:
462 		case LINE_TITLE_2:
463 		case LINE_TITLE_3:
464 		case LINE_ITEM:
465 		case LINE_QUOTE:
466 		case LINE_PRE_START:
467 		case LINE_PRE_CONTENT:
468 		case LINE_PRE_END:
469 			r = fprintf(fp, "%s%s\n", gemtext_prefixes[line->type],
470 			    text);
471 			break;
472 
473 		case LINE_LINK:
474 			r = fprintf(fp, "=> %s %s\n", alt, text);
475 			break;
476 
477 		default:
478 			/* not reached */
479 			abort();
480 		}
481 
482 		if (r == -1)
483 			return 0;
484 	}
485 
486 	return 1;
487 }