1 /*
2  * Copyright (c) 2022 Omar Polo <op@openbsd.org>
3  * Copyright (c) 2007-2016 Reyk Floeter <reyk@openbsd.org>
4  * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org>
5  * Copyright (c) 2004 Ryan McBride <mcbride@openbsd.org>
6  * Copyright (c) 2002, 2003, 2004 Henning Brauer <henning@openbsd.org>
7  * Copyright (c) 2001 Markus Friedl.  All rights reserved.
8  * Copyright (c) 2001 Daniel Hartmeier.  All rights reserved.
9  * Copyright (c) 2001 Theo de Raadt.  All rights reserved.
10  *
11  * Permission to use, copy, modify, and distribute this software for any
12  * purpose with or without fee is hereby granted, provided that the above
13  * copyright notice and this permission notice appear in all copies.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
16  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
17  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
18  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
19  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
20  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
21  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22  */
23 
24 %{
25 
26 #include <sys/queue.h>
27 
28 #include <ctype.h>
29 #include <err.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <stdarg.h>
33 #include <stdint.h>
34 #include <string.h>
35 #include <unistd.h>
36 
37 #include "got_compat.h"
38 
39 #ifndef nitems
40 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
41 #endif
42 
43 TAILQ_HEAD(files, file)		 files = TAILQ_HEAD_INITIALIZER(files);
44 static struct file {
45 	TAILQ_ENTRY(file)	 entry;
46 	FILE			*stream;
47 	char			*name;
48 	size_t			 ungetpos;
49 	size_t			 ungetsize;
50 	unsigned char		*ungetbuf;
51 	int			 eof_reached;
52 	int			 lineno;
53 	int			 errors;
54 } *file, *topfile;
55 int		 parse(FILE *, const char *);
56 struct file	*pushfile(const char *, int);
57 int		 popfile(void);
58 int		 yyparse(void);
59 int		 yylex(void);
60 int		 yyerror(const char *, ...)
61     __attribute__((__format__ (printf, 1, 2)))
62     __attribute__((__nonnull__ (1)));
63 int		 kw_cmp(const void *, const void *);
64 int		 lookup(char *);
65 int		 igetc(void);
66 int		 lgetc(int);
67 void		 lungetc(int);
68 int		 findeol(void);
69 
70 void		 dbg(void);
71 void		 printq(const char *);
72 
73 extern int	 nodebug;
74 
75 static FILE	*fp;
76 
77 static int	 block;
78 static int	 in_define;
79 static int	 errors;
80 static int	 lastline = -1;
81 
82 typedef struct {
83 	union {
84 		char		*string;
85 	} v;
86 	int lineno;
87 } YYSTYPE;
88 
89 %}
90 
91 %token	DEFINE ELSE END ERROR FINALLY FOR IF INCLUDE PRINTF
92 %token	RENDER TQFOREACH UNSAFE URLESCAPE WHILE
93 %token	<v.string>	STRING
94 %type	<v.string>	string nstring
95 %type	<v.string>	stringy
96 
97 %%
98 
99 grammar		: /* empty */
100 		| grammar include
101 		| grammar verbatim
102 		| grammar block
103 		| grammar error		{ file->errors++; }
104 		;
105 
106 include		: INCLUDE STRING {
107 			struct file	*nfile;
108 
109 			if ((nfile = pushfile($2, 0)) == NULL) {
110 				yyerror("failed to include file %s", $2);
111 				free($2);
112 				YYERROR;
113 			}
114 			free($2);
115 
116 			file = nfile;
117 			lungetc('\n');
118 		}
119 		;
120 
121 verbatim	: '!' verbatim1 '!' {
122 			if (in_define) {
123 				/* TODO: check template status and exit in case */
124 			}
125 		}
126 		;
127 
128 verbatim1	: /* empty */
129 		| verbatim1 STRING {
130 			if (*$2 != '\0') {
131 				dbg();
132 				fprintf(fp, "%s\n", $2);
133 			}
134 			free($2);
135 		}
136 		;
137 
138 verbatims	: /* empty */
139 		| verbatims verbatim
140 		;
141 
142 raw		: nstring {
143 			dbg();
144 			fprintf(fp, "if ((tp_ret = tp_write(tp, ");
145 			printq($1);
146 			fprintf(fp, ", %zu)) == -1) goto err;\n",
147 			    strlen($1));
148 
149 			free($1);
150 		}
151 		;
152 
153 block		: define body end {
154 			fputs("err:\n", fp);
155 			fputs("return tp_ret;\n", fp);
156 			fputs("}\n", fp);
157 			in_define = 0;
158 		}
159 		| define body finally end {
160 			fputs("return tp_ret;\n", fp);
161 			fputs("}\n", fp);
162 			in_define = 0;
163 		}
164 		;
165 
166 define		: '{' DEFINE string '}' {
167 			in_define = 1;
168 
169 			dbg();
170 			fprintf(fp, "int\n%s\n{\n", $3);
171 			fputs("int tp_ret = 0;\n", fp);
172 
173 			free($3);
174 		}
175 		;
176 
177 body		: /* empty */
178 		| body verbatim
179 		| body raw
180 		| body special
181 		;
182 
183 special		: '{' RENDER string '}' {
184 			dbg();
185 			fprintf(fp, "if ((tp_ret = %s) == -1) goto err;\n",
186 			    $3);
187 			free($3);
188 		}
189 		| printf
190 		| if body endif			{ fputs("}\n", fp); }
191 		| loop
192 		| '{' string '|' UNSAFE '}' {
193 			dbg();
194 			fprintf(fp,
195 			    "if ((tp_ret = tp_writes(tp, %s)) == -1)\n",
196 			    $2);
197 			fputs("goto err;\n", fp);
198 			free($2);
199 		}
200 		| '{' string '|' URLESCAPE '}' {
201 			dbg();
202 			fprintf(fp,
203 			    "if ((tp_ret = tp_urlescape(tp, %s)) == -1)\n",
204 			    $2);
205 			fputs("goto err;\n", fp);
206 			free($2);
207 		}
208 		| '{' string '}' {
209 			dbg();
210 			fprintf(fp,
211 			    "if ((tp_ret = tp_htmlescape(tp, %s)) == -1)\n",
212 			    $2);
213 			fputs("goto err;\n", fp);
214 			free($2);
215 		}
216 		;
217 
218 printf		: '{' PRINTF {
219 			dbg();
220 			fprintf(fp, "if (asprintf(&tp->tp_tmp, ");
221 		} printfargs '}' {
222 			fputs(") == -1)\n", fp);
223 			fputs("goto err;\n", fp);
224 			fputs("if ((tp_ret = tp_htmlescape(tp, tp->tp_tmp)) "
225 			    "== -1)\n", fp);
226 			fputs("goto err;\n", fp);
227 			fputs("free(tp->tp_tmp);\n", fp);
228 			fputs("tp->tp_tmp = NULL;\n", fp);
229 		}
230 		;
231 
232 printfargs	: /* empty */
233 		| printfargs STRING {
234 			fprintf(fp, " %s", $2);
235 			free($2);
236 		}
237 		;
238 
239 if		: '{' IF stringy '}' {
240 			dbg();
241 			fprintf(fp, "if (%s) {\n", $3);
242 			free($3);
243 		}
244 		;
245 
246 endif		: end
247 		| else body end
248 		| elsif body endif
249 		;
250 
251 elsif		: '{' ELSE IF stringy '}' {
252 			dbg();
253 			fprintf(fp, "} else if (%s) {\n", $4);
254 			free($4);
255 		}
256 		;
257 
258 else		: '{' ELSE '}' {
259 			dbg();
260 			fputs("} else {\n", fp);
261 		}
262 		;
263 
264 loop		: '{' FOR stringy '}' {
265 			fprintf(fp, "for (%s) {\n", $3);
266 			free($3);
267 		} body end {
268 			fputs("}\n", fp);
269 		}
270 		| '{' TQFOREACH STRING STRING STRING '}' {
271 			fprintf(fp, "TAILQ_FOREACH(%s, %s, %s) {\n",
272 			    $3, $4, $5);
273 			free($3);
274 			free($4);
275 			free($5);
276 		} body end {
277 			fputs("}\n", fp);
278 		}
279 		| '{' WHILE stringy '}' {
280 			fprintf(fp, "while (%s) {\n", $3);
281 			free($3);
282 		} body end {
283 			fputs("}\n", fp);
284 		}
285 		;
286 
287 end		: '{' END '}'
288 		;
289 
290 finally		: '{' FINALLY '}' {
291 			dbg();
292 			fputs("err:\n", fp);
293 		} verbatims
294 		;
295 
296 nstring	:	STRING nstring {
297 			if (asprintf(&$$, "%s%s", $1, $2) == -1)
298 				err(1, "asprintf");
299 			free($1);
300 			free($2);
301 		}
302 		| STRING
303 		;
304 
305 string		: STRING string {
306 			if (asprintf(&$$, "%s %s", $1, $2) == -1)
307 				err(1, "asprintf");
308 			free($1);
309 			free($2);
310 		}
311 		| STRING
312 		;
313 
314 stringy		: STRING
315 		| STRING stringy {
316 			if (asprintf(&$$, "%s %s", $1, $2) == -1)
317 				err(1, "asprintf");
318 			free($1);
319 			free($2);
320 		}
321 		| '|' stringy {
322 			if (asprintf(&$$, "|%s", $2) == -1)
323 				err(1, "asprintf");
324 			free($2);
325 		}
326 		;
327 
328 %%
329 
330 struct keywords {
331 	const char	*k_name;
332 	int		 k_val;
333 };
334 
335 int
336 yyerror(const char *fmt, ...)
337 {
338 	va_list	 ap;
339 	char	*msg;
340 
341 	file->errors++;
342 	va_start(ap, fmt);
343 	if (vasprintf(&msg, fmt, ap) == -1)
344 		err(1, "yyerror vasprintf");
345 	va_end(ap);
346 	fprintf(stderr, "%s:%d: %s\n", file->name, yylval.lineno, msg);
347 	free(msg);
348 	return (0);
349 }
350 
351 int
352 kw_cmp(const void *k, const void *e)
353 {
354 	return (strcmp(k, ((const struct keywords *)e)->k_name));
355 }
356 
357 int
358 lookup(char *s)
359 {
360 	/* this has to be sorted always */
361 	static const struct keywords keywords[] = {
362 		{ "define",		DEFINE },
363 		{ "else",		ELSE },
364 		{ "end",		END },
365 		{ "finally",		FINALLY },
366 		{ "for",		FOR },
367 		{ "if",			IF },
368 		{ "include",		INCLUDE },
369 		{ "printf",		PRINTF },
370 		{ "render",		RENDER },
371 		{ "tailq-foreach",	TQFOREACH },
372 		{ "unsafe",		UNSAFE },
373 		{ "urlescape",		URLESCAPE },
374 		{ "while",		WHILE },
375 	};
376 	const struct keywords	*p;
377 
378 	p = bsearch(s, keywords, nitems(keywords), sizeof(keywords[0]),
379 	    kw_cmp);
380 
381 	if (p)
382 		return (p->k_val);
383 	else
384 		return (STRING);
385 }
386 
387 #define START_EXPAND	1
388 #define DONE_EXPAND	2
389 
390 static int	expanding;
391 
392 int
393 igetc(void)
394 {
395 	int	c;
396 
397 	while (1) {
398 		if (file->ungetpos > 0)
399 			c = file->ungetbuf[--file->ungetpos];
400 		else
401 			c = getc(file->stream);
402 
403 		if (c == START_EXPAND)
404 			expanding = 1;
405 		else if (c == DONE_EXPAND)
406 			expanding = 0;
407 		else
408 			break;
409 	}
410 	return (c);
411 }
412 
413 int
414 lgetc(int quotec)
415 {
416 	int		c;
417 
418 	if (quotec) {
419 		if ((c = igetc()) == EOF) {
420 			yyerror("reached end of filewhile parsing "
421 			    "quoted string");
422 			if (file == topfile || popfile() == EOF)
423 				return (EOF);
424 			return (quotec);
425 		}
426 		return (c);
427 	}
428 
429 	c = igetc();
430 	if (c == '\t' || c == ' ') {
431 		/* Compress blanks to a sigle space. */
432 		do {
433 			c = getc(file->stream);
434 		} while (c == '\t'  || c == ' ');
435 		ungetc(c, file->stream);
436 		c = ' ';
437 	}
438 
439 	if (c == EOF) {
440 		/*
441 		 * Fake EOL when hit EOF for the first time. This gets line
442 		 * count right if last line in included file is syntactically
443 		 * invalid and has no newline.
444 		 */
445 		if (file->eof_reached == 0) {
446 			file->eof_reached = 1;
447 			return ('\n');
448 		}
449 		while (c == EOF) {
450 			if (file == topfile || popfile() == EOF)
451 				return (EOF);
452 			c = igetc();
453 		}
454 	}
455 	return (c);
456 }
457 
458 void
459 lungetc(int c)
460 {
461 	if (c == EOF)
462 		return;
463 
464 	if (file->ungetpos >= file->ungetsize) {
465 		void *p = reallocarray(file->ungetbuf, file->ungetsize, 2);
466 		if (p == NULL)
467 			err(1, "reallocarray");
468 		file->ungetbuf = p;
469 		file->ungetsize *= 2;
470 	}
471 	file->ungetbuf[file->ungetpos++] = c;
472 }
473 
474 int
475 findeol(void)
476 {
477 	int	c;
478 
479 	/* skip to either EOF or the first real EOL */
480 	while (1) {
481 		c = lgetc(0);
482 		if (c == '\n') {
483 			file->lineno++;
484 			break;
485 		}
486 		if (c == EOF)
487 			break;
488 	}
489 	return (ERROR);
490 }
491 
492 int
493 yylex(void)
494 {
495 	char		 buf[8096];
496 	char		*p = buf;
497 	int		 c;
498 	int		 token;
499 	int		 starting = 0;
500 	int		 ending = 0;
501 	int		 quote = 0;
502 
503 	if (!in_define && block == 0) {
504 		while ((c = lgetc(0)) != '{' && c != EOF) {
505 			if (c == '\n')
506 				file->lineno++;
507 		}
508 
509 		if (c == EOF)
510 			return (0);
511 
512 newblock:
513 		c = lgetc(0);
514 		if (c == '{' || c == '!') {
515 			if (c == '{')
516 				block = '}';
517 			else
518 				block = c;
519 			return (c);
520 		}
521 		if (c == '\n')
522 			file->lineno++;
523 	}
524 
525 	while ((c = lgetc(0)) == ' ' || c == '\t' || c == '\n') {
526 		if (c == '\n')
527 			file->lineno++;
528 	}
529 
530 	if (c == EOF) {
531 		yyerror("unterminated block");
532 		return (0);
533 	}
534 
535 	yylval.lineno = file->lineno;
536 
537 	if (block != 0 && c == block) {
538 		if ((c = lgetc(0)) == '}') {
539 			if (block == '!') {
540 				block = 0;
541 				return ('!');
542 			}
543 			block = 0;
544 			return ('}');
545 		}
546 		lungetc(c);
547 		c = block;
548 	}
549 
550 	if (in_define && block == 0) {
551 		if (c == '{')
552 			goto newblock;
553 
554 		do {
555 			if (starting) {
556 				if (c == '!' || c == '{') {
557 					lungetc(c);
558 					lungetc('{');
559 					break;
560 				}
561 				starting = 0;
562 				lungetc(c);
563 				c = '{';
564 			} else if (c == '{') {
565 				starting = 1;
566 				continue;
567 			} else if (c == '\n')
568 				break;
569 
570 			*p++ = c;
571 			if ((size_t)(p - buf) >= sizeof(buf)) {
572 				yyerror("string too long");
573 				return (findeol());
574 			}
575 		} while ((c = lgetc(0)) != EOF);
576 		*p = '\0';
577 		if (c == EOF) {
578 			yyerror("unterminated block");
579 			return (0);
580 		}
581 		if (c == '\n')
582 			file->lineno++;
583 		if ((yylval.v.string = strdup(buf)) == NULL)
584 			err(1, "strdup");
585 		return (STRING);
586 	}
587 
588 	if (block == '!') {
589 		do {
590 			if (ending) {
591 				if (c == '}') {
592 					lungetc(c);
593 					lungetc(block);
594 					break;
595 				}
596 				ending = 0;
597 				lungetc(c);
598 				c = block;
599 			} else if (c == '!') {
600 				ending = 1;
601 				continue;
602 			} else if (c == '\n')
603 				break;
604 
605 			*p++ = c;
606 			if ((size_t)(p - buf) >= sizeof(buf)) {
607 				yyerror("line too long");
608 				return (findeol());
609 			}
610 		} while ((c = lgetc(0)) != EOF);
611 		*p = '\0';
612 
613 		if (c == EOF) {
614 			yyerror("unterminated block");
615 			return (0);
616 		}
617 		if (c == '\n')
618 			file->lineno++;
619 
620 		if ((yylval.v.string = strdup(buf)) == NULL)
621 			err(1, "strdup");
622 		return (STRING);
623 	}
624 
625 	if (c == '|')
626 		return (c);
627 
628 	do {
629 		if (!quote && isspace((unsigned char)c))
630 			break;
631 
632 		if (c == '"')
633 			quote = !quote;
634 
635 		if (!quote && c == '|') {
636 			lungetc(c);
637 			break;
638 		}
639 
640 		if (ending) {
641 			if (c == '}') {
642 				lungetc(c);
643 				lungetc('}');
644 				break;
645 			}
646 			ending = 0;
647 			lungetc(c);
648 			c = block;
649 		} else if (!quote && c == '}') {
650 			ending = 1;
651 			continue;
652 		}
653 
654 		*p++ = c;
655 		if ((size_t)(p - buf) >= sizeof(buf)) {
656 			yyerror("string too long");
657 			return (findeol());
658 		}
659 	} while ((c = lgetc(0)) != EOF);
660 	*p = '\0';
661 
662 	if (c == EOF) {
663 		yyerror(quote ? "unterminated quote" : "unterminated block");
664 		return (0);
665 	}
666 	if (c ==  '\n')
667 		file->lineno++;
668 	if ((token = lookup(buf)) == STRING)
669 		if ((yylval.v.string = strdup(buf)) == NULL)
670 			err(1, "strdup");
671 	return (token);
672 }
673 
674 struct file *
675 pushfile(const char *name, int secret)
676 {
677 	struct file	*nfile;
678 
679 	if ((nfile = calloc(1, sizeof(*nfile))) == NULL)
680 		err(1, "calloc");
681 	if ((nfile->name = strdup(name)) == NULL)
682 		err(1, "strdup");
683 	if ((nfile->stream = fopen(nfile->name, "r")) == NULL) {
684 		warn("can't open %s", nfile->name);
685 		free(nfile->name);
686 		free(nfile);
687 		return (NULL);
688 	}
689 	nfile->lineno = TAILQ_EMPTY(&files) ? 1 : 0;
690 	nfile->ungetsize = 16;
691 	nfile->ungetbuf = malloc(nfile->ungetsize);
692 	if (nfile->ungetbuf == NULL)
693 		err(1, "malloc");
694 	TAILQ_INSERT_TAIL(&files, nfile, entry);
695 	return (nfile);
696 }
697 
698 int
699 popfile(void)
700 {
701 	struct file	*prev;
702 
703 	if ((prev = TAILQ_PREV(file, files, entry)) != NULL)
704 		prev->errors += file->errors;
705 
706 	TAILQ_REMOVE(&files, file, entry);
707 	fclose(file->stream);
708 	free(file->name);
709 	free(file->ungetbuf);
710 	free(file);
711 	file = prev;
712 	return (file ? 0 : EOF);
713 }
714 
715 int
716 parse(FILE *outfile, const char *filename)
717 {
718 	fp = outfile;
719 
720 	if ((file = pushfile(filename, 0)) == 0)
721 		return (-1);
722 	topfile = file;
723 
724 	yyparse();
725 	errors = file->errors;
726 	popfile();
727 
728 	return (errors ? -1 : 0);
729 }
730 
731 void
732 dbg(void)
733 {
734 	if (nodebug)
735 		return;
736 
737 	if (yylval.lineno == lastline + 1) {
738 		lastline = yylval.lineno;
739 		return;
740 	}
741 	lastline = yylval.lineno;
742 
743 	fprintf(fp, "#line %d ", yylval.lineno);
744 	printq(file->name);
745 	putc('\n', fp);
746 }
747 
748 void
749 printq(const char *str)
750 {
751 	putc('"', fp);
752 	for (; *str; ++str) {
753 		if (*str == '"')
754 			putc('\\', fp);
755 		putc(*str, fp);
756 	}
757 	putc('"', fp);
758 }