commit - a6238a4fc991acfceb605346baa838ad40e555dd
commit + bff58270a8ffa0e66ce97234e440b545ba9290d3
blob - 8c03fe56e6f17e0382ee573493d969d629cd22af
blob + 2c280566f2aef354a7a5e6a5d749131b779d9161
--- Makefile
+++ Makefile
+.PATH:${.CURDIR}/template/
+
PROG = galileo
SRCS = galileo.c config.c fcgi.c log.c parse.y proc.c proxy.c \
- xmalloc.c
+ tmpl.c xmalloc.c
+# templates
+SRCS += fragments.c
+
MAN = ${PROG}.conf.5 ${PROG}.8
# debug
CFLAGS += -O0 -g3
-CFLAGS += -I${.CURDIR}
+CFLAGS += -I${.CURDIR} -I${.CURDIR}/template
WARNINGS = yes
SBINDIR?= ${PREFIX}/sbin
MANDIR?= ${PREFIX}/man/man
+fragments.c: fragments.tmpl
+ ${.CURDIR}/template/obj/template $? > $@
+
realinstall:
${INSTALL} ${INSTALL_COPY} -o ${BINOWN} -g ${BINGRP} \
-m ${BINMODE} ${PROG} ${SBINDIR}/${PROG}
blob - 515d41d950c37724dbb178c003a47d2a84d69946
blob + 595f05ec0916cb194741e3f8f6d831dd3430c142
--- galileo.h
+++ galileo.h
struct imsg;
struct privsep;
struct privsep_proc;
+struct template;
struct tls;
struct client {
struct tls *clt_ctx;
struct bufferevent *clt_bev;
int clt_headersdone;
+ struct template *clt_tp;
#define TR_ENABLED 0x1
#define TR_PRE 0x2
int fcgi_cmp(struct fcgi *, struct fcgi *);
int fcgi_client_cmp(struct client *, struct client *);
+/* fragments.tmpl */
+int tp_head(struct template *, const char *, const char *);
+int tp_foot(struct template *);
+int tp_figure(struct template *, const char *, const char *);
+
/* galileo.c */
int accept_reserve(int, struct sockaddr *, socklen_t *, int,
volatile int *);
blob - d7c7097bac03f3fc7134cad494036ace115aebc0
blob + 6096ef855d97f397cf4a1cb0c4521cdf43eca476
--- proxy.c
+++ proxy.c
#include "log.h"
#include "proc.h"
+#include "tmpl.h"
#include "galileo.h"
clt->clt_translate &= ~TR_NAV;
}
- if (clt_puts(clt, "<figure><a href='") == -1 ||
- printurl(clt, line) == -1 ||
- clt_puts(clt, "'><img src='") == -1 ||
- printurl(clt, line) == -1 ||
- clt_puts(clt, "' /></a><figcaption>") == -1 ||
- htmlescape(clt, label) == -1 ||
- clt_puts(clt, "</figcaption></figure>") == -1)
+ if (tp_figure(clt->clt_tp, line, label) == -1)
return (-1);
return (0);
*semi = ';';
continue;
}
+ }
+
+ return (0);
+}
+
+static int
+proxy_tp_puts(struct template *tp, const char *c)
+{
+ struct client *clt = tp->tp_arg;
+
+ if (clt_puts(clt, c) == -1) {
+ tp->tp_ret = -1;
+ return (-1);
}
+ return (0);
+}
+static int
+proxy_tp_putc(struct template *tp, int c)
+{
+ struct client *clt = tp->tp_arg;
+
+ if (clt_putc(clt, c) == -1) {
+ tp->tp_ret = -1;
+ return (-1);
+ }
return (0);
}
goto err;
}
- if (clt->clt_translate)
+ if (clt->clt_translate) {
+ clt->clt_tp = template(clt, proxy_tp_puts, proxy_tp_putc);
+
ctype = "text/html;charset=utf-8";
- else
+ } else
ctype = mime;
if (clt_printf(clt, "Content-Type: %s\r\n\r\n", ctype) == -1)
clt->clt_headersdone = 1;
- if (clt->clt_translate) {
- if (clt_puts(clt, "<!doctype html><html") == -1)
- goto err;
- if (*lang != '\0') {
- if (clt_puts(clt, " lang='") == -1 ||
- printurl(clt, lang) == -1 ||
- clt_puts(clt, "'") == -1)
- goto err;
- }
- if (clt_puts(clt, "><head>") == -1)
- goto err;
- if (*pc->stylesheet != '\0' &&
- clt_printf(clt, "<link rel='stylesheet' href='%s' />",
- pc->stylesheet) == -1)
- goto err;
- if (clt_puts(clt,
- "<meta name='viewport' content='initial-scale=1' />")
- == -1)
- goto err;
- if (clt_puts(clt, "</head><body>") == -1)
- goto err;
- }
+ if (clt->clt_translate &&
+ tp_head(clt->clt_tp, lang, pc->stylesheet) == -1)
+ goto err;
/*
* Trigger the read again so we proceed with the response
clt->clt_translate &= ~TR_NAV;
}
- if (clt_puts(clt, "<footer>") == -1 ||
- clt_puts(clt, "<hr />") == -1 ||
- clt_puts(clt, "<dl>") == -1 ||
- clt_puts(clt, "<dt>Original URL:</dt>") == -1 ||
- clt_puts(clt, "<dd><a href='gemini://") == -1 ||
- printurl(clt, clt->clt_pc->proxy_name) == -1 ||
- printurl(clt, clt->clt_path_info) == -1 ||
- clt_puts(clt, "'>gemini://") == -1 ||
- htmlescape(clt, clt->clt_pc->proxy_name) == -1 ||
- htmlescape(clt, clt->clt_path_info) == -1 ||
- clt_puts(clt, "</a></dd>") == -1 ||
- clt_puts(clt, "</dl></footer>") == -1)
+ if (tp_foot(clt->clt_tp) == -1)
return;
- if (clt_puts(clt, "</body></html>") == -1)
- return;
}
fcgi_end_request(clt, status);
if (clt->clt_bev)
bufferevent_free(clt->clt_bev);
+ free(clt->clt_tp);
free(clt->clt_server_name);
free(clt->clt_script_name);
free(clt->clt_path_info);
blob - /dev/null
blob + 85f50b727ebffe31cbcc01d3522a66c5c57b49eb (mode 644)
--- /dev/null
+++ template/Makefile
+PROG = template
+SRCS = template.c parse.y
+
+# XXX
+NOMAN = Yes
+
+
+# debug
+CFLAGS += -O0 -g3
+
+CFLAGS += -I${.CURDIR}
+
+WARNINGS = yes
+
+CDIAGFLAGS = -Wall -Wextra -Wpointer-arith -Wuninitialized
+CDIAGFLAGS+= -Wstrict-prototypes -Wmissing-prototypes -Wunused
+CDIAGFLAGS+= -Wsign-compare -Wshadow -Wno-unused-parameter
+CDIAGFLAGS+= -Wno-missing-field-initializers
+CDIAGFLAGS+= -Werror
+
+.if make(regress) || make(clean)
+SUBDIR = regress
+.endif
+
+.include <bsd.prog.mk>
blob - /dev/null
blob + 24c966b200d01acdfa53e4217059071dfa05e31f (mode 644)
--- /dev/null
+++ template/parse.y
+/*
+ * Copyright (c) 2022 Omar Polo <op@omarpolo.com>
+ * Copyright (c) 2007-2016 Reyk Floeter <reyk@openbsd.org>
+ * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org>
+ * Copyright (c) 2004 Ryan McBride <mcbride@openbsd.org>
+ * Copyright (c) 2002, 2003, 2004 Henning Brauer <henning@openbsd.org>
+ * Copyright (c) 2001 Markus Friedl. All rights reserved.
+ * Copyright (c) 2001 Daniel Hartmeier. All rights reserved.
+ * Copyright (c) 2001 Theo de Raadt. All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+%{
+
+#include <sys/queue.h>
+
+#include <ctype.h>
+#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifndef nitems
+#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
+#endif
+
+TAILQ_HEAD(files, file) files = TAILQ_HEAD_INITIALIZER(files);
+static struct file {
+ TAILQ_ENTRY(file) entry;
+ FILE *stream;
+ char *name;
+ size_t ungetpos;
+ size_t ungetsize;
+ u_char *ungetbuf;
+ int eof_reached;
+ int lineno;
+ int errors;
+} *file, *topfile;
+int parse(const char *);
+struct file *pushfile(const char *, int);
+int popfile(void);
+int yyparse(void);
+int yylex(void);
+int yyerror(const char *, ...)
+ __attribute__((__format__ (printf, 1, 2)))
+ __attribute__((__nonnull__ (1)));
+int kw_cmp(const void *, const void *);
+int lookup(char *);
+int igetc(void);
+int lgetc(int);
+void lungetc(int);
+int findeol(void);
+
+void dbg(void);
+void printq(const char *);
+
+extern int nodebug;
+
+static int block;
+static int in_define;
+static int errors;
+static char lerr[32];
+
+typedef struct {
+ union {
+ char *string;
+ } v;
+ int lineno;
+} YYSTYPE;
+
+%}
+
+%token DEFINE ELSE END ERROR ESCAPE FINALLY IF INCLUDE
+%token RENDER TQFOREACH UNSAFE URLESCAPE
+%token <v.string> STRING
+%type <v.string> string
+
+%%
+
+grammar : /* empty */
+ | grammar include
+ | grammar verbatim
+ | grammar block
+ | grammar error { file->errors++; }
+ ;
+
+include : INCLUDE STRING {
+ struct file *nfile;
+
+ if ((nfile = pushfile($2, 0)) == NULL) {
+ yyerror("failed to include file %s", $2);
+ free($2);
+ YYERROR;
+ }
+ free($2);
+
+ file = nfile;
+ lungetc('\n');
+ }
+ ;
+
+verbatim : '!' verbatim1 '!' {
+ if (in_define) {
+ /* TODO: check template status and exit in case */
+ }
+ }
+ ;
+
+verbatim1 : /* empty */
+ | verbatim1 STRING {
+ if (*$2 != '\0') {
+ dbg();
+ puts($2);
+ }
+ free($2);
+ }
+ ;
+
+verbatims : /* empty */
+ | verbatims verbatim
+ ;
+
+raw : STRING {
+ dbg();
+ printf("if (tp->tp_puts(tp, ");
+ printq($1);
+ printf(") == -1) goto %s;\n", lerr);
+
+ free($1);
+ }
+ ;
+
+block : define body end {
+ printf("%s:\n", lerr);
+ puts("return tp->tp_ret;");
+ puts("}");
+ in_define = 0;
+ }
+ | define body finally end {
+ puts("return tp->tp_ret;");
+ puts("}");
+ in_define = 0;
+ }
+ ;
+
+define : '{' DEFINE string '}' {
+ in_define = 1;
+ (void)snprintf(lerr, sizeof(lerr), "err%llu",
+ (unsigned long long)arc4random());
+
+ dbg();
+ printf("int\n%s\n{\n", $3);
+
+ free($3);
+ }
+ ;
+
+body : /* empty */
+ | body verbatim
+ | body raw
+ | body special
+ ;
+
+special : '{' RENDER string '}' {
+ dbg();
+ if (strrchr($3, ')') != NULL)
+ printf("if (%s == -1) goto %s;\n",
+ $3, lerr);
+ else
+ printf("if (%s != NULL && %s(tp) == -1) "
+ "goto %s;\n", $3, $3, lerr);
+ free($3);
+ }
+ | if body endif { puts("}"); }
+ | loop
+ | '{' string '|' ESCAPE '}' {
+ dbg();
+ printf("if (tp->tp_escape(tp, %s) == -1) goto %s;\n",
+ $2, lerr);
+ free($2);
+ }
+ | '{' string '|' UNSAFE '}' {
+ dbg();
+ printf("if (tp->tp_puts(tp, %s) == -1) goto %s;\n",
+ $2, lerr);
+ free($2);
+ }
+ | '{' string '|' URLESCAPE '}' {
+ dbg();
+ printf("if (tp_urlescape(tp, %s) == -1) goto %s;\n",
+ $2, lerr);
+ free($2);
+ }
+ | '{' string '}' {
+ dbg();
+ printf("if (tp->tp_escape(tp, %s) == -1) goto %s;\n",
+ $2, lerr);
+ free($2);
+ }
+ ;
+
+if : '{' IF string '}' {
+ dbg();
+ printf("if (%s) {\n", $3);
+ free($3);
+ }
+ ;
+
+endif : end
+ | else body end
+ | elsif body endif
+ ;
+
+elsif : '{' ELSE IF string '}' {
+ dbg();
+ printf("} else if (%s) {\n", $4);
+ free($4);
+ }
+ ;
+
+else : '{' ELSE '}' {
+ dbg();
+ puts("} else {");
+ }
+ ;
+
+loop : '{' TQFOREACH STRING STRING STRING '}' {
+ printf("TAILQ_FOREACH(%s, %s, %s) {\n",
+ $3, $4, $5);
+ free($3);
+ free($4);
+ free($5);
+ } body end {
+ puts("}");
+ }
+ ;
+
+end : '{' END '}'
+ ;
+
+finally : '{' FINALLY '}' {
+ dbg();
+ printf("%s:\n", lerr);
+ } verbatims
+ ;
+
+string : STRING string {
+ if (asprintf(&$$, "%s %s", $1, $2) == -1)
+ err(1, "asprintf");
+ free($1);
+ free($2);
+ }
+ | STRING
+ ;
+
+%%
+
+struct keywords {
+ const char *k_name;
+ int k_val;
+};
+
+int
+yyerror(const char *fmt, ...)
+{
+ va_list ap;
+ char *msg;
+
+ file->errors++;
+ va_start(ap, fmt);
+ if (vasprintf(&msg, fmt, ap) == -1)
+ err(1, "yyerror vasprintf");
+ va_end(ap);
+ fprintf(stderr, "%s:%d: %s\n", file->name, yylval.lineno, msg);
+ free(msg);
+ return (0);
+}
+
+int
+kw_cmp(const void *k, const void *e)
+{
+ return (strcmp(k, ((const struct keywords *)e)->k_name));
+}
+
+int
+lookup(char *s)
+{
+ /* this has to be sorted always */
+ static const struct keywords keywords[] = {
+ { "define", DEFINE },
+ { "else", ELSE },
+ { "end", END },
+ { "escape", ESCAPE },
+ { "finally", FINALLY },
+ { "if", IF },
+ { "include", INCLUDE },
+ { "render", RENDER },
+ { "tailq-foreach", TQFOREACH },
+ { "unsafe", UNSAFE },
+ { "urlescape", URLESCAPE },
+ };
+ const struct keywords *p;
+
+ p = bsearch(s, keywords, nitems(keywords), sizeof(keywords[0]),
+ kw_cmp);
+
+ if (p)
+ return (p->k_val);
+ else
+ return (STRING);
+}
+
+#define START_EXPAND 1
+#define DONE_EXPAND 2
+
+static int expanding;
+
+int
+igetc(void)
+{
+ int c;
+
+ while (1) {
+ if (file->ungetpos > 0)
+ c = file->ungetbuf[--file->ungetpos];
+ else
+ c = getc(file->stream);
+
+ if (c == START_EXPAND)
+ expanding = 1;
+ else if (c == DONE_EXPAND)
+ expanding = 0;
+ else
+ break;
+ }
+ return (c);
+}
+
+int
+lgetc(int quotec)
+{
+ int c, next;
+
+ if (quotec) {
+ if ((c = igetc()) == EOF) {
+ yyerror("reached end of filewhile parsing "
+ "quoted string");
+ if (file == topfile || popfile() == EOF)
+ return (EOF);
+ return (quotec);
+ }
+ return (c);
+ }
+
+ while ((c = igetc()) == '\\') {
+ next = igetc();
+ if (next != '\n') {
+ c = next;
+ break;
+ }
+ yylval.lineno = file->lineno;
+ file->lineno++;
+ }
+ if (c == '\t' || c == ' ') {
+ /* Compress blanks to a sigle space. */
+ do {
+ c = getc(file->stream);
+ } while (c == '\t' || c == ' ');
+ ungetc(c, file->stream);
+ c = ' ';
+ }
+
+ if (c == EOF) {
+ /*
+ * Fake EOL when hit EOF for the first time. This gets line
+ * count rigchtif last line included file is syntactically
+ * invalid and has no newline.
+ */
+ if (file->eof_reached == 0) {
+ file->eof_reached = 1;
+ return ('\n');
+ }
+ while (c == EOF) {
+ if (file == topfile || popfile() == EOF)
+ return (EOF);
+ c = igetc();
+ }
+ }
+ return (c);
+}
+
+void
+lungetc(int c)
+{
+ if (c == EOF)
+ return;
+
+ if (file->ungetpos >= file->ungetsize) {
+ void *p = reallocarray(file->ungetbuf, file->ungetsize, 2);
+ if (p == NULL)
+ err(1, "reallocarray");
+ file->ungetbuf = p;
+ file->ungetsize *= 2;
+ }
+ file->ungetbuf[file->ungetpos++] = c;
+}
+
+int
+findeol(void)
+{
+ int c;
+
+ /* skip to either EOF or the first real EOL */
+ while (1) {
+ c = lgetc(0);
+ if (c == '\n') {
+ file->lineno++;
+ break;
+ }
+ if (c == EOF)
+ break;
+ }
+ return (ERROR);
+}
+
+int
+yylex(void)
+{
+ char buf[8096];
+ char *p = buf;
+ int c;
+ int token;
+ int starting = 0;
+ int ending = 0;
+
+ if (!in_define && block == 0) {
+ while ((c = lgetc(0)) != '{' && c != EOF) {
+ if (c == '\n')
+ file->lineno++;
+ }
+
+ if (c == EOF)
+ return (0);
+
+newblock:
+ c = lgetc(0);
+ if (c == '{' || c == '!') {
+ if (c == '{')
+ block = '}';
+ else
+ block = c;
+ return (c);
+ }
+ if (c == '\n')
+ file->lineno++;
+ }
+
+ while ((c = lgetc(0)) == ' ' || c == '\t' || c == '\n') {
+ if (c == '\n')
+ file->lineno++;
+ }
+
+ if (c == EOF) {
+ yyerror("unterminated block");
+ return (0);
+ }
+
+ yylval.lineno = file->lineno;
+
+ if (block != 0 && c == block) {
+ if ((c = lgetc(0)) == '}') {
+ if (block == '!') {
+ block = 0;
+ return ('!');
+ }
+ block = 0;
+ return ('}');
+ }
+ lungetc(c);
+ c = block;
+ }
+
+ if (in_define && block == 0) {
+ if (c == '{')
+ goto newblock;
+
+ do {
+ if (starting) {
+ if (c == '!' || c == '{') {
+ lungetc('{');
+ lungetc(c);
+ break;
+ }
+ starting = 0;
+ lungetc(c);
+ c = '{';
+ } else if (c == '{') {
+ starting = 1;
+ continue;
+ }
+
+ *p++ = c;
+ if ((size_t)(p - buf) >= sizeof(buf)) {
+ yyerror("string too long");
+ return (findeol());
+ }
+ } while ((c = lgetc(0)) != EOF && c != '\n');
+ *p = '\0';
+ if (c == EOF) {
+ yyerror("unterminated block");
+ return (0);
+ }
+ if (c == '\n')
+ file->lineno++;
+ if ((yylval.v.string = strdup(buf)) == NULL)
+ err(1, "strdup");
+ return (STRING);
+ }
+
+ if (block == '!') {
+ do {
+ if (ending) {
+ if (c == '}') {
+ lungetc(c);
+ lungetc(block);
+ break;
+ }
+ ending = 0;
+ lungetc(c);
+ c = block;
+ } else if (c == '!') {
+ ending = 1;
+ continue;
+ }
+
+ *p++ = c;
+ if ((size_t)(p - buf) >= sizeof(buf)) {
+ yyerror("line too long");
+ return (findeol());
+ }
+ } while ((c = lgetc(0)) != EOF && c != '\n');
+ *p = '\0';
+
+ if (c == EOF) {
+ yyerror("unterminated block");
+ return (0);
+ }
+ if (c == '\n')
+ file->lineno++;
+
+ if ((yylval.v.string = strdup(buf)) == NULL)
+ err(1, "strdup");
+ return (STRING);
+ }
+
+ if (c == '|')
+ return (c);
+
+ do {
+ if (c == '|') {
+ lungetc(c);
+ break;
+ }
+
+ if (ending) {
+ if (c == '}') {
+ lungetc(c);
+ lungetc('}');
+ break;
+ }
+ ending = 0;
+ lungetc(c);
+ c = block;
+ } else if (c == '}') {
+ ending = 1;
+ continue;
+ }
+
+ *p++ = c;
+ if ((size_t)(p - buf) >= sizeof(buf)) {
+ yyerror("string too long");
+ return (findeol());
+ }
+ } while ((c = lgetc(0)) != EOF && !isspace((unsigned char)c));
+ *p = '\0';
+
+ if (c == EOF) {
+ yyerror("unterminated block");
+ return (0);
+ }
+ if (c == '\n')
+ file->lineno++;
+ if ((token = lookup(buf)) == STRING)
+ if ((yylval.v.string = strdup(buf)) == NULL)
+ err(1, "strdup");
+ return (token);
+}
+
+struct file *
+pushfile(const char *name, int secret)
+{
+ struct file *nfile;
+
+ if ((nfile = calloc(1, sizeof(*nfile))) == NULL)
+ err(1, "calloc");
+ if ((nfile->name = strdup(name)) == NULL)
+ err(1, "strdup");
+ if ((nfile->stream = fopen(nfile->name, "r")) == NULL) {
+ warn("can't open %s", nfile->name);
+ free(nfile->name);
+ free(nfile);
+ return (NULL);
+ }
+ nfile->lineno = TAILQ_EMPTY(&files) ? 1 : 0;
+ nfile->ungetsize = 16;
+ nfile->ungetbuf = malloc(nfile->ungetsize);
+ if (nfile->ungetbuf == NULL)
+ err(1, "malloc");
+ TAILQ_INSERT_TAIL(&files, nfile, entry);
+ return (nfile);
+}
+
+int
+popfile(void)
+{
+ struct file *prev;
+
+ if ((prev = TAILQ_PREV(file, files, entry)) != NULL)
+ prev->errors += file->errors;
+
+ TAILQ_REMOVE(&files, file, entry);
+ fclose(file->stream);
+ free(file->name);
+ free(file->ungetbuf);
+ free(file);
+ file = prev;
+ return (file ? 0 : EOF);
+}
+
+int
+parse(const char *filename)
+{
+ if ((file = pushfile(filename, 0)) == 0)
+ return (-1);
+ topfile = file;
+
+ yyparse();
+ errors = file->errors;
+ popfile();
+
+ return (errors ? -1 : 0);
+}
+
+void
+dbg(void)
+{
+ if (nodebug)
+ return;
+
+ printf("#line %d ", yylval.lineno);
+ printq(file->name);
+ putchar('\n');
+}
+
+void
+printq(const char *str)
+{
+ putchar('"');
+ for (; *str; ++str) {
+ if (*str == '"')
+ putchar('\\');
+ putchar(*str);
+ }
+ putchar('"');
+}
blob - /dev/null
blob + e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 (mode 644)
blob - /dev/null
blob + c2d0fad50754e9ec3740571ad5e77d7dc475ab26 (mode 644)
--- /dev/null
+++ template/regress/01-noise-only.tmpl
+only
+noise
blob - /dev/null
blob + 9fda4795acb6662979fb44d2805bdadb0df7c43c (mode 644)
--- /dev/null
+++ template/regress/02-only-verbatim.tmpl
+{! #include <stdio.h> !}
+
+noise
+here
+
+{!
+int
+main(void)
+{
+ puts("hello, world!");
+ return 0;
+}
+!}
blob - /dev/null
blob + 270c611ee72c567bc1b2abec4cbc345bab9f15ba (mode 644)
--- /dev/null
+++ template/regress/02.expected
+hello, world!
blob - /dev/null
blob + 72fc2491d73a975d4a090dbe73551f9a3bd990ee (mode 644)
--- /dev/null
+++ template/regress/03-block.tmpl
+{! #include <stdlib.h> !}
+
+{{ define base(struct template *tp, const char *title) }}
+{! char *foo = NULL; !}
+<!doctype html>
+<html>
+ <head>
+ <title>{{ title }}</title>
+ </head>
+ <body>
+ <h1>{{ title }}</h1>
+ {{ render tp->tp_body }}
+ </body>
+</html>
+{{ finally }}
+{! free(foo); !}
+{{ end }}
blob - /dev/null
blob + 1321d087e7cfe62f16d62f44bf67ec720e19be5a (mode 644)
--- /dev/null
+++ template/regress/03.expected
+<!doctype html><html><head><title> *hello* </title></head><body><h1> *hello* </h1></body></html>
+<!doctype html><html><head><title><hello></title></head><body><h1><hello></h1></body></html>
blob - /dev/null
blob + 87bad8ee4581a664cf2097201d2d371369bcf9b1 (mode 644)
--- /dev/null
+++ template/regress/04-flow.tmpl
+{!
+#include <stdlib.h>
+#include <string.h>
+!}
+
+{{ define base(struct template *tp, const char *title) }}
+{! char *foo = NULL; !}
+<!doctype html>
+<html>
+ <head>
+ <title>{{ title }}</title>
+ </head>
+ <body>
+ <h1>{{ title }}</h1>
+ {{ if strchr(title, '*') != NULL }}
+ <p>"{{ title }}" has a '*' in it</p>
+ {{ if 1 }}
+ <p>tautology!</p>
+ {{ end }}
+ {{ else if strchr(title, '=') != NULL }}
+ <p>"{{ title }}" has a '=' in it!</p>
+ {{ else }}
+ <p>"{{ title }}" doesn't have a '*' in it</p>
+ {{ end }}
+ {{ render tp->tp_body }}
+ </body>
+</html>
+{{ finally }}
+{! free(foo); !}
+{{ end }}
blob - /dev/null
blob + 32240e27d9a6dbeeb395f7e760e2a043e29b939c (mode 644)
--- /dev/null
+++ template/regress/04.expected
+<!doctype html><html><head><title> *hello* </title></head><body><h1> *hello* </h1><p>" *hello* " has a '*' in it</p><p>tautology!</p></body></html>
+<!doctype html><html><head><title><hello></title></head><body><h1><hello></h1><p>"<hello>" doesn't have a '*' in it</p></body></html>
blob - /dev/null
blob + 0a1daeb5d04c95c9bfaa13fa6bd319e71f0c231e (mode 644)
--- /dev/null
+++ template/regress/05-loop.tmpl
+{!
+#include <sys/queue.h>
+#include <string.h>
+#include "lists.h"
+
+int list(struct template *, struct tailhead *);
+
+!}
+
+{{ define base(struct template *tp, struct tailhead *head) }}
+<!doctype html>
+<html>
+ <body>
+ {{ render list(tp, head) }}
+ </body>
+</html>
+{{ end }}
+
+{{ define list(struct template *tp, struct tailhead *head) }}
+ {! struct entry *np; !}
+ {{ if !TAILQ_EMPTY(head) }}
+ <p>items:</p>
+ <ul>
+ {{ tailq-foreach np head entries }}
+ <li>{{ np->text }}</li>
+ {{ end }}
+ </ul>
+ {{ else }}
+ <p>no items</p>
+ {{ end }}
+{{ end }}
blob - /dev/null
blob + 1c17d8e4f2fb97529887c0f02f9ee8e6d8d77c08 (mode 644)
--- /dev/null
+++ template/regress/05.expected
+<!doctype html><html><body><p>items:</p><ul><li>1</li><li>2</li></ul></body></html>
+<!doctype html><html><body><p>no items</p></body></html>
blob - /dev/null
blob + b2dcc4306bba2066a2b6162240a848836820a343 (mode 644)
--- /dev/null
+++ template/regress/06-escape.tmpl
+{! #include <stdlib.h> !}
+
+{{ define base(struct template *tp, const char *title) }}
+<!doctype html>
+<html>
+ <head>
+ <title>{{ title | urlescape }}</title>
+ </head>
+ <body>
+ <h1>{{ title | unsafe }}</h1>
+ {{ render tp->tp_body }}
+ </body>
+</html>
+{{ end }}
blob - /dev/null
blob + 6a9d734b454093206236753143743d95d5e473af (mode 644)
--- /dev/null
+++ template/regress/06.expected
+<!doctype html><html><head><title>%20*hello*%20</title></head><body><h1> *hello* </h1></body></html>
+<!doctype html><html><head><title><hello></title></head><body><h1><hello></h1></body></html>
blob - /dev/null
blob + 2a90c70cd5e4af08090a85f82bcda63c20a83324 (mode 644)
--- /dev/null
+++ template/regress/Makefile
+REGRESS_TARGETS = 00-empty \
+ 01-noise-only \
+ 02-only-verbatim \
+ 03-block \
+ 04-flow \
+ 05-loop \
+ 06-escape
+
+REGRESS_SETUP_ONCE = setup-comp
+REGRESS_CLEANUP = clean-comp
+NO_OBJ = Yes
+
+CFLAGS += -I${.CURDIR}/../
+
+setup-comp:
+ cp ${.CURDIR}/../tmpl.c .
+ ln -f ${.CURDIR}/../template template || \
+ ln -f ${.CURDIR}/../obj/template template
+
+clean-comp:
+ rm template
+ rm -f t got 0*.[cdo] runbase.[do] runlist.[do] tmpl.*
+
+.SUFFIXES: .tmpl .c .o
+
+.tmpl.c:
+ ./template $? > $@
+
+00-empty:
+ ./template 00-empty.tmpl >/dev/null
+
+01-noise-only:
+ ./template 01-noise-only.tmpl >/dev/null
+
+02-only-verbatim: 02-only-verbatim.o tmpl.o
+ ${CC} 02-only-verbatim.o tmpl.o -o t && ./t > got
+ diff -u ${.CURDIR}/02.expected got
+
+03-block: 03-block.o runbase.o tmpl.o
+ ${CC} 03-block.o runbase.o tmpl.o -o t && ./t > got
+ diff -u ${.CURDIR}/03.expected got
+
+04-flow: 04-flow.o runbase.o tmpl.o
+ ${CC} 04-flow.o runbase.o tmpl.o -o t && ./t > got
+ diff -u ${.CURDIR}/04.expected got
+
+05-loop: 05-loop.o runlist.o tmpl.o
+ ${CC} 05-loop.o runlist.o tmpl.o -o t && ./t > got
+ diff -u ${.CURDIR}/05.expected got
+
+06-escape: 06-escape.o runbase.o tmpl.o
+ ${CC} 06-escape.o runbase.o tmpl.o -o t && ./t > got
+ diff -u ${.CURDIR}/06.expected got
+
+.include <bsd.regress.mk>
blob - /dev/null
blob + 7229706ecd6bfb0bb2f38be92950b7082f7a6c41 (mode 644)
--- /dev/null
+++ template/regress/lists.h
+#include <sys/queue.h>
+
+TAILQ_HEAD(tailhead, entry);
+struct entry {
+ char *text;
+ TAILQ_ENTRY(entry) entries;
+};
blob - /dev/null
blob + 079c1cdcd7646cc4367a33ddbc44e91dbe465c30 (mode 644)
--- /dev/null
+++ template/regress/runbase.c
+/*
+ * Copyright (c) 2022 Omar Polo <op@omarpolo.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "tmpl.h"
+
+int base(struct template *, const char *title);
+
+int
+my_putc(struct template *tp, int c)
+{
+ FILE *fp = tp->tp_arg;
+
+ if (putc(c, fp) < 0) {
+ tp->tp_ret = -1;
+ return (-1);
+ }
+
+ return (0);
+}
+
+int
+my_puts(struct template *tp, const char *s)
+{
+ FILE *fp = tp->tp_arg;
+
+ if (fputs(s, fp) < 0) {
+ tp->tp_ret = -1;
+ return (-1);
+ }
+
+ return (0);
+}
+
+int
+main(int argc, char **argv)
+{
+ struct template *tp;
+
+ if ((tp = template(stdout, my_puts, my_putc)) == NULL)
+ err(1, "template");
+
+ base(tp, " *hello* ");
+ puts("");
+
+ template_reset(tp);
+
+ base(tp, "<hello>");
+ puts("");
+
+ free(tp);
+ return (0);
+}
blob - /dev/null
blob + 73afb09894b94e6728dbf1905ec8dae81608924f (mode 644)
--- /dev/null
+++ template/regress/runlist.c
+/*
+ * Copyright (c) 2022 Omar Polo <op@omarpolo.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "tmpl.h"
+#include "lists.h"
+
+int base(struct template *, struct tailhead *);
+
+int
+my_putc(struct template *tp, int c)
+{
+ FILE *fp = tp->tp_arg;
+
+ if (putc(c, fp) < 0) {
+ tp->tp_ret = -1;
+ return (-1);
+ }
+
+ return (0);
+}
+
+int
+my_puts(struct template *tp, const char *s)
+{
+ FILE *fp = tp->tp_arg;
+
+ if (fputs(s, fp) < 0) {
+ tp->tp_ret = -1;
+ return (-1);
+ }
+
+ return (0);
+}
+
+int
+main(int argc, char **argv)
+{
+ struct template *tp;
+ struct tailhead head;
+ struct entry *np;
+ int i;
+
+ if ((tp = template(stdout, my_puts, my_putc)) == NULL)
+ err(1, "template");
+
+ TAILQ_INIT(&head);
+ for (i = 0; i < 2; ++i) {
+ if ((np = calloc(1, sizeof(*np))) == NULL)
+ err(1, "calloc");
+ if (asprintf(&np->text, "%d", i+1) == -1)
+ err(1, "asprintf");
+ TAILQ_INSERT_TAIL(&head, np, entries);
+ }
+
+ base(tp, &head);
+ puts("");
+
+ while ((np = TAILQ_FIRST(&head))) {
+ TAILQ_REMOVE(&head, np, entries);
+ free(np->text);
+ free(np);
+ }
+
+ template_reset(tp);
+
+ base(tp, &head);
+ puts("");
+
+ free(tp);
+
+ return (0);
+}
blob - /dev/null
blob + f35c12a5a774cca9c6314d3441274f74714d17a9 (mode 644)
--- /dev/null
+++ template/template.c
+/*
+ * Copyright (c) 2022 Omar Polo <op@omarpolo.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int parse(const char *);
+
+int nodebug;
+
+static void __dead
+usage(void)
+{
+ fprintf(stderr, "usage: %s [file...]\n",
+ getprogname());
+ exit(1);
+}
+
+int
+main(int argc, char **argv)
+{
+ int ch, i;
+
+ if (pledge("stdio rpath", NULL) == -1)
+ err(1, "pledge");
+
+ while ((ch = getopt(argc, argv, "G")) != -1) {
+ switch (ch) {
+ case 'G':
+ nodebug = 1;
+ break;
+ default:
+ usage();
+ }
+ }
+ argc -= optind;
+ argv += optind;
+
+ /* preamble */
+ puts("#include \"tmpl.h\"");
+
+ if (argc == 0) {
+ parse("/dev/stdin");
+ exit(0);
+ }
+
+ for (i = 0; i < argc; ++i)
+ if (parse(argv[i]) == -1)
+ return (1);
+
+ return (0);
+}
blob - /dev/null
blob + 4cd589aa6877e36404e10e7bc59a5504d9548d55 (mode 644)
--- /dev/null
+++ template/tmpl.c
+/*
+ * Copyright (c) 2022 Omar Polo <op@omarpolo.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "tmpl.h"
+
+int
+tp_urlescape(struct template *tp, const char *str)
+{
+ int r;
+ char tmp[4];
+
+ for (; *str; ++str) {
+ if (iscntrl((unsigned char)*str) ||
+ isspace((unsigned char)*str) ||
+ *str == '\'' || *str == '"' || *str == '\\') {
+ r = snprintf(tmp, sizeof(tmp), "%%%2X", *str);
+ if (r < 0 || (size_t)r >= sizeof(tmp)) {
+ tp->tp_ret = -1;
+ return (-1);
+ }
+ if (tp->tp_puts(tp, tmp) == -1)
+ return (-1);
+ } else {
+ if (tp->tp_putc(tp, *str) == -1)
+ return (-1);
+ }
+ }
+
+ return (0);
+}
+
+int
+tp_htmlescape(struct template *tp, const char *str)
+{
+ int r;
+
+ for (; *str; ++str) {
+ switch (*str) {
+ case '<':
+ r = tp->tp_puts(tp, "<");
+ break;
+ case '>':
+ r = tp->tp_puts(tp, ">");
+ break;
+ case '&':
+ r = tp->tp_puts(tp, "&");
+ break;
+ case '"':
+ r = tp->tp_puts(tp, """);
+ break;
+ case '\'':
+ r = tp->tp_puts(tp, "'");
+ break;
+ default:
+ r = tp->tp_putc(tp, *str);
+ break;
+ }
+
+ if (r == -1) {
+ tp->tp_ret = -1;
+ return (-1);
+ }
+ }
+
+ return (0);
+}
+
+struct template *
+template(void *arg, tmpl_puts putsfn, tmpl_putc putcfn)
+{
+ struct template *tp;
+
+ if ((tp = calloc(1, sizeof(*tp))) == NULL)
+ return (NULL);
+
+ tp->tp_arg = arg;
+ tp->tp_escape = tp_htmlescape;
+ tp->tp_puts = putsfn;
+ tp->tp_putc = putcfn;
+
+ return (tp);
+}
+
+void
+template_reset(struct template *tp)
+{
+ tp->tp_ret = 0;
+}
blob - /dev/null
blob + 8feca604eb6abd04507d15d39f8f0d847d55fbc9 (mode 644)
--- /dev/null
+++ template/tmpl.h
+/*
+ * Copyright (c) 2022 Omar Polo <op@omarpolo.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef TMPL_H
+#define TMPL_H
+
+struct template;
+
+typedef int (*tmpl_puts)(struct template *, const char *);
+typedef int (*tmpl_putc)(struct template *, int);
+
+struct template {
+ void *tp_arg;
+ tmpl_puts tp_escape;
+ tmpl_puts tp_puts;
+ tmpl_putc tp_putc;
+
+ int tp_ret;
+
+ int (*tp_body)(struct template *);
+};
+
+int tp_urlescape(struct template *, const char *);
+int tp_htmlescape(struct template *, const char *);
+
+struct template *template(void *, tmpl_puts, tmpl_putc);
+void template_reset(struct template *);
+
+#endif
blob - /dev/null
blob + 5361df7900f73db6d6af3195fc438d37b2020100 (mode 644)
--- /dev/null
+++ template/y.tab.c
+/* A Bison parser, made by GNU Bison 3.7.6. */
+
+/* Bison implementation for Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
+ Inc.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+ simplifying the original so-called "semantic" parser. */
+
+/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
+ especially those whose name start with YY_ or yy_. They are
+ private implementation details that can be changed or removed. */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+ infringing on user name space. This should be done even for local
+ variables, as they might otherwise be expanded by user macros.
+ There are some unavoidable exceptions within include files to
+ define necessary library symbols; they are noted "INFRINGES ON
+ USER NAME SPACE" below. */
+
+/* Identify Bison output, and Bison version. */
+#define YYBISON 30706
+
+/* Bison version string. */
+#define YYBISON_VERSION "3.7.6"
+
+/* Skeleton name. */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers. */
+#define YYPURE 0
+
+/* Push parsers. */
+#define YYPUSH 0
+
+/* Pull parsers. */
+#define YYPULL 1
+
+
+
+
+/* First part of user prologue. */
+#line 24 "parse.y"
+
+
+#include <sys/queue.h>
+
+#include <ctype.h>
+#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifndef nitems
+#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
+#endif
+
+TAILQ_HEAD(files, file) files = TAILQ_HEAD_INITIALIZER(files);
+static struct file {
+ TAILQ_ENTRY(file) entry;
+ FILE *stream;
+ char *name;
+ size_t ungetpos;
+ size_t ungetsize;
+ u_char *ungetbuf;
+ int eof_reached;
+ int lineno;
+ int errors;
+} *file, *topfile;
+int parse(const char *);
+struct file *pushfile(const char *, int);
+int popfile(void);
+int yyparse(void);
+int yylex(void);
+int yyerror(const char *, ...)
+ __attribute__((__format__ (printf, 1, 2)))
+ __attribute__((__nonnull__ (1)));
+int kw_cmp(const void *, const void *);
+int lookup(char *);
+int igetc(void);
+int lgetc(int);
+void lungetc(int);
+int findeol(void);
+
+void dbg(void);
+void printq(const char *);
+
+extern int nodebug;
+
+static int block;
+static int in_define;
+static int errors;
+static char lerr[32];
+
+typedef struct {
+ union {
+ char *string;
+ } v;
+ int lineno;
+} YYSTYPE;
+
+
+#line 134 "y.tab.c"
+
+# ifndef YY_CAST
+# ifdef __cplusplus
+# define YY_CAST(Type, Val) static_cast<Type> (Val)
+# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
+# else
+# define YY_CAST(Type, Val) ((Type) (Val))
+# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
+# endif
+# endif
+# ifndef YY_NULLPTR
+# if defined __cplusplus
+# if 201103L <= __cplusplus
+# define YY_NULLPTR nullptr
+# else
+# define YY_NULLPTR 0
+# endif
+# else
+# define YY_NULLPTR ((void*)0)
+# endif
+# endif
+
+
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token kinds. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ enum yytokentype
+ {
+ YYEMPTY = -2,
+ YYEOF = 0, /* "end of file" */
+ YYerror = 256, /* error */
+ YYUNDEF = 257, /* "invalid token" */
+ DEFINE = 258, /* DEFINE */
+ ELSE = 259, /* ELSE */
+ END = 260, /* END */
+ ERROR = 261, /* ERROR */
+ FINALLY = 262, /* FINALLY */
+ IF = 263, /* IF */
+ INCLUDE = 264, /* INCLUDE */
+ RENDER = 265, /* RENDER */
+ TQFOREACH = 266, /* TQFOREACH */
+ STRING = 267 /* STRING */
+ };
+ typedef enum yytokentype yytoken_kind_t;
+#endif
+/* Token kinds. */
+#define YYEMPTY -2
+#define YYEOF 0
+#define YYerror 256
+#define YYUNDEF 257
+#define DEFINE 258
+#define ELSE 259
+#define END 260
+#define ERROR 261
+#define FINALLY 262
+#define IF 263
+#define INCLUDE 264
+#define RENDER 265
+#define TQFOREACH 266
+#define STRING 267
+
+/* Value type. */
+
+
+extern YYSTYPE yylval;
+
+int yyparse (void);
+
+
+/* Symbol kind. */
+enum yysymbol_kind_t
+{
+ YYSYMBOL_YYEMPTY = -2,
+ YYSYMBOL_YYEOF = 0, /* "end of file" */
+ YYSYMBOL_YYerror = 1, /* error */
+ YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
+ YYSYMBOL_DEFINE = 3, /* DEFINE */
+ YYSYMBOL_ELSE = 4, /* ELSE */
+ YYSYMBOL_END = 5, /* END */
+ YYSYMBOL_ERROR = 6, /* ERROR */
+ YYSYMBOL_FINALLY = 7, /* FINALLY */
+ YYSYMBOL_IF = 8, /* IF */
+ YYSYMBOL_INCLUDE = 9, /* INCLUDE */
+ YYSYMBOL_RENDER = 10, /* RENDER */
+ YYSYMBOL_TQFOREACH = 11, /* TQFOREACH */
+ YYSYMBOL_STRING = 12, /* STRING */
+ YYSYMBOL_13_ = 13, /* '!' */
+ YYSYMBOL_14_ = 14, /* '{' */
+ YYSYMBOL_15_ = 15, /* '}' */
+ YYSYMBOL_YYACCEPT = 16, /* $accept */
+ YYSYMBOL_grammar = 17, /* grammar */
+ YYSYMBOL_include = 18, /* include */
+ YYSYMBOL_verbatim = 19, /* verbatim */
+ YYSYMBOL_verbatim1 = 20, /* verbatim1 */
+ YYSYMBOL_verbatims = 21, /* verbatims */
+ YYSYMBOL_raw = 22, /* raw */
+ YYSYMBOL_block = 23, /* block */
+ YYSYMBOL_define = 24, /* define */
+ YYSYMBOL_body = 25, /* body */
+ YYSYMBOL_special = 26, /* special */
+ YYSYMBOL_if = 27, /* if */
+ YYSYMBOL_endif = 28, /* endif */
+ YYSYMBOL_elsif = 29, /* elsif */
+ YYSYMBOL_else = 30, /* else */
+ YYSYMBOL_loop = 31, /* loop */
+ YYSYMBOL_32_1 = 32, /* $@1 */
+ YYSYMBOL_end = 33, /* end */
+ YYSYMBOL_finally = 34, /* finally */
+ YYSYMBOL_35_2 = 35, /* $@2 */
+ YYSYMBOL_string = 36 /* string */
+};
+typedef enum yysymbol_kind_t yysymbol_kind_t;
+
+
+
+
+#ifdef short
+# undef short
+#endif
+
+/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
+ <limits.h> and (if available) <stdint.h> are included
+ so that the code can choose integer types of a good width. */
+
+#ifndef __PTRDIFF_MAX__
+# include <limits.h> /* INFRINGES ON USER NAME SPACE */
+# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
+# define YY_STDINT_H
+# endif
+#endif
+
+/* Narrow types that promote to a signed type and that can represent a
+ signed or unsigned integer of at least N bits. In tables they can
+ save space and decrease cache pressure. Promoting to a signed type
+ helps avoid bugs in integer arithmetic. */
+
+#ifdef __INT_LEAST8_MAX__
+typedef __INT_LEAST8_TYPE__ yytype_int8;
+#elif defined YY_STDINT_H
+typedef int_least8_t yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef __INT_LEAST16_MAX__
+typedef __INT_LEAST16_TYPE__ yytype_int16;
+#elif defined YY_STDINT_H
+typedef int_least16_t yytype_int16;
+#else
+typedef short yytype_int16;
+#endif
+
+/* Work around bug in HP-UX 11.23, which defines these macros
+ incorrectly for preprocessor constants. This workaround can likely
+ be removed in 2023, as HPE has promised support for HP-UX 11.23
+ (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
+ <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
+#ifdef __hpux
+# undef UINT_LEAST8_MAX
+# undef UINT_LEAST16_MAX
+# define UINT_LEAST8_MAX 255
+# define UINT_LEAST16_MAX 65535
+#endif
+
+#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST8_TYPE__ yytype_uint8;
+#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
+ && UINT_LEAST8_MAX <= INT_MAX)
+typedef uint_least8_t yytype_uint8;
+#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
+typedef unsigned char yytype_uint8;
+#else
+typedef short yytype_uint8;
+#endif
+
+#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST16_TYPE__ yytype_uint16;
+#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
+ && UINT_LEAST16_MAX <= INT_MAX)
+typedef uint_least16_t yytype_uint16;
+#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
+typedef unsigned short yytype_uint16;
+#else
+typedef int yytype_uint16;
+#endif
+
+#ifndef YYPTRDIFF_T
+# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
+# define YYPTRDIFF_T __PTRDIFF_TYPE__
+# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
+# elif defined PTRDIFF_MAX
+# ifndef ptrdiff_t
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# endif
+# define YYPTRDIFF_T ptrdiff_t
+# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
+# else
+# define YYPTRDIFF_T long
+# define YYPTRDIFF_MAXIMUM LONG_MAX
+# endif
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+# define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+# define YYSIZE_T size_t
+# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# else
+# define YYSIZE_T unsigned
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM \
+ YY_CAST (YYPTRDIFF_T, \
+ (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
+ ? YYPTRDIFF_MAXIMUM \
+ : YY_CAST (YYSIZE_T, -1)))
+
+#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
+
+
+/* Stored state numbers (used for stacks). */
+typedef yytype_int8 yy_state_t;
+
+/* State numbers in computations. */
+typedef int yy_state_fast_t;
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+# if ENABLE_NLS
+# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+# endif
+# endif
+# ifndef YY_
+# define YY_(Msgid) Msgid
+# endif
+#endif
+
+
+#ifndef YY_ATTRIBUTE_PURE
+# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
+# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
+# else
+# define YY_ATTRIBUTE_PURE
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
+# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+# else
+# define YY_ATTRIBUTE_UNUSED
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E. */
+#if ! defined lint || defined __GNUC__
+# define YY_USE(E) ((void) (E))
+#else
+# define YY_USE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized. */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
+ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+ _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
+# define YY_IGNORE_USELESS_CAST_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
+# define YY_IGNORE_USELESS_CAST_END \
+ _Pragma ("GCC diagnostic pop")
+#endif
+#ifndef YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_END
+#endif
+
+
+#define YY_ASSERT(E) ((void) (0 && (E)))
+
+#if !defined yyoverflow
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# ifdef YYSTACK_USE_ALLOCA
+# if YYSTACK_USE_ALLOCA
+# ifdef __GNUC__
+# define YYSTACK_ALLOC __builtin_alloca
+# elif defined __BUILTIN_VA_ARG_INCR
+# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+# elif defined _AIX
+# define YYSTACK_ALLOC __alloca
+# elif defined _MSC_VER
+# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+# define alloca _alloca
+# else
+# define YYSTACK_ALLOC alloca
+# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+ /* Use EXIT_SUCCESS as a witness for stdlib.h. */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# endif
+# endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's 'empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# ifndef YYSTACK_ALLOC_MAXIMUM
+ /* The OS might guarantee only one guard page at the bottom of the stack,
+ and a page size can be as small as 4096 bytes. So we cannot safely
+ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
+ to allow for a few compiler-allocated temporary stack slots. */
+# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+# endif
+# else
+# define YYSTACK_ALLOC YYMALLOC
+# define YYSTACK_FREE YYFREE
+# ifndef YYSTACK_ALLOC_MAXIMUM
+# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+# endif
+# if (defined __cplusplus && ! defined EXIT_SUCCESS \
+ && ! ((defined YYMALLOC || defined malloc) \
+ && (defined YYFREE || defined free)))
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# ifndef YYMALLOC
+# define YYMALLOC malloc
+# if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# ifndef YYFREE
+# define YYFREE free
+# if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# endif
+#endif /* !defined yyoverflow */
+
+#if (! defined yyoverflow \
+ && (! defined __cplusplus \
+ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ yy_state_t yyss_alloc;
+ YYSTYPE yyvs_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next. */
+# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+ N elements. */
+# define YYSTACK_BYTES(N) \
+ ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
+ + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one. The
+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
+ elements in the stack, and YYPTR gives the new location of the
+ stack. Advance YYPTR to a properly aligned location for the next
+ stack. */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
+ do \
+ { \
+ YYPTRDIFF_T yynewbytes; \
+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
+ Stack = &yyptr->Stack_alloc; \
+ yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
+ yyptr += yynewbytes / YYSIZEOF (*yyptr); \
+ } \
+ while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST. The source and destination do
+ not overlap. */
+# ifndef YYCOPY
+# if defined __GNUC__ && 1 < __GNUC__
+# define YYCOPY(Dst, Src, Count) \
+ __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
+# else
+# define YYCOPY(Dst, Src, Count) \
+ do \
+ { \
+ YYPTRDIFF_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (Dst)[yyi] = (Src)[yyi]; \
+ } \
+ while (0)
+# endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL 2
+/* YYLAST -- Last index in YYTABLE. */
+#define YYLAST 69
+
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS 16
+/* YYNNTS -- Number of nonterminals. */
+#define YYNNTS 21
+/* YYNRULES -- Number of rules. */
+#define YYNRULES 37
+/* YYNSTATES -- Number of states. */
+#define YYNSTATES 71
+
+/* YYMAXUTOK -- Last valid token kind. */
+#define YYMAXUTOK 267
+
+
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex, with out-of-bounds checking. */
+#define YYTRANSLATE(YYX) \
+ (0 <= (YYX) && (YYX) <= YYMAXUTOK \
+ ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
+ : YYSYMBOL_YYUNDEF)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex. */
+static const yytype_int8 yytranslate[] =
+{
+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 13, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 14, 2, 15, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, 12
+};
+
+#if YYDEBUG
+ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
+static const yytype_uint8 yyrline[] =
+{
+ 0, 93, 93, 94, 95, 96, 97, 100, 115, 122,
+ 123, 132, 133, 136, 146, 152, 159, 171, 172, 173,
+ 174, 177, 187, 188, 189, 196, 203, 204, 205, 208,
+ 215, 221, 221, 232, 235, 235, 241, 247
+};
+#endif
+
+/** Accessing symbol of state STATE. */
+#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
+
+#if YYDEBUG || 0
+/* The user-facing name of the symbol whose (internal) number is
+ YYSYMBOL. No bounds checking. */
+static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
+
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+static const char *const yytname[] =
+{
+ "\"end of file\"", "error", "\"invalid token\"", "DEFINE", "ELSE",
+ "END", "ERROR", "FINALLY", "IF", "INCLUDE", "RENDER", "TQFOREACH",
+ "STRING", "'!'", "'{'", "'}'", "$accept", "grammar", "include",
+ "verbatim", "verbatim1", "verbatims", "raw", "block", "define", "body",
+ "special", "if", "endif", "elsif", "else", "loop", "$@1", "end",
+ "finally", "$@2", "string", YY_NULLPTR
+};
+
+static const char *
+yysymbol_name (yysymbol_kind_t yysymbol)
+{
+ return yytname[yysymbol];
+}
+#endif
+
+#ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+ (internal) symbol number NUM (which must be that of a token). */
+static const yytype_int16 yytoknum[] =
+{
+ 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
+ 265, 266, 267, 33, 123, 125
+};
+#endif
+
+#define YYPACT_NINF (-21)
+
+#define yypact_value_is_default(Yyn) \
+ ((Yyn) == YYPACT_NINF)
+
+#define YYTABLE_NINF (-1)
+
+#define yytable_value_is_error(Yyn) \
+ 0
+
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+ STATE-NUM. */
+static const yytype_int8 yypact[] =
+{
+ -21, 5, -21, -21, 4, -21, 14, -21, -21, -21,
+ -21, -21, 0, 8, -3, -21, -21, 8, 6, -21,
+ 29, -21, -21, -21, -21, -21, -21, 10, -21, -21,
+ 15, 20, 8, 8, 26, 27, 41, 38, -21, -21,
+ -21, 31, 47, 49, -21, 21, -21, -21, -21, -21,
+ -21, -21, -21, 51, -7, 41, 46, 52, 53, 8,
+ -21, -21, 40, -21, -21, -21, 54, -21, -21, 46,
+ -21
+};
+
+ /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+ Performed when YYTABLE does not specify something else to do. Zero
+ means the default is an error. */
+static const yytype_int8 yydefact[] =
+{
+ 2, 0, 1, 6, 0, 9, 0, 3, 4, 5,
+ 17, 7, 0, 0, 0, 10, 8, 37, 0, 13,
+ 0, 18, 19, 20, 17, 23, 14, 0, 36, 16,
+ 0, 0, 0, 0, 0, 0, 0, 0, 15, 33,
+ 34, 0, 0, 0, 24, 0, 22, 17, 17, 26,
+ 11, 25, 21, 0, 0, 0, 0, 35, 0, 0,
+ 30, 28, 0, 27, 12, 31, 0, 17, 29, 0,
+ 32
+};
+
+ /* YYPGOTO[NTERM-NUM]. */
+static const yytype_int8 yypgoto[] =
+{
+ -21, -21, -21, -1, -21, -21, -21, -21, -21, -20,
+ -21, -21, 9, -21, -21, -21, -21, -12, -21, -21,
+ -10
+};
+
+ /* YYDEFGOTO[NTERM-NUM]. */
+static const yytype_int8 yydefgoto[] =
+{
+ 0, 1, 7, 21, 12, 57, 22, 9, 10, 14,
+ 23, 24, 46, 47, 48, 25, 67, 49, 27, 50,
+ 35
+};
+
+ /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
+ positive, shift that token. If negative, reduce the rule whose
+ number is the opposite. If YYTABLE_NINF, syntax error. */
+static const yytype_int8 yytable[] =
+{
+ 8, 59, 26, 18, 36, 2, 3, 28, 60, 19,
+ 5, 20, 15, 16, 4, 38, 11, 13, 5, 6,
+ 17, 29, 41, 42, 37, 54, 30, 55, 56, 32,
+ 39, 33, 34, 17, 30, 40, 31, 32, 43, 33,
+ 34, 17, 44, 30, 63, 30, 51, 69, 32, 66,
+ 33, 34, 17, 19, 5, 45, 64, 70, 19, 5,
+ 62, 53, 52, 58, 61, 5, 0, 0, 65, 68
+};
+
+static const yytype_int8 yycheck[] =
+{
+ 1, 8, 14, 13, 24, 0, 1, 17, 15, 12,
+ 13, 14, 12, 13, 9, 27, 12, 3, 13, 14,
+ 12, 15, 32, 33, 14, 4, 5, 47, 48, 8,
+ 15, 10, 11, 12, 5, 15, 7, 8, 12, 10,
+ 11, 12, 15, 5, 56, 5, 15, 67, 8, 59,
+ 10, 11, 12, 12, 13, 14, 57, 69, 12, 13,
+ 14, 12, 15, 12, 55, 13, -1, -1, 15, 15
+};
+
+ /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+ symbol of state STATE-NUM. */
+static const yytype_int8 yystos[] =
+{
+ 0, 17, 0, 1, 9, 13, 14, 18, 19, 23,
+ 24, 12, 20, 3, 25, 12, 13, 12, 36, 12,
+ 14, 19, 22, 26, 27, 31, 33, 34, 36, 15,
+ 5, 7, 8, 10, 11, 36, 25, 14, 33, 15,
+ 15, 36, 36, 12, 15, 14, 28, 29, 30, 33,
+ 35, 15, 15, 12, 4, 25, 25, 21, 12, 8,
+ 15, 28, 14, 33, 19, 15, 36, 32, 15, 25,
+ 33
+};
+
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const yytype_int8 yyr1[] =
+{
+ 0, 16, 17, 17, 17, 17, 17, 18, 19, 20,
+ 20, 21, 21, 22, 23, 23, 24, 25, 25, 25,
+ 25, 26, 26, 26, 26, 27, 28, 28, 28, 29,
+ 30, 32, 31, 33, 35, 34, 36, 36
+};
+
+ /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
+static const yytype_int8 yyr2[] =
+{
+ 0, 2, 0, 2, 2, 2, 2, 2, 3, 0,
+ 2, 0, 2, 1, 3, 4, 4, 0, 2, 2,
+ 2, 4, 3, 1, 3, 4, 1, 3, 3, 5,
+ 3, 0, 9, 3, 0, 5, 2, 1
+};
+
+
+enum { YYENOMEM = -2 };
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+
+#define YYACCEPT goto yyacceptlab
+#define YYABORT goto yyabortlab
+#define YYERROR goto yyerrorlab
+
+
+#define YYRECOVERING() (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value) \
+ do \
+ if (yychar == YYEMPTY) \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
+ YYPOPSTACK (yylen); \
+ yystate = *yyssp; \
+ goto yybackup; \
+ } \
+ else \
+ { \
+ yyerror (YY_("syntax error: cannot back up")); \
+ YYERROR; \
+ } \
+ while (0)
+
+/* Backward compatibility with an undocumented macro.
+ Use YYerror or YYUNDEF. */
+#define YYERRCODE YYUNDEF
+
+
+/* Enable debugging if requested. */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+# define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+# ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+
+
+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yy_symbol_print (stderr, \
+ Kind, Value); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (0)
+
+
+/*-----------------------------------.
+| Print this symbol's value on YYO. |
+`-----------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyo,
+ yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
+{
+ FILE *yyoutput = yyo;
+ YY_USE (yyoutput);
+ if (!yyvaluep)
+ return;
+# ifdef YYPRINT
+ if (yykind < YYNTOKENS)
+ YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
+# endif
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ YY_USE (yykind);
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+/*---------------------------.
+| Print this symbol on YYO. |
+`---------------------------*/
+
+static void
+yy_symbol_print (FILE *yyo,
+ yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
+{
+ YYFPRINTF (yyo, "%s %s (",
+ yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
+
+ yy_symbol_value_print (yyo, yykind, yyvaluep);
+ YYFPRINTF (yyo, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included). |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
+{
+ YYFPRINTF (stderr, "Stack now");
+ for (; yybottom <= yytop; yybottom++)
+ {
+ int yybot = *yybottom;
+ YYFPRINTF (stderr, " %d", yybot);
+ }
+ YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top) \
+do { \
+ if (yydebug) \
+ yy_stack_print ((Bottom), (Top)); \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced. |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
+ int yyrule)
+{
+ int yylno = yyrline[yyrule];
+ int yynrhs = yyr2[yyrule];
+ int yyi;
+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
+ yyrule - 1, yylno);
+ /* The symbols being reduced. */
+ for (yyi = 0; yyi < yynrhs; yyi++)
+ {
+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
+ yy_symbol_print (stderr,
+ YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
+ &yyvsp[(yyi + 1) - (yynrhs)]);
+ YYFPRINTF (stderr, "\n");
+ }
+}
+
+# define YY_REDUCE_PRINT(Rule) \
+do { \
+ if (yydebug) \
+ yy_reduce_print (yyssp, yyvsp, Rule); \
+} while (0)
+
+/* Nonzero means print parse trace. It is left uninitialized so that
+ multiple parsers can coexist. */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args) ((void) 0)
+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks. */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+ if the built-in stack extension method is used).
+
+ Do not make this value too large; the results are undefined if
+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+
+
+
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol. |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg,
+ yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
+{
+ YY_USE (yyvaluep);
+ if (!yymsg)
+ yymsg = "Deleting";
+ YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ YY_USE (yykind);
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+/* Lookahead token kind. */
+int yychar;
+
+/* The semantic value of the lookahead symbol. */
+YYSTYPE yylval;
+/* Number of syntax errors so far. */
+int yynerrs;
+
+
+
+
+/*----------.
+| yyparse. |
+`----------*/
+
+int
+yyparse (void)
+{
+ yy_state_fast_t yystate = 0;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus = 0;
+
+ /* Refer to the stacks through separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* Their size. */
+ YYPTRDIFF_T yystacksize = YYINITDEPTH;
+
+ /* The state stack: array, bottom, top. */
+ yy_state_t yyssa[YYINITDEPTH];
+ yy_state_t *yyss = yyssa;
+ yy_state_t *yyssp = yyss;
+
+ /* The semantic value stack: array, bottom, top. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs = yyvsa;
+ YYSTYPE *yyvsp = yyvs;
+
+ int yyn;
+ /* The return value of yyparse. */
+ int yyresult;
+ /* Lookahead symbol kind. */
+ yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+
+
+
+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
+
+ /* The number of symbols on the RHS of the reduced rule.
+ Keep to zero when no symbol should be popped. */
+ int yylen = 0;
+
+ YYDPRINTF ((stderr, "Starting parse\n"));
+
+ yychar = YYEMPTY; /* Cause a token to be read. */
+ goto yysetstate;
+
+
+/*------------------------------------------------------------.
+| yynewstate -- push a new state, which is found in yystate. |
+`------------------------------------------------------------*/
+yynewstate:
+ /* In all cases, when you get here, the value and location stacks
+ have just been pushed. So pushing a state here evens the stacks. */
+ yyssp++;
+
+
+/*--------------------------------------------------------------------.
+| yysetstate -- set current state (the top of the stack) to yystate. |
+`--------------------------------------------------------------------*/
+yysetstate:
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+ YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
+ YY_IGNORE_USELESS_CAST_BEGIN
+ *yyssp = YY_CAST (yy_state_t, yystate);
+ YY_IGNORE_USELESS_CAST_END
+ YY_STACK_PRINT (yyss, yyssp);
+
+ if (yyss + yystacksize - 1 <= yyssp)
+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
+ goto yyexhaustedlab;
+#else
+ {
+ /* Get the current used size of the three stacks, in elements. */
+ YYPTRDIFF_T yysize = yyssp - yyss + 1;
+
+# if defined yyoverflow
+ {
+ /* Give user a chance to reallocate the stack. Use copies of
+ these so that the &'s don't force the real ones into
+ memory. */
+ yy_state_t *yyss1 = yyss;
+ YYSTYPE *yyvs1 = yyvs;
+
+ /* Each stack pointer address is followed by the size of the
+ data in use in that stack, in bytes. This used to be a
+ conditional around just the two extra args, but that might
+ be undefined if yyoverflow is a macro. */
+ yyoverflow (YY_("memory exhausted"),
+ &yyss1, yysize * YYSIZEOF (*yyssp),
+ &yyvs1, yysize * YYSIZEOF (*yyvsp),
+ &yystacksize);
+ yyss = yyss1;
+ yyvs = yyvs1;
+ }
+# else /* defined YYSTACK_RELOCATE */
+ /* Extend the stack our own way. */
+ if (YYMAXDEPTH <= yystacksize)
+ goto yyexhaustedlab;
+ yystacksize *= 2;
+ if (YYMAXDEPTH < yystacksize)
+ yystacksize = YYMAXDEPTH;
+
+ {
+ yy_state_t *yyss1 = yyss;
+ union yyalloc *yyptr =
+ YY_CAST (union yyalloc *,
+ YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
+ if (! yyptr)
+ goto yyexhaustedlab;
+ YYSTACK_RELOCATE (yyss_alloc, yyss);
+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+# undef YYSTACK_RELOCATE
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
+ }
+# endif
+
+ yyssp = yyss + yysize - 1;
+ yyvsp = yyvs + yysize - 1;
+
+ YY_IGNORE_USELESS_CAST_BEGIN
+ YYDPRINTF ((stderr, "Stack size increased to %ld\n",
+ YY_CAST (long, yystacksize)));
+ YY_IGNORE_USELESS_CAST_END
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ YYABORT;
+ }
+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
+
+ if (yystate == YYFINAL)
+ YYACCEPT;
+
+ goto yybackup;
+
+
+/*-----------.
+| yybackup. |
+`-----------*/
+yybackup:
+ /* Do appropriate processing given the current state. Read a
+ lookahead token if we need one and don't already have one. */
+
+ /* First try to decide what to do without reference to lookahead token. */
+ yyn = yypact[yystate];
+ if (yypact_value_is_default (yyn))
+ goto yydefault;
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
+ if (yychar == YYEMPTY)
+ {
+ YYDPRINTF ((stderr, "Reading a token\n"));
+ yychar = yylex ();
+ }
+
+ if (yychar <= YYEOF)
+ {
+ yychar = YYEOF;
+ yytoken = YYSYMBOL_YYEOF;
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else if (yychar == YYerror)
+ {
+ /* The scanner already issued an error message, process directly
+ to error recovery. But do not keep the error token as
+ lookahead, it is too special and may lead us to an endless
+ loop in error recovery. */
+ yychar = YYUNDEF;
+ yytoken = YYSYMBOL_YYerror;
+ goto yyerrlab1;
+ }
+ else
+ {
+ yytoken = YYTRANSLATE (yychar);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+ }
+
+ /* If the proper action on seeing token YYTOKEN is to reduce or to
+ detect an error, take that action. */
+ yyn += yytoken;
+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+ goto yydefault;
+ yyn = yytable[yyn];
+ if (yyn <= 0)
+ {
+ if (yytable_value_is_error (yyn))
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
+
+ /* Shift the lookahead token. */
+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+ yystate = yyn;
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+ /* Discard the shifted token. */
+ yychar = YYEMPTY;
+ goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
+yydefault:
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+ goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- do a reduction. |
+`-----------------------------*/
+yyreduce:
+ /* yyn is the number of a rule to reduce with. */
+ yylen = yyr2[yyn];
+
+ /* If YYLEN is nonzero, implement the default value of the action:
+ '$$ = $1'.
+
+ Otherwise, the following line sets YYVAL to garbage.
+ This behavior is undocumented and Bison
+ users should not rely upon it. Assigning to YYVAL
+ unconditionally makes the parser a bit smaller, and it avoids a
+ GCC warning that YYVAL may be used uninitialized. */
+ yyval = yyvsp[1-yylen];
+
+
+ YY_REDUCE_PRINT (yyn);
+ switch (yyn)
+ {
+ case 6: /* grammar: grammar error */
+#line 97 "parse.y"
+ { file->errors++; }
+#line 1256 "y.tab.c"
+ break;
+
+ case 7: /* include: INCLUDE STRING */
+#line 100 "parse.y"
+ {
+ struct file *nfile;
+
+ if ((nfile = pushfile((yyvsp[0].v.string), 0)) == NULL) {
+ yyerror("failed to include file %s", (yyvsp[0].v.string));
+ free((yyvsp[0].v.string));
+ YYERROR;
+ }
+ free((yyvsp[0].v.string));
+
+ file = nfile;
+ lungetc('\n');
+ }
+#line 1274 "y.tab.c"
+ break;
+
+ case 8: /* verbatim: '!' verbatim1 '!' */
+#line 115 "parse.y"
+ {
+ if (in_define) {
+ /* TODO: check template status and exit in case */
+ }
+ }
+#line 1284 "y.tab.c"
+ break;
+
+ case 10: /* verbatim1: verbatim1 STRING */
+#line 123 "parse.y"
+ {
+ if (*(yyvsp[0].v.string) != '\0') {
+ dbg();
+ puts((yyvsp[0].v.string));
+ }
+ free((yyvsp[0].v.string));
+ }
+#line 1296 "y.tab.c"
+ break;
+
+ case 13: /* raw: STRING */
+#line 136 "parse.y"
+ {
+ dbg();
+ printf("if (tp->tp_puts(tp, ");
+ printq((yyvsp[0].v.string));
+ printf(") == -1) goto %s;\n", lerr);
+
+ free((yyvsp[0].v.string));
+ }
+#line 1309 "y.tab.c"
+ break;
+
+ case 14: /* block: define body end */
+#line 146 "parse.y"
+ {
+ printf("%s:\n", lerr);
+ puts("return tp->tp_ret;");
+ puts("}");
+ in_define = 0;
+ }
+#line 1320 "y.tab.c"
+ break;
+
+ case 15: /* block: define body finally end */
+#line 152 "parse.y"
+ {
+ puts("return tp->tp_ret;");
+ puts("}");
+ in_define = 0;
+ }
+#line 1330 "y.tab.c"
+ break;
+
+ case 16: /* define: '{' DEFINE string '}' */
+#line 159 "parse.y"
+ {
+ in_define = 1;
+ (void)snprintf(lerr, sizeof(lerr), "err%llu",
+ (unsigned long long)arc4random());
+
+ dbg();
+ printf("int\n%s\n{\n", (yyvsp[-1].v.string));
+
+ free((yyvsp[-1].v.string));
+ }
+#line 1345 "y.tab.c"
+ break;
+
+ case 21: /* special: '{' RENDER string '}' */
+#line 177 "parse.y"
+ {
+ dbg();
+ if (strrchr((yyvsp[-1].v.string), ')') != NULL)
+ printf("if (%s == -1) goto %s;\n",
+ (yyvsp[-1].v.string), lerr);
+ else
+ printf("if (%s != NULL && %s(tp) == -1) "
+ "goto %s;\n", (yyvsp[-1].v.string), (yyvsp[-1].v.string), lerr);
+ free((yyvsp[-1].v.string));
+ }
+#line 1360 "y.tab.c"
+ break;
+
+ case 22: /* special: if body endif */
+#line 187 "parse.y"
+ { puts("}"); }
+#line 1366 "y.tab.c"
+ break;
+
+ case 24: /* special: '{' string '}' */
+#line 189 "parse.y"
+ {
+ dbg();
+ printf("if (tp->tp_escape(tp, %s) == -1) goto %s;\n",
+ (yyvsp[-1].v.string), lerr);
+ }
+#line 1376 "y.tab.c"
+ break;
+
+ case 25: /* if: '{' IF string '}' */
+#line 196 "parse.y"
+ {
+ dbg();
+ printf("if (%s) {\n", (yyvsp[-1].v.string));
+ free((yyvsp[-1].v.string));
+ }
+#line 1386 "y.tab.c"
+ break;
+
+ case 29: /* elsif: '{' ELSE IF string '}' */
+#line 208 "parse.y"
+ {
+ dbg();
+ printf("} else if (%s) {\n", (yyvsp[-1].v.string));
+ free((yyvsp[-1].v.string));
+ }
+#line 1396 "y.tab.c"
+ break;
+
+ case 30: /* else: '{' ELSE '}' */
+#line 215 "parse.y"
+ {
+ dbg();
+ puts("} else {");
+ }
+#line 1405 "y.tab.c"
+ break;
+
+ case 31: /* $@1: %empty */
+#line 221 "parse.y"
+ {
+ printf("TAILQ_FOREACH(%s, %s, %s) {\n",
+ (yyvsp[-3].v.string), (yyvsp[-2].v.string), (yyvsp[-1].v.string));
+ free((yyvsp[-3].v.string));
+ free((yyvsp[-2].v.string));
+ free((yyvsp[-1].v.string));
+ }
+#line 1417 "y.tab.c"
+ break;
+
+ case 32: /* loop: '{' TQFOREACH STRING STRING STRING '}' $@1 body end */
+#line 227 "parse.y"
+ {
+ puts("}");
+ }
+#line 1425 "y.tab.c"
+ break;
+
+ case 34: /* $@2: %empty */
+#line 235 "parse.y"
+ {
+ dbg();
+ printf("%s:\n", lerr);
+ }
+#line 1434 "y.tab.c"
+ break;
+
+ case 36: /* string: STRING string */
+#line 241 "parse.y"
+ {
+ if (asprintf(&(yyval.v.string), "%s %s", (yyvsp[-1].v.string), (yyvsp[0].v.string)) == -1)
+ err(1, "asprintf");
+ free((yyvsp[-1].v.string));
+ free((yyvsp[0].v.string));
+ }
+#line 1445 "y.tab.c"
+ break;
+
+
+#line 1449 "y.tab.c"
+
+ default: break;
+ }
+ /* User semantic actions sometimes alter yychar, and that requires
+ that yytoken be updated with the new translation. We take the
+ approach of translating immediately before every use of yytoken.
+ One alternative is translating here after every semantic action,
+ but that translation would be missed if the semantic action invokes
+ YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+ if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
+ incorrect destructor might then be invoked immediately. In the
+ case of YYERROR or YYBACKUP, subsequent parser actions might lead
+ to an incorrect destructor call or verbose syntax error message
+ before the lookahead is translated. */
+ YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
+
+ YYPOPSTACK (yylen);
+ yylen = 0;
+
+ *++yyvsp = yyval;
+
+ /* Now 'shift' the result of the reduction. Determine what state
+ that goes to, based on the state we popped back to and the rule
+ number reduced by. */
+ {
+ const int yylhs = yyr1[yyn] - YYNTOKENS;
+ const int yyi = yypgoto[yylhs] + *yyssp;
+ yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+ ? yytable[yyi]
+ : yydefgoto[yylhs]);
+ }
+
+ goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error. |
+`--------------------------------------*/
+yyerrlab:
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
+ /* If not already recovering from an error, report this error. */
+ if (!yyerrstatus)
+ {
+ ++yynerrs;
+ yyerror (YY_("syntax error"));
+ }
+
+ if (yyerrstatus == 3)
+ {
+ /* If just tried and failed to reuse lookahead token after an
+ error, discard it. */
+
+ if (yychar <= YYEOF)
+ {
+ /* Return failure if at end of input. */
+ if (yychar == YYEOF)
+ YYABORT;
+ }
+ else
+ {
+ yydestruct ("Error: discarding",
+ yytoken, &yylval);
+ yychar = YYEMPTY;
+ }
+ }
+
+ /* Else will try to reuse lookahead token after shifting the error
+ token. */
+ goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR. |
+`---------------------------------------------------*/
+yyerrorlab:
+ /* Pacify compilers when the user code never invokes YYERROR and the
+ label yyerrorlab therefore never appears in user code. */
+ if (0)
+ YYERROR;
+
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYERROR. */
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+ yystate = *yyssp;
+ goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR. |
+`-------------------------------------------------------------*/
+yyerrlab1:
+ yyerrstatus = 3; /* Each real token shifted decrements this. */
+
+ /* Pop stack until we find a state that shifts the error token. */
+ for (;;)
+ {
+ yyn = yypact[yystate];
+ if (!yypact_value_is_default (yyn))
+ {
+ yyn += YYSYMBOL_YYerror;
+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
+ {
+ yyn = yytable[yyn];
+ if (0 < yyn)
+ break;
+ }
+ }
+
+ /* Pop the current state because it cannot handle the error token. */
+ if (yyssp == yyss)
+ YYABORT;
+
+
+ yydestruct ("Error: popping",
+ YY_ACCESSING_SYMBOL (yystate), yyvsp);
+ YYPOPSTACK (1);
+ yystate = *yyssp;
+ YY_STACK_PRINT (yyss, yyssp);
+ }
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+ /* Shift the error token. */
+ YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
+
+ yystate = yyn;
+ goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here. |
+`-------------------------------------*/
+yyacceptlab:
+ yyresult = 0;
+ goto yyreturn;
+
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here. |
+`-----------------------------------*/
+yyabortlab:
+ yyresult = 1;
+ goto yyreturn;
+
+
+#if !defined yyoverflow
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here. |
+`-------------------------------------------------*/
+yyexhaustedlab:
+ yyerror (YY_("memory exhausted"));
+ yyresult = 2;
+ goto yyreturn;
+#endif
+
+
+/*-------------------------------------------------------.
+| yyreturn -- parsing is finished, clean up and return. |
+`-------------------------------------------------------*/
+yyreturn:
+ if (yychar != YYEMPTY)
+ {
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = YYTRANSLATE (yychar);
+ yydestruct ("Cleanup: discarding lookahead",
+ yytoken, &yylval);
+ }
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYABORT or YYACCEPT. */
+ YYPOPSTACK (yylen);
+ YY_STACK_PRINT (yyss, yyssp);
+ while (yyssp != yyss)
+ {
+ yydestruct ("Cleanup: popping",
+ YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
+ YYPOPSTACK (1);
+ }
+#ifndef yyoverflow
+ if (yyss != yyssa)
+ YYSTACK_FREE (yyss);
+#endif
+
+ return yyresult;
+}
+
+#line 250 "parse.y"
+
+
+struct keywords {
+ const char *k_name;
+ int k_val;
+};
+
+int
+yyerror(const char *fmt, ...)
+{
+ va_list ap;
+ char *msg;
+
+ file->errors++;
+ va_start(ap, fmt);
+ if (vasprintf(&msg, fmt, ap) == -1)
+ err(1, "yyerror vasprintf");
+ va_end(ap);
+ fprintf(stderr, "%s:%d: %s\n", file->name, yylval.lineno, msg);
+ free(msg);
+ return (0);
+}
+
+int
+kw_cmp(const void *k, const void *e)
+{
+ return (strcmp(k, ((const struct keywords *)e)->k_name));
+}
+
+int
+lookup(char *s)
+{
+ /* this has to be sorted always */
+ static const struct keywords keywords[] = {
+ { "define", DEFINE },
+ { "else", ELSE },
+ { "end", END },
+ { "finally", FINALLY },
+ { "if", IF },
+ { "include", INCLUDE },
+ { "render", RENDER },
+ { "tailq-foreach", TQFOREACH },
+ };
+ const struct keywords *p;
+
+ p = bsearch(s, keywords, nitems(keywords), sizeof(keywords[0]),
+ kw_cmp);
+
+ if (p)
+ return (p->k_val);
+ else
+ return (STRING);
+}
+
+#define START_EXPAND 1
+#define DONE_EXPAND 2
+
+static int expanding;
+
+int
+igetc(void)
+{
+ int c;
+
+ while (1) {
+ if (file->ungetpos > 0)
+ c = file->ungetbuf[--file->ungetpos];
+ else
+ c = getc(file->stream);
+
+ if (c == START_EXPAND)
+ expanding = 1;
+ else if (c == DONE_EXPAND)
+ expanding = 0;
+ else
+ break;
+ }
+ return (c);
+}
+
+int
+lgetc(int quotec)
+{
+ int c, next;
+
+ if (quotec) {
+ if ((c = igetc()) == EOF) {
+ yyerror("reached end of filewhile parsing "
+ "quoted string");
+ if (file == topfile || popfile() == EOF)
+ return (EOF);
+ return (quotec);
+ }
+ return (c);
+ }
+
+ while ((c = igetc()) == '\\') {
+ next = igetc();
+ if (next != '\n') {
+ c = next;
+ break;
+ }
+ yylval.lineno = file->lineno;
+ file->lineno++;
+ }
+ if (c == '\t' || c == ' ') {
+ /* Compress blanks to a sigle space. */
+ do {
+ c = getc(file->stream);
+ } while (c == '\t' || c == ' ');
+ ungetc(c, file->stream);
+ c = ' ';
+ }
+
+ if (c == EOF) {
+ /*
+ * Fake EOL when hit EOF for the first time. This gets line
+ * count rigchtif last line included file is syntactically
+ * invalid and has no newline.
+ */
+ if (file->eof_reached == 0) {
+ file->eof_reached = 1;
+ return ('\n');
+ }
+ while (c == EOF) {
+ if (file == topfile || popfile() == EOF)
+ return (EOF);
+ c = igetc();
+ }
+ }
+ return (c);
+}
+
+void
+lungetc(int c)
+{
+ if (c == EOF)
+ return;
+
+ if (file->ungetpos >= file->ungetsize) {
+ void *p = reallocarray(file->ungetbuf, file->ungetsize, 2);
+ if (p == NULL)
+ err(1, "reallocarray");
+ file->ungetbuf = p;
+ file->ungetsize *= 2;
+ }
+ file->ungetbuf[file->ungetpos++] = c;
+}
+
+int
+findeol(void)
+{
+ int c;
+
+ /* skip to either EOF or the first real EOL */
+ while (1) {
+ c = lgetc(0);
+ if (c == '\n') {
+ file->lineno++;
+ break;
+ }
+ if (c == EOF)
+ break;
+ }
+ return (ERROR);
+}
+
+int
+yylex(void)
+{
+ char buf[8096];
+ char *p = buf;
+ int c;
+ int token;
+ int starting = 0;
+ int ending = 0;
+
+ if (!in_define && block == 0) {
+ while ((c = lgetc(0)) != '{' && c != EOF) {
+ if (c == '\n')
+ file->lineno++;
+ }
+
+ if (c == EOF)
+ return (0);
+
+newblock:
+ c = lgetc(0);
+ if (c == '{' || c == '!') {
+ if (c == '{')
+ block = '}';
+ else
+ block = c;
+ return (c);
+ }
+ if (c == '\n')
+ file->lineno++;
+ }
+
+ while ((c = lgetc(0)) == ' ' || c == '\t' || c == '\n') {
+ if (c == '\n')
+ file->lineno++;
+ }
+
+ if (c == EOF) {
+ yyerror("unterminated block");
+ return (0);
+ }
+
+ yylval.lineno = file->lineno;
+
+ if (block != 0 && c == block) {
+ if ((c = lgetc(0)) == '}') {
+ if (block == '!') {
+ block = 0;
+ return ('!');
+ }
+ block = 0;
+ return ('}');
+ }
+ lungetc(c);
+ c = block;
+ }
+
+ if (in_define && block == 0) {
+ if (c == '{')
+ goto newblock;
+
+ do {
+ if (starting) {
+ if (c == '!' || c == '{') {
+ lungetc('{');
+ lungetc(c);
+ break;
+ }
+ starting = 0;
+ lungetc(c);
+ c = '{';
+ } else if (c == '{') {
+ starting = 1;
+ continue;
+ }
+
+ *p++ = c;
+ if ((size_t)(p - buf) >= sizeof(buf)) {
+ yyerror("string too long");
+ return (findeol());
+ }
+ } while ((c = lgetc(0)) != EOF && c != '\n');
+ *p = '\0';
+ if (c == EOF) {
+ yyerror("unterminated block");
+ return (0);
+ }
+ if (c == '\n')
+ file->lineno++;
+ if ((yylval.v.string = strdup(buf)) == NULL)
+ err(1, "strdup");
+ return (STRING);
+ }
+
+ if (block == '!') {
+ do {
+ if (ending) {
+ if (c == '}') {
+ lungetc(c);
+ lungetc(block);
+ break;
+ }
+ ending = 0;
+ lungetc(c);
+ c = block;
+ } else if (c == '!') {
+ ending = 1;
+ continue;
+ }
+
+ *p++ = c;
+ if ((size_t)(p - buf) >= sizeof(buf)) {
+ yyerror("line too long");
+ return (findeol());
+ }
+ } while ((c = lgetc(0)) != EOF && c != '\n');
+ *p = '\0';
+
+ if (c == EOF) {
+ yyerror("unterminated block");
+ return (0);
+ }
+ if (c == '\n')
+ file->lineno++;
+
+ if ((yylval.v.string = strdup(buf)) == NULL)
+ err(1, "strdup");
+ return (STRING);
+ }
+
+ do {
+ if (ending) {
+ if (c == '}') {
+ lungetc(c);
+ lungetc('}');
+ break;
+ }
+ ending = 0;
+ lungetc(c);
+ c = block;
+ } else if (c == '}') {
+ ending = 1;
+ continue;
+ }
+
+ *p++ = c;
+ if ((size_t)(p - buf) >= sizeof(buf)) {
+ yyerror("string too long");
+ return (findeol());
+ }
+ } while ((c = lgetc(0)) != EOF && !isspace((unsigned char)c));
+ *p = '\0';
+
+ if (c == EOF) {
+ yyerror("unterminated block");
+ return (0);
+ }
+ if (c == '\n')
+ file->lineno++;
+ if ((token = lookup(buf)) == STRING)
+ if ((yylval.v.string = strdup(buf)) == NULL)
+ err(1, "strdup");
+ return (token);
+}
+
+struct file *
+pushfile(const char *name, int secret)
+{
+ struct file *nfile;
+
+ if ((nfile = calloc(1, sizeof(*nfile))) == NULL)
+ err(1, "calloc");
+ if ((nfile->name = strdup(name)) == NULL)
+ err(1, "strdup");
+ if ((nfile->stream = fopen(nfile->name, "r")) == NULL) {
+ warn("can't open %s", nfile->name);
+ free(nfile->name);
+ free(nfile);
+ return (NULL);
+ }
+ nfile->lineno = TAILQ_EMPTY(&files) ? 1 : 0;
+ nfile->ungetsize = 16;
+ nfile->ungetbuf = malloc(nfile->ungetsize);
+ if (nfile->ungetbuf == NULL)
+ err(1, "malloc");
+ TAILQ_INSERT_TAIL(&files, nfile, entry);
+ return (nfile);
+}
+
+int
+popfile(void)
+{
+ struct file *prev;
+
+ if ((prev = TAILQ_PREV(file, files, entry)) != NULL)
+ prev->errors += file->errors;
+
+ TAILQ_REMOVE(&files, file, entry);
+ fclose(file->stream);
+ free(file->name);
+ free(file->ungetbuf);
+ free(file);
+ file = prev;
+ return (file ? 0 : EOF);
+}
+
+int
+parse(const char *filename)
+{
+ if ((file = pushfile(filename, 0)) == 0)
+ return (-1);
+ topfile = file;
+
+ yyparse();
+ errors = file->errors;
+ popfile();
+
+ return (errors ? -1 : 0);
+}
+
+void
+dbg(void)
+{
+ if (nodebug)
+ return;
+
+ printf("#line %d ", yylval.lineno);
+ printq(file->name);
+ putchar('\n');
+}
+
+void
+printq(const char *str)
+{
+ putchar('"');
+ for (; *str; ++str) {
+ if (*str == '"')
+ putchar('\\');
+ putchar(*str);
+ }
+ putchar('"');
+}
