slweb

slweb.c (133252B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2020-2026  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 
 #include <assert.h>
 #include <ctype.h>
 #include <dirent.h>
 #include <errno.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include "utf8.h"
 #include "defs.h"
 #include "version.h"
 
 static KeyValue* footnotes	      = NULL;
 static KeyValue* links		      = NULL;
 static KeyValue* pfootnotes	      = NULL;
 static KeyValue* plinks		      = NULL;
 static KeyValue* macros		      = NULL;
 static KeyValue* pmacros	      = NULL;
 static KeyValue* pvars		      = NULL;
 static KeyValue* vars		      = NULL;
 static u8** inline_footnotes	      = NULL;
 static u8* csv_template		      = NULL;
 static u8* tsv_template		      = NULL;
 static char* basedir		      = NULL;
 static char* csv_filename	      = NULL;
 static char* global_link_prefix	      = NULL;
 static char* incdir		      = NULL;
 static char* input_dirname	      = NULL;
 static char* input_filename	      = NULL;
 static char* tsv_filename	      = NULL;
 static unsigned long long state	      = ST_NONE;
 static size_t basedir_size	      = 0;
 static size_t colno		      = 1;
 static size_t csv_iter		      = 0;
 static size_t csv_template_len	      = 0;
 static size_t csv_template_size	      = 0;
 static size_t current_footnote	      = 0;
 static size_t current_inline_footnote = 0;
 static size_t footnote_count	      = 0;
 static size_t global_link_prefix_size = 0;
 static size_t ifn_size		      = 0;
 static size_t inline_footnote_count   = 0;
 static size_t lineno		      = 0;
 static size_t links_count	      = 0;
 static size_t macros_count	      = 0;
 static size_t tsv_iter		      = 0;
 static size_t tsv_template_len	      = 0;
 static size_t tsv_template_size	      = 0;
 static size_t vars_count	      = 0;
 static int incdir_only_summary	      = 0;
 static int output_firstcol	      = 1;
 
 static void add_css(FILE* output, int output_yaml);
 static int error(const int code, const char* file, const char* func,
 	const int line, const char* fmt, ...);
 static u8* format_date(const u8* date_arg, const char* timestamp_format);
 static void free_keyvalue(KeyValue** list, const size_t list_count);
 static u8* get_value(KeyValue* list, const size_t list_count, const u8* key,
 	KeyValue** cursor);
 static void print_meta_var(FILE* output, u8** tsv_header, u8** tsv_register);
 static int print_output(FILE* output, const char* fmt, ...);
 static void process_horizontal_rule(FILE* output);
 static void process_incdir_subdir(FILE* output, const char* subdirname,
 	const u8* link_prefix, const int details_open, const u8* macro_body,
 	const u8* footer_permalink_text, const char* permalink_url,
 	const int ext_in_permalink, const int list_only);
 static void process_inline_image(FILE* output, const u8* image_text,
 	const u8* image_file_prefix, const u8* link_prefix, const u8* image_url,
 	const int add_link, const int add_figcaption);
 static void process_inline_stylesheet(FILE* output, const u8* css_filename,
 	int output_yaml);
 static void process_list_end(FILE* output);
 static void process_list_item_end(FILE* output);
 static void process_numlist_end(FILE* output);
 static void process_stylesheet(FILE* output, const u8* css_filename,
 	int output_yaml);
 static void process_timestamp(FILE* output, const u8* link_prefix,
 	const char* link, const u8* permalink_macro, const u8* date,
 	const int ext_in_permalink);
 static void process_tsv(FILE* output, const u8* arg_token,
 	const int read_yaml_macros_and_links, const int end_tag);
 static void process_tsv_count(FILE* output, const u8* arg_token,
 	const int read_yaml_macros_and_links, const int is_tsv);
 static void read_csv(FILE* output, const char* filename,
 	csv_callback_t callback);
 static int read_file_into_buffer(FILE** input, u8** buffer, size_t* buffer_size,
 	const char* input_filename, char** input_dirname);
 static int read_tsv(FILE* output, const char* filename, tsv_callback_t callback);
 static int reverse_alphacompare(const struct dirent** a,
 	const struct dirent** b);
 static int set_basedir(char** basedir, size_t* basedir_size, const char* arg);
 static int simple_parse_yaml_line(const u8* line, KeyValue** vars,
 	size_t* vars_count, KeyValue** pvars);
 static int slweb_parse(FILE* output, const char* source_filename,
 	const size_t sfn_size, const u8* buffer, const int body_only,
 	const int read_yaml_macros_and_links);
 static int startswith(const char* s, const char* what);
 static char* strip_ext(const char* fn, const size_t fn_size);
 static int url_is_local(const char* url);
 static int warning(const int code, const u8* fmt, ...);
 
 static void
 add_css(FILE* output, int output_yaml)
 {
 	KeyValue* pvars = vars;
 	if (!vars)
 		return;
 	while (pvars < vars + vars_count)
 	{
 		assert(pvars->key != NULL);
 		if (!strcmp((char*)pvars->key, "stylesheet"))
 			process_stylesheet(output, pvars->value, output_yaml);
 		else if (!strcmp((char*)pvars->key, "inline-stylesheet"))
 			process_inline_stylesheet(output, pvars->value,
 				output_yaml);
 		pvars++;
 	}
 }
 
 static int
 all_numeric(const u8* start, const u8* end)
 {
 	const u8* ps = start;
 	assert((start != NULL) && (end != NULL));
 	while (ps != end)
 	{
 		if (*ps && !isdigit((const int)*ps))
 			return 0;
 		ps++;
 	}
 	return 1;
 }
 
 static int
 begin_article(FILE* output, const char* source_filename, const size_t sfn_size,
 	const u8* link_prefix, const int add_article_header, const u8* author,
 	const u8* title, const u8* header_text, const char* title_heading_level,
 	u8* date, const int ext_in_permalink, const char* permalink_url)
 {
 	char* temp	= NULL;
 	int save_incdir = IN(state, ST_INCDIR);
 
 	UNUSED(add_article_header);
 	CLEAR(state, ST_INCDIR);
 
 	if (author || date || header_text || title)
 		print_output(output, "<header>\n");
 
 	if (title)
 		print_output(output, "<h%s>%s</h%s>\n",
 			title_heading_level ? title_heading_level : "2",
 			(char*)title,
 			title_heading_level ? title_heading_level : "2");
 
 	if (header_text)
 		print_output(output, "<p>%s\n", (char*)header_text);
 
 	if (author)
 		print_output(output, "<address>%s</address>\n", author);
 
 	if (date && source_filename)
 	{
 		u8* permalink_macro = NULL;
 		char* link	    = NULL;
 		size_t link_len;
 
 		permalink_macro = get_value(macros, macros_count,
 			(u8*)"permalink", NULL);
 		link = strip_ext((const char*)source_filename, BUFSIZE);
 		assert(sfn_size != 0);
 		link_len = strlen(link);
 		if (ext_in_permalink)
 			MEMCCPY((link + link_len), timestamp_output_ext,
 				sfn_size - link_len, temp);
 		if (permalink_url)
 			process_timestamp(output, link_prefix, permalink_url,
 				permalink_macro, date, ext_in_permalink);
 		else
 			process_timestamp(output, link_prefix, link,
 				permalink_macro, date, ext_in_permalink);
 		free(link);
 	}
 
 	if (author || date || header_text || title)
 		print_output(output, "</header>\n");
 
 	output_firstcol = author || date || header_text || title;
 
 	if (save_incdir)
 		SET(state, ST_INCDIR);
 
 	return 0;
 }
 
 static int
 begin_html_and_head(FILE* output)
 {
 	KeyValue* cursor      = NULL;
 	KeyValue* cursor_type = NULL;
 	KeyValue* cursor_desc = NULL;
 	u8* lang	      = get_value(vars, vars_count, (u8*)"lang", NULL);
 	u8* site_name	= get_value(vars, vars_count, (u8*)"site-name", NULL);
 	u8* site_desc	= get_value(vars, vars_count, (u8*)"site-desc", NULL);
 	u8* canonical	= get_value(vars, vars_count, (u8*)"canonical", NULL);
 	u8* favicon_url = get_value(vars, vars_count, (u8*)"favicon-url", NULL);
 	u8* meta	= get_value(vars, vars_count, (u8*)"meta", NULL);
 	u8* feed	= NULL;
 	u8* feed_type	= NULL;
 	u8* feed_desc	= NULL;
 	char* favicon	= NULL;
 	char* filename	= NULL;
 
 	print_output(output,
 		"<!DOCTYPE html>\n"
 		"<html lang=\"%s\">\n"
 		"<head>\n"
 		"<title>%s</title>\n"
 		"<meta charset=\"utf-8\">\n",
 		lang ? (char*)lang : "en", site_name ? (char*)site_name : "");
 
 	CALLOC(favicon, char, BUFSIZE);
 	snprintf(favicon, BUFSIZE - 1, "%s/favicon.ico", basedir);
 	if (!access(favicon, R_OK))
 		print_output(output,
 			"<link rel=\"shortcut icon\" type=\"image/x-icon\""
 			" href=\"%s\">\n",
 			favicon_url ? (char*)favicon_url : "/favicon.ico");
 	free(favicon);
 
 	if (meta)
 	{
 		CALLOC(filename, char, BUFSIZE);
 		snprintf(filename, BUFSIZE, "%s/%s", input_dirname, (char*)meta);
 		read_tsv(output, filename, &print_meta_var);
 		free(filename);
 	}
 
 	if (canonical && *canonical)
 		print_output(output, "<link rel=\"canonical\" href=\"%s\">\n",
 			(char*)canonical);
 
 	cursor	    = vars;
 	cursor_type = vars;
 	cursor_desc = vars;
 	do
 	{
 		feed	  = get_value(cursor, vars_count - (cursor - vars),
 			     (u8*)"feed", &cursor);
 		feed_type = get_value(cursor_type,
 			vars_count - (cursor_type - vars), (u8*)"feed-type",
 			&cursor_type);
 		feed_desc = get_value(cursor_desc,
 			vars_count - (cursor_desc - vars), (u8*)"feed-desc",
 			&cursor_desc);
 		if (feed && *feed && feed_type && *feed_type && feed_desc
 			&& *feed_desc)
 			print_output(output,
 				"<link rel=\"alternate\""
 				" type=\"%s\" href=\"%s\" "
 				"title=\"%s\">\n",
 				(char*)feed_type, (char*)feed,
 				(char*)feed_desc);
 	} while (feed && feed_type && feed_desc);
 
 	if (site_desc && *site_desc)
 		print_output(output,
 			"<meta name=\"description\" content=\"%s\">\n",
 			(char*)site_desc);
 
 	print_output(output,
 		"<meta name=\"viewport\" content=\"width=device-width,"
 		" initial-scale=1\">\n<meta name=\"generator\" "
 		"content=\"slweb\">\n");
 
 	output_firstcol = 1;
 	return 0;
 }
 
 static int
 cleanup(void)
 {
 	free(basedir);
 	free(input_dirname);
 	while (inline_footnote_count--)
 		free(inline_footnotes[inline_footnote_count]);
 	free(inline_footnotes);
 	free_keyvalue(&footnotes, footnote_count);
 	free_keyvalue(&links, links_count);
 	free_keyvalue(&macros, macros_count);
 	free_keyvalue(&vars, vars_count);
 	free(footnotes);
 	free(links);
 	free(macros);
 	free(vars);
 	return 0;
 }
 
 static int
 end_body_and_html(FILE* output)
 {
 	print_output(output, "</body>\n</html>\n");
 	output_firstcol = 1;
 	return 0;
 }
 
 static int
 end_footnotes(FILE* output, int add_footnote_div)
 {
 	KeyValue* pfootnote;
 	size_t footnote = 0;
 
 	CLEAR(state, ST_PARA_OPEN);
 
 	if (add_footnote_div)
 	{
 		print_output(output, "<div class=\"footnotes\">\n");
 		output_firstcol = 1;
 	}
 
 	process_horizontal_rule(output);
 
 	for (footnote = 0; footnote < inline_footnote_count; footnote++)
 	{
 		print_output(output,
 			"<p id=\"inline-footnote-%d\">"
 			"<a href=\"#inline-footnote-text-%d\">%d.</a> "
 			"%s\n",
 			footnote + 1, footnote + 1, footnote + 1,
 			(char*)inline_footnotes[footnote]);
 		output_firstcol = 1;
 	}
 
 	pfootnote = footnotes;
 	footnote  = 0;
 	while (pfootnote && footnote < footnote_count)
 	{
 		print_output(output,
 			"<p id=\"footnote-%d\">"
 			"<a href=\"#footnote-text-%d\">%d.</a> %s\n",
 			footnote + 1, footnote + 1, footnote + 1,
 			(char*)pfootnote->value);
 		output_firstcol = 1;
 		pfootnote++;
 		footnote++;
 	}
 
 	if (add_footnote_div)
 	{
 		print_output(output, "</div><!--footnotes-->\n");
 		output_firstcol = 1;
 	}
 
 	return 0;
 }
 
 static int
 end_head_start_body(FILE* output)
 {
 	print_output(output, "</head>\n<body>\n");
 	output_firstcol = 1;
 	return 0;
 }
 
 static int
 error(const int code, const char* file, const char* func, const int line,
 	const char* fmt, ...)
 {
 	char buf[BUFSIZE];
 	va_list args;
 	va_start(args, fmt);
 	vsnprintf(buf, sizeof(buf), (const char*)fmt, args);
 	va_end(args);
 	fprintf(stderr, "%s:%s:%lu:%lu:%s:%s:%d: %s\n", PROGRAMNAME,
 		input_filename ? input_filename : "(init/stdin)", lineno, colno,
 		func, file, line, buf);
 	return code;
 }
 
 static int
 filter_slw(const struct dirent* node)
 {
 	size_t node_len;
 	size_t slw_len;
 
 	assert(node != NULL);
 	if (((*node->d_name == '.')
 		    && (!*(node->d_name + 1)
 			    || ((*(node->d_name + 1) == '.')
 				    && !(*(node->d_name + 2))))))
 		return 0;
 	node_len = strlen(node->d_name);
 	slw_len	 = sizeof(".slw") - 1;
 	if (slw_len >= node_len)
 		return 0;
 	return !strcmp(node->d_name + node_len - slw_len, ".slw");
 }
 
 static int
 filter_subdirs(const struct dirent* node)
 {
 	struct stat st;
 	char* nodename = NULL;
 
 	assert(node != NULL);
 	if (((*node->d_name == '.')
 		    && (!*(node->d_name + 1)
 			    || ((*(node->d_name + 1) == '.')
 				    && !(*(node->d_name + 2))))))
 		return 0;
 	CALLOC(nodename, char, BUFSIZE);
 	snprintf(nodename, BUFSIZE, "%s/%s", incdir, node->d_name);
 	if (lstat(nodename, &st) < 0 || !S_ISDIR(st.st_mode))
 	{
 		free(nodename);
 		return 0;
 	}
 	free(nodename);
 	return 1;
 }
 
 static u8*
 format_date(const u8* date_arg, const char* timestamp_format)
 {
 	u8* day			      = NULL;
 	u8* month		      = NULL;
 	u8* year		      = NULL;
 	u8* formatted_date	      = NULL;
 	u8* ptr			      = NULL;
 	u8* date		      = NULL;
 	const char* ptimestamp_format = NULL;
 	char* temp		      = NULL;
 	size_t formatted_date_len;
 
 	assert((date_arg != NULL) && (timestamp_format != NULL));
 	errno = 0;
 	date  = (u8*)strdup((const char*)date_arg);
 	if (!date)
 	{
 		perror(PROGRAMNAME ": strdup");
 		exit(error(errno, __FILE__, __func__, __LINE__,
 			"Allocation error"));
 	}
 	CALLOC(formatted_date, u8, DATEBUFSIZE);
 	ptr  = NULL;
 	year = (u8*)strtok_r((char*)date, "-", (char**)&ptr);
 	if (!year)
 		goto format_date_cleanup;
 	month = (u8*)strtok_r(NULL, "-", (char**)&ptr);
 	if (!month)
 		goto format_date_cleanup;
 	day = (u8*)strtok_r(NULL, "T", (char**)&ptr);
 	if (!day)
 		goto format_date_cleanup;
 	ptimestamp_format  = timestamp_format;
 	formatted_date_len = 0;
 	while (*ptimestamp_format)
 	{
 		if (*ptimestamp_format == 'd' || *ptimestamp_format == 'D')
 		{
 			MEMCCPY((formatted_date + formatted_date_len), day,
 				DATEBUFSIZE - formatted_date_len, temp);
 			formatted_date_len += strlen((char*)day);
 		}
 		else if (*ptimestamp_format == 'm' || *ptimestamp_format == 'M')
 		{
 			MEMCCPY((formatted_date + formatted_date_len), month,
 				DATEBUFSIZE - formatted_date_len, temp);
 			formatted_date_len += strlen((char*)month);
 		}
 		else if (*ptimestamp_format == 'y' || *ptimestamp_format == 'Y')
 		{
 			MEMCCPY((formatted_date + formatted_date_len), year,
 				DATEBUFSIZE - formatted_date_len, temp);
 			formatted_date_len += strlen((char*)year);
 		}
 		else
 			*(formatted_date + formatted_date_len++)
 				= *ptimestamp_format;
 		ptimestamp_format++;
 	}
 	return formatted_date;
 
 format_date_cleanup:
 	free(formatted_date);
 	free(date);
 	return NULL;
 }
 
 static void
 free_keyvalue(KeyValue** list, const size_t list_count)
 {
 	assert(list != NULL);
 	if (!*list)
 		return;
 	for (size_t index = 0; index < list_count; index++)
 	{
 		KeyValue* current = *list + index;
 		free(current->value);
 		free(current->key);
 	}
 	return;
 }
 
 static u8*
 get_value(KeyValue* list, const size_t list_count, const u8* key,
 	KeyValue** cursor)
 {
 	KeyValue* plist = list;
 	if (!list)
 		return NULL;
 	assert(key != NULL);
 	while (plist < list + list_count)
 	{
 		if (!strcmp((char*)plist->key, (char*)key))
 		{
 			if (cursor)
 			{
 				if (plist + 1 < list + list_count)
 					*cursor = plist + 1;
 				else
 					*cursor = NULL;
 			}
 			return plist->value;
 		}
 		plist++;
 	}
 	if (cursor)
 		*cursor = NULL;
 	return NULL;
 }
 
 #define PIPE_READ_INDEX	 0
 #define PIPE_WRITE_INDEX 1
 
 static int
 print_command(FILE* output, const char* command, const u8* pass_arguments[],
 	const u8* pipe_arguments[], const int strip_newlines)
 {
 	FILE* cmd_input	    = NULL;
 	FILE* cmd_output    = NULL;
 	u8* cmd_output_line = NULL;
 	char* eol	    = NULL;
 	pid_t pid	    = 0;
 	pid_t wpid;
 	int pstatus = 0;
 	int arg_pipe_fds[2];
 	int output_pipe_fds[2];
 
 	assert((output != NULL) && (command != NULL)
 		&& (pass_arguments != NULL));
 	fflush(output);
 	pipe(arg_pipe_fds);
 	pipe(output_pipe_fds);
 	errno = 0;
 	pid   = fork();
 	if (pid == 0)
 	{
 		close(arg_pipe_fds[PIPE_WRITE_INDEX]);
 		close(output_pipe_fds[PIPE_READ_INDEX]);
 
 		dup2(arg_pipe_fds[PIPE_READ_INDEX], STDIN_FILENO);
 		dup2(output_pipe_fds[PIPE_WRITE_INDEX], STDOUT_FILENO);
 
 		execvp(command, (char* const*)pass_arguments);
 		exit(1);
 	}
 	else if (pid < 0)
 	{
 		perror(PROGRAMNAME ": fork");
 		exit(error(errno, __FILE__, __func__, __LINE__, "fork failed"));
 	}
 
 	/* Parent */
 	close(arg_pipe_fds[PIPE_READ_INDEX]);
 	close(output_pipe_fds[PIPE_WRITE_INDEX]);
 	errno	  = 0;
 	cmd_input = fdopen(arg_pipe_fds[PIPE_WRITE_INDEX], "w");
 	if (cmd_input)
 		cmd_output = fdopen(output_pipe_fds[PIPE_READ_INDEX], "r");
 	if (!cmd_input || !cmd_output)
 	{
 		perror(PROGRAMNAME ": fdopen");
 		exit(error(errno, __FILE__, __func__, __LINE__,
 			"fdopen failed"));
 	}
 
 	if (pipe_arguments)
 	{
 		const u8** ppipe_argument = pipe_arguments;
 		while (ppipe_argument && *ppipe_argument)
 		{
 			fprintf(cmd_input, "%s\n", *ppipe_argument);
 			ppipe_argument++;
 		}
 	}
 	fclose(cmd_input);
 
 	CALLOC(cmd_output_line, u8, BUFSIZE);
 	while (!feof(cmd_output))
 	{
 		if (!fgets((char*)cmd_output_line, BUFSIZE, cmd_output))
 			continue;
 		eol = strchr((char*)cmd_output_line, '\n');
 		if (eol)
 			*eol = 0;
 		print_output(output, "%s%s", cmd_output_line,
 			strip_newlines ? "" : "\n");
 	}
 	if (!strip_newlines)
 		output_firstcol = 1;
 	free(cmd_output_line);
 	fclose(cmd_output);
 	kill(pid, SIGKILL);
 	wpid = waitpid(pid, &pstatus, 0);
 	if (wpid < 0)
 		warning(pstatus,
 			(u8*)"Child returned nonzero status, errno = %d",
 			errno);
 	if (WIFEXITED(pstatus))
 		return WEXITSTATUS(pstatus);
 	return wpid;
 }
 
 #define PRINTCSVIF(format, arg)                                           \
 	do                                                                \
 	{                                                                 \
 		if ((ALL(csv_state, ST_CS_COND_NONEMPTY)                  \
 			    && *csv_register[conditional_index - 1])      \
 			|| (ALL(csv_state, ST_CS_COND_EMPTY)              \
 				&& !*csv_register[conditional_index - 1]) \
 			|| !ANY(csv_state,                                \
 				ST_CS_COND_EMPTY | ST_CS_COND_NONEMPTY))  \
 		{                                                         \
 			fprintf(output, format, arg);                     \
 		}                                                         \
 	} while (0)
 
 static void
 print_csv_row(FILE* output, u8** csv_header, u8** csv_register)
 {
 	u8* pcsv_template		= csv_template;
 	unsigned char csv_state		= ST_CS_NONE;
 	unsigned char num		= 0;
 	unsigned char conditional_index = 0;
 	assert((output != NULL) && (csv_header != NULL)
 		&& (csv_register != NULL));
 csv_template_start:
 	if (!*pcsv_template)
 		return;
 	if (IN(csv_state, ST_CS_ESCAPE))
 	{
 		PRINTCSVIF("%c", *pcsv_template);
 		CLEAR(csv_state, ST_CS_ESCAPE);
 		pcsv_template++;
 		goto csv_template_start;
 	}
 
 	switch (*pcsv_template)
 	{
 	case '\\':
 		SET(csv_state, ST_CS_ESCAPE);
 		pcsv_template++;
 		break;
 	case '$':
 		if (IN(csv_state, ST_CS_REGISTER))
 		{
 			PRINTCSVIF("%c", '$');
 			CLEAR(csv_state, ST_CS_REGISTER);
 		}
 		else
 			SET(csv_state, ST_CS_REGISTER);
 		pcsv_template++;
 		break;
 	case '#':
 		if (IN(csv_state, ST_CS_HEADER))
 		{
 			error(ERR_BAD_HR_MARK, __FILE__, __func__, __LINE__,
 				"Invalid header register mark");
 			CLEAR(csv_state, ST_CS_REGISTER | ST_CS_HEADER);
 		}
 		else if (IN(csv_state, ST_CS_REGISTER))
 		{
 			CLEAR(csv_state, ST_CS_REGISTER);
 			SET(csv_state, ST_CS_HEADER);
 		}
 		else
 			PRINTCSVIF("%c", '#');
 		pcsv_template++;
 		break;
 	case '?':
 		if (IN(csv_state, ST_CS_COND))
 		{
 			error(ERR_BAD_CND_MARK, __FILE__, __func__, __LINE__,
 				"Invalid conditional mark");
 			CLEAR(csv_state, ST_CS_COND);
 		}
 		else if (IN(csv_state, ST_CS_REGISTER))
 		{
 			CLEAR(csv_state, ST_CS_REGISTER);
 			SET(csv_state, ST_CS_COND);
 		}
 		else
 			PRINTCSVIF("%c", '?');
 		pcsv_template++;
 		break;
 	case '!':
 		if (ALL(csv_state, ST_CS_COND | ST_CS_COND_NONEMPTY))
 		{
 			CLEAR(csv_state, ST_CS_COND | ST_CS_COND_NONEMPTY);
 			SET(csv_state, ST_CS_COND_EMPTY);
 		}
 		else if (IN(csv_state, ST_CS_COND))
 		{
 			error(ERR_BAD_EMPTY_CND, __FILE__, __func__, __LINE__,
 				"Empty conditional before/without nonempty "
 				"conditional");
 			CLEAR(csv_state, ST_CS_COND | ST_CS_COND_EMPTY);
 		}
 		else
 			PRINTCSVIF("%c", '!');
 		pcsv_template++;
 		break;
 	case '/':
 		if (ALL(csv_state, ST_CS_COND | ST_CS_COND_EMPTY))
 			CLEAR(csv_state, ST_CS_COND | ST_CS_COND_EMPTY);
 		else if (ALL(csv_state, ST_CS_COND))
 			CLEAR(csv_state, ST_CS_COND | ST_CS_COND_NONEMPTY);
 		else
 			PRINTCSVIF("%c", '/');
 		pcsv_template++;
 		break;
 	case '1':
 	case '2':
 	case '3':
 	case '4':
 	case '5':
 	case '6':
 	case '7':
 	case '8':
 	case '9':
 		if (IN(csv_state, ST_CS_COND))
 		{
 			conditional_index = *pcsv_template - '0';
 			CLEAR(csv_state, ST_CS_COND);
 			SET(csv_state, ST_CS_COND_NONEMPTY);
 		}
 		else if (IN(csv_state, ST_CS_HEADER))
 		{
 			num = *pcsv_template - '0';
 			PRINTCSVIF("%s", csv_header[num - 1]);
 			CLEAR(csv_state, ST_CS_HEADER);
 		}
 		else if (IN(csv_state, ST_CS_REGISTER))
 		{
 			num = *pcsv_template - '0';
 			PRINTCSVIF("%s", csv_register[num - 1]);
 			CLEAR(csv_state, ST_CS_REGISTER);
 		}
 		else
 			PRINTCSVIF("%c", *pcsv_template);
 		pcsv_template++;
 		break;
 	default:
 		if (IN(csv_state, ST_CS_HEADER))
 		{
 			error(ERR_BAD_HR_MARK, __FILE__, __func__, __LINE__,
 				"Invalid header register mark");
 			CLEAR(csv_state, ST_CS_HEADER);
 		}
 		else if (IN(csv_state, ST_CS_REGISTER))
 		{
 			error(ERR_BAD_REG_MARK, __FILE__, __func__, __LINE__,
 				"Invalid register mark");
 			CLEAR(csv_state, ST_CS_REGISTER);
 		}
 		else
 			PRINTCSVIF("%c", *pcsv_template);
 		pcsv_template++;
 	}
 	goto csv_template_start;
 }
 
 static int
 print_image_dimensions(FILE* output, const u8* image_file_prefix, const u8* path)
 {
 	struct stat sb;
 	FILE* cmd_output = NULL;
 	char command[BUFSIZE];
 	char cmd_output_line[BUFSIZE];
 	char image_path[BUFSIZE - strlen(CMD_IDENTIFY)];
 	char* eol = NULL;
 
 	assert((output != NULL) && (path != NULL) && (basedir != NULL));
 	if (!*path)
 		return 1;
 	snprintf(image_path, BUFSIZE - strlen(CMD_IDENTIFY) - 1, "%s%s%s",
 		image_file_prefix ? (char*)image_file_prefix : basedir,
 		*path == '/' ? "" : "/", path);
 	errno = 0;
 	if (stat(image_path, &sb) < 0)
 	{
 		perror(PROGRAMNAME ": stat");
 		return errno;
 	}
 	snprintf(command, BUFSIZE - 1, CMD_IDENTIFY, image_path);
 	cmd_output = popen(command, "r");
 	/* popen(3): "The popen() function does not reliably set errno." */
 	if (!cmd_output)
 		return error(ERR_POPEN_FAIL, __FILE__, __func__, __LINE__,
 			"popen failed");
 	if (!fgets(cmd_output_line, BUFSIZE, cmd_output))
 		goto print_dimensions_cleanup;
 
 	eol = strchr((char*)cmd_output_line, '\n');
 	if (eol)
 		*eol = 0;
 	print_output(output, "%s", cmd_output_line);
 	output_firstcol = 0;
 
 print_dimensions_cleanup:
 	pclose(cmd_output);
 	return 0;
 }
 
 static void
 print_meta_var(FILE* output, u8** tsv_header, u8** tsv_register)
 {
 	u8* pvalue;
 	u8* var_name = NULL;
 	u8* value    = NULL;
 	size_t value_len;
 	UNUSED(tsv_header);
 	assert((output != NULL) && (tsv_header != NULL)
 		&& (tsv_register != NULL));
 	if (!*tsv_register || !*(tsv_register + 1))
 		return;
 	pvalue	  = *(tsv_register + 1);
 	value_len = strlen((char*)pvalue);
 	if (*pvalue == '%' && *(pvalue + value_len - 1) == '%')
 	{
 		errno	 = 0;
 		var_name = (u8*)strdup((char*)pvalue + 1);
 		if (!var_name)
 		{
 			perror(PROGRAMNAME ": strdup");
 			exit(error(errno, __FILE__, __func__, __LINE__,
 				"Allocation failed"));
 		}
 		*(var_name + value_len - 2) = 0;
 		value = get_value(vars, vars_count, var_name, NULL);
 		if (value)
 			print_output(output,
 				"<meta name=\"%s\" content=\"%s\">\n",
 				*tsv_register, value);
 		free(var_name);
 	}
 	else
 		print_output(output, "<meta name=\"%s\" content=\"%s\">\n",
 			*tsv_register, *(tsv_register + 1));
 }
 
 #define PRINTTSVIF(format, arg)                                           \
 	do                                                                \
 	{                                                                 \
 		if ((ALL(tsv_state, ST_CS_COND_NONEMPTY)                  \
 			    && *tsv_register[conditional_index - 1])      \
 			|| (ALL(tsv_state, ST_CS_COND_EMPTY)              \
 				&& !*tsv_register[conditional_index - 1]) \
 			|| !ANY(tsv_state,                                \
 				ST_CS_COND_EMPTY | ST_CS_COND_NONEMPTY))  \
 			fprintf(output, format, arg);                     \
 	} while (0)
 
 static void
 print_tsv_row(FILE* output, u8** tsv_header, u8** tsv_register)
 {
 	u8* ptsv_template		= tsv_template;
 	unsigned char tsv_state		= ST_CS_NONE;
 	unsigned char num		= 0;
 	unsigned char conditional_index = 0;
 
 	assert((output != NULL) && (tsv_header != NULL)
 		&& (tsv_register != NULL));
 tsv_template_start:
 	if (!*ptsv_template)
 		return;
 	if (IN(tsv_state, ST_CS_ESCAPE))
 	{
 		PRINTTSVIF("%c", *ptsv_template);
 		CLEAR(tsv_state, ST_CS_ESCAPE);
 		ptsv_template++;
 		goto tsv_template_start;
 	}
 
 	switch (*ptsv_template)
 	{
 	case '\\':
 		SET(tsv_state, ST_CS_ESCAPE);
 		ptsv_template++;
 		break;
 	case '$':
 		if (IN(tsv_state, ST_CS_REGISTER))
 		{
 			PRINTTSVIF("%c", '$');
 			CLEAR(tsv_state, ST_CS_REGISTER);
 		}
 		else
 			SET(tsv_state, ST_CS_REGISTER);
 		ptsv_template++;
 		break;
 	case '#':
 		if (IN(tsv_state, ST_CS_HEADER))
 		{
 			error(ERR_BAD_HR_MARK, __FILE__, __func__, __LINE__,
 				"Invalid header register mark");
 			CLEAR(tsv_state, ST_CS_REGISTER | ST_CS_HEADER);
 		}
 		else if (IN(tsv_state, ST_CS_REGISTER))
 		{
 			CLEAR(tsv_state, ST_CS_REGISTER);
 			SET(tsv_state, ST_CS_HEADER);
 		}
 		else
 			PRINTTSVIF("%c", '#');
 		ptsv_template++;
 		break;
 	case '?':
 		if (IN(tsv_state, ST_CS_COND))
 		{
 			error(ERR_BAD_CND_MARK, __FILE__, __func__, __LINE__,
 				"Invalid conditional mark");
 			CLEAR(tsv_state, ST_CS_COND);
 		}
 		else if (IN(tsv_state, ST_CS_REGISTER))
 		{
 			CLEAR(tsv_state, ST_CS_REGISTER);
 			SET(tsv_state, ST_CS_COND);
 		}
 		else
 			PRINTTSVIF("%c", '?');
 		ptsv_template++;
 		break;
 	case '!':
 		if (ALL(tsv_state, ST_CS_COND | ST_CS_COND_NONEMPTY))
 		{
 			CLEAR(tsv_state, ST_CS_COND | ST_CS_COND_NONEMPTY);
 			SET(tsv_state, ST_CS_COND_EMPTY);
 		}
 		else if (IN(tsv_state, ST_CS_COND))
 		{
 			error(ERR_BAD_EMPTY_CND, __FILE__, __func__, __LINE__,
 				"Empty conditional before/without nonempty "
 				"conditional");
 			CLEAR(tsv_state, ST_CS_COND | ST_CS_COND_EMPTY);
 		}
 		else
 			PRINTTSVIF("%c", '!');
 		ptsv_template++;
 		break;
 	case '/':
 		if (ALL(tsv_state, ST_CS_COND | ST_CS_COND_EMPTY))
 			CLEAR(tsv_state, ST_CS_COND | ST_CS_COND_EMPTY);
 		else if (ALL(tsv_state, ST_CS_COND))
 			CLEAR(tsv_state, ST_CS_COND | ST_CS_COND_NONEMPTY);
 		else
 			PRINTTSVIF("%c", '/');
 		ptsv_template++;
 		break;
 	case '1':
 	case '2':
 	case '3':
 	case '4':
 	case '5':
 	case '6':
 	case '7':
 	case '8':
 	case '9':
 		if (IN(tsv_state, ST_CS_COND))
 		{
 			conditional_index = *ptsv_template - '0';
 			CLEAR(tsv_state, ST_CS_COND);
 			SET(tsv_state, ST_CS_COND_NONEMPTY);
 		}
 		else if (IN(tsv_state, ST_CS_HEADER))
 		{
 			num = *ptsv_template - '0';
 			PRINTTSVIF("%s", tsv_header[num - 1]);
 			CLEAR(tsv_state, ST_CS_HEADER);
 		}
 		else if (IN(tsv_state, ST_CS_REGISTER))
 		{
 			num = *ptsv_template - '0';
 			PRINTTSVIF("%s", tsv_register[num - 1]);
 			CLEAR(tsv_state, ST_CS_REGISTER);
 		}
 		else
 			PRINTTSVIF("%c", *ptsv_template);
 		ptsv_template++;
 		break;
 	default:
 		if (IN(tsv_state, ST_CS_HEADER))
 		{
 			error(ERR_BAD_HR_MARK, __FILE__, __func__, __LINE__,
 				"Invalid header register mark");
 			CLEAR(tsv_state, ST_CS_HEADER);
 		}
 		else if (IN(tsv_state, ST_CS_REGISTER))
 		{
 			error(ERR_BAD_REG_MARK, __FILE__, __func__, __LINE__,
 				"Invalid register mark");
 			CLEAR(tsv_state, ST_CS_REGISTER);
 		}
 		else
 			PRINTTSVIF("%c", *ptsv_template);
 		ptsv_template++;
 	}
 	goto tsv_template_start;
 }
 
 static int
 print_output(FILE* output, const char* fmt, ...)
 {
 	u8* var_incdir_only_summary = NULL;
 	u8* temp		    = NULL;
 	char buf[BUFSIZE];
 	va_list args;
 	int incdir_only_summary = 0;
 
 	assert((output != NULL) && (fmt != NULL));
 	va_start(args, fmt);
 	var_incdir_only_summary
 		= get_value(vars, vars_count, (u8*)"incdir-only-summary", NULL);
 	incdir_only_summary
 		= var_incdir_only_summary && (*var_incdir_only_summary == '1');
 	if (IN(state, ST_INCDIR) && !IN(state, ST_SUMMARY)
 		&& incdir_only_summary)
 		return 0;
 	else if (IN(state, ST_CSV_BODY))
 	{
 		size_t buf_len = 0;
 		vsnprintf((char*)buf, BUFSIZE, fmt, args);
 		buf_len = strlen(buf);
 		if (!csv_template)
 		{
 			csv_template_size = BUFSIZE;
 			CALLOC(csv_template, u8, csv_template_size);
 			MEMCCPY(csv_template, buf, csv_template_size, temp);
 		}
 		else
 		{
 			csv_template_len = strlen((char*)csv_template);
 			ENSURE_SIZE(csv_template, temp, csv_template_size,
 				csv_template_len + buf_len + 1,
 				csv_template_len + buf_len + 1,
 				print_output_alloc_error, u8);
 			MEMCCPY((csv_template + csv_template_len), buf,
 				csv_template_size - csv_template_len, temp);
 		}
 	}
 	else if (IN(state, ST_TSV_BODY))
 	{
 		size_t buf_len = 0;
 		vsnprintf((char*)buf, BUFSIZE, fmt, args);
 		buf_len = strlen(buf);
 		if (!tsv_template)
 		{
 			tsv_template_size = BUFSIZE;
 			CALLOC(tsv_template, u8, tsv_template_size);
 			MEMCCPY(tsv_template, buf, tsv_template_size, temp);
 		}
 		else
 		{
 			tsv_template_len = strlen((char*)tsv_template);
 			ENSURE_SIZE(tsv_template, temp, tsv_template_size,
 				tsv_template_len + buf_len + 1,
 				tsv_template_len + buf_len + 1,
 				print_output_alloc_error, u8);
 			MEMCCPY((tsv_template + tsv_template_len), buf,
 				tsv_template_size - tsv_template_len, temp);
 		}
 	}
 	else
 		vfprintf(output, fmt, args);
 	va_end(args);
 	return 0;
 print_output_alloc_error:
 	exit(error(errno, __FILE__, __func__, __LINE__, "Allocation error"));
 	return 1;
 }
 
 static int
 process_blockquote(FILE* output, const int end_tag)
 {
 	print_output(output, "<%sblockquote>", end_tag ? "/" : "");
 	return 0;
 }
 
 static int
 process_bold(FILE* output, const int end_tag)
 {
 	print_output(output, "<%sstrong>", end_tag ? "/" : "");
 	return 0;
 }
 
 static int
 process_code(FILE* output, const int end_tag)
 {
 	print_output(output, "<%scode>", end_tag ? "/" : "");
 	return 0;
 }
 
 static int
 process_csv(FILE* output, const u8* arg_token,
 	const int read_yaml_macros_and_links, const int end_tag)
 {
 	u8* saveptr   = NULL;
 	u8* args      = NULL;
 	u8* args_base = NULL;
 	size_t args_len;
 	assert((output != NULL) && (arg_token != NULL));
 	if (end_tag)
 	{
 		CLEAR(state, ST_CSV_BODY);
 		if (read_yaml_macros_and_links)
 			return 0;
 		read_csv(output, csv_filename, &print_csv_row);
 		free(csv_filename);
 		csv_filename = NULL;
 		free(csv_template);
 		csv_template	  = NULL;
 		csv_template_size = 0;
 	}
 	else
 	{
 		if (ANY(state, ST_CSV_BODY | ST_TSV_BODY))
 			exit(error(ERR_NEST_CSV, __FILE__, __func__, __LINE__,
 				"Can't nest csv/tsv directives"));
 		SET(state, ST_CSV_BODY);
 		if (read_yaml_macros_and_links)
 			return 0;
 		csv_iter = 0;
 		(void)strtok_r((char*)arg_token, " ", (char**)&saveptr);
 		args = (u8*)strtok_r(NULL, " ", (char**)&saveptr);
 		if (!args)
 			exit(error(ERR_NO_ARG, __FILE__, __func__, __LINE__,
 				"Arguments required"));
 		args_len = strlen((char*)args);
 		if (*args != '"' || *(args + args_len - 1) != '"')
 			exit(error(ERR_ARG_NOTSTR, __FILE__, __func__, __LINE__,
 				"First argument must be a string"));
 		if (!csv_filename)
 			CALLOC(csv_filename, char, BUFSIZE);
 		args_base = (u8*)strdup((char*)args + 1);
 		*(args_base + strlen((char*)args_base) - 1) = 0;
 		snprintf(csv_filename, BUFSIZE, "%s/%s.csv", input_dirname,
 			(char*)args_base);
 		free(args_base);
 		args = (u8*)strtok_r(NULL, " ", (char**)&saveptr);
 		if (args)
 		{
 			errno	 = 0;
 			csv_iter = (size_t)strtol((char*)args, NULL, 10);
 			if (errno)
 			{
 				perror(PROGRAMNAME ": strtol");
 				exit(error(errno, __FILE__, __func__, __LINE__,
 					"Invalid argument '%s'", args));
 			}
 		}
 	}
 	return 0;
 }
 
 static int
 process_footnote(FILE* output, const u8* token, const int footnote_definition,
 	const int footnote_output)
 {
 	char* temp = NULL;
 
 	assert(token != NULL);
 	current_footnote++;
 	if (footnote_definition)
 	{
 		footnote_count++;
 		if (footnote_count == 1 && inline_footnote_count > 0)
 			warning(1,
 				(u8*)"Both inline and regular footnotes "
 				     "present");
 		else if (!footnotes)
 		{
 			footnote_count = 1;
 			CALLOC(footnotes, KeyValue, footnote_count);
 			pfootnotes = footnotes;
 		}
 		else
 		{
 			REALLOCARRAY(footnotes, KeyValue, footnote_count);
 			pfootnotes = footnotes + footnote_count - 1;
 		}
 		CALLOC(pfootnotes->key, u8, KEYSIZE);
 		MEMCCPY(pfootnotes->key, (char*)token, KEYSIZE, temp);
 		pfootnotes->value      = NULL;
 		pfootnotes->value_size = 0;
 	}
 	if (footnote_output)
 	{
 		print_output(output,
 			"<a href=\"#footnote-%d\" id=\"footnote-text-%d\">"
 			"<sup>%d</sup></a>",
 			current_footnote, current_footnote, current_footnote);
 		output_firstcol = 0;
 	}
 	return 0;
 }
 
 static int
 process_formula(FILE* output, const u8* token, const int display_formula)
 {
 	const u8* pipe_args[] = {token, NULL};
 	int result	      = 0;
 
 	assert(token != NULL);
 	result = print_command(output, CMD_KATEX,
 		display_formula ? (const u8**)CMD_KATEX_DISPLAY_ARGS
 				: (const u8**)CMD_KATEX_INLINE_ARGS,
 		(const u8**)pipe_args, 1);
 	if (result)
 	{
 		print_output(output, "%s$%s$%s", display_formula ? "$" : "",
 			token, display_formula ? "$" : "");
 		output_firstcol = 0;
 	}
 	return result;
 }
 
 static int
 process_git_log(FILE* output)
 {
 	u8* pipe_args[]	     = {NULL, NULL};
 	char* basename	     = NULL;
 	char* temp	     = NULL;
 	char* slash	     = NULL;
 	size_t basename_size = BUFSIZE;
 	pid_t result	     = 0;
 
 	assert(output != NULL);
 	if (!input_filename)
 		return warning(1, (u8*)"Cannot use 'git-log' in stdin");
 
 	slash = strrchr(input_filename, '/');
 	CALLOC(basename, char, basename_size);
 	if (slash)
 		MEMCCPY(basename, slash + 1, basename_size, temp);
 	else
 		MEMCCPY(basename, input_filename, basename_size, temp);
 	pipe_args[0] = (u8*)basename;
 	print_output(output, "<div id=\"git-log\">\nPrevious commit:\n");
 	result = print_command(output, CMD_GIT_LOG,
 		(const u8**)CMD_GIT_LOG_ARGS, (const u8**)pipe_args, 0);
 	print_output(output, "</div><!--git-log-->\n");
 	output_firstcol = 1;
 	free(basename);
 	return result ? warning(result, (u8*)"git-log: Cannot run git") : 0;
 }
 
 static int
 process_heading(FILE* output, const u8* token, const unsigned char heading_level)
 {
 	assert((output != NULL) && (token != NULL));
 	if (!*token)
 		warning(1, (u8*)"Empty heading");
 	print_output(output, "%s</h%hhu>", (char*)token, heading_level);
 	return 0;
 }
 
 static int
 process_heading_start(FILE* output, const unsigned char heading_level,
 	const size_t heading_count)
 {
 	print_output(output, "<h%hhu id=\"heading-%zu\">", heading_level,
 		heading_count);
 	return 0;
 }
 
 static void
 process_horizontal_rule(FILE* output)
 {
 	print_output(output, "<hr>\n");
 	if (IN(state, ST_PARA_OPEN))
 		print_output(output, "<p>\n");
 	output_firstcol = 1;
 }
 
 static void
 process_image(FILE* output, const u8* image_text, const u8* image_file_prefix,
 	const u8* link_prefix, const u8* image_id, const int add_link,
 	const int add_figcaption)
 {
 	u8* url = get_value(links, links_count, image_id, NULL);
 	process_inline_image(output, image_text, image_file_prefix, link_prefix,
 		url, add_link, add_figcaption);
 }
 
 static int
 process_incdir(FILE* output, const u8* token, const u8* link_prefix,
 	const u8* footer_permalink_text, const char* permalink_url,
 	const int ext_in_permalink, const int read_yaml_macros_and_links)
 {
 	struct dirent** namelist;
 	struct dirent** pnamelist;
 	u8* saveptr = NULL;
 	/* skipping the first token (incdir) */
 	u8* arg	       = NULL;
 	u8* macro_body = NULL;
 	u8* parg       = NULL;
 	size_t arg_len = 0;
 	int names_output;
 	int num		 = 5;
 	int names_total	 = 0;
 	int details_open = 1;
 	int list_only	 = 0;
 	int pass;
 
 	assert((output != NULL) && (token != NULL));
 	if (read_yaml_macros_and_links)
 		return 0;
 	(void)strtok_r((char*)token, " ", (char**)&saveptr);
 	arg = (u8*)strtok_r(NULL, " ", (char**)&saveptr);
 	if (!arg)
 		exit(error(ERR_NO_ARG, __FILE__, __func__, __LINE__,
 			"Arguments required"));
 	arg_len = strlen((char*)arg);
 	if (*arg != '"' || *(arg + arg_len - 1) != '"')
 		exit(error(ERR_ARG_NOTSTR, __FILE__, __func__, __LINE__,
 			"First argument not string"));
 
 	incdir			       = strdup((char*)(arg + 1));
 	*(incdir + strlen(incdir) - 1) = 0; /* trim ending " */
 
 	pass = 0;
 incdir_next_arg:
 	arg = (u8*)strtok_r(NULL, " ", (char**)&saveptr);
 	if (!arg)
 		goto incdir_done_args;
 	parg = arg;
 	if (*parg == '=')
 		macro_body = get_value(macros, macros_count, arg + 1, NULL);
 	else if (!strcmp((const char*)arg, "listonly"))
 		list_only = 1;
 	else
 	{
 		while (parg && *parg)
 		{
 			if (*parg < '0' || *parg > '9')
 				exit(error(ERR_ARG_NOTNUM, __FILE__, __func__,
 					__LINE__, "Argument not a number"));
 			parg++;
 		}
 		errno = 0;
 		num   = strtol((char*)arg, NULL, 10);
 		if (errno)
 		{
 			perror(PROGRAMNAME ": strtol");
 			exit(error(errno, __FILE__, __func__, __LINE__,
 				"Invalid parameter 'num'"));
 		}
 	}
 	pass++;
 	if (pass < 3)
 		goto incdir_next_arg;
 
 incdir_done_args:
 	print_output(output, "<ul class=\"incdir\">\n");
 	/* scandir(3) does not set errno */
 	if ((names_total = scandir(incdir, &namelist, &filter_subdirs,
 		     &reverse_alphacompare))
 		< 0)
 		exit(error(ERR_SCANDIR_FAIL, __FILE__, __func__, __LINE__,
 			"scandir '%s' failed", incdir));
 	pnamelist    = namelist;
 	names_output = 0;
 	while (names_output < MIN(names_total, num))
 	{
 		/*if (list_only)
 			print_output(output, "<li>%s\n",
 			(*pnamelist)->d_name);*/
 		process_incdir_subdir(output, (*pnamelist)->d_name, link_prefix,
 			details_open, macro_body, footer_permalink_text,
 			permalink_url, ext_in_permalink, list_only);
 		details_open = 0;
 		pnamelist++;
 		names_output++;
 		/*if (list_only)
 			print_output(output, "</li>\n");*/
 	}
 	while (names_total--)
 		free(namelist[names_total]);
 	free(namelist);
 	free(incdir);
 	print_output(output, "</ul>\n");
 	output_firstcol = 1;
 	return 0;
 }
 
 static void
 process_incdir_subdir(FILE* output, const char* subdirname,
 	const u8* link_prefix, const int details_open, const u8* macro_body,
 	const u8* footer_permalink_text, const char* permalink_url,
 	const int ext_in_permalink, const int list_only)
 {
 	struct dirent** namelist;
 	struct dirent** pnamelist;
 	FILE* input		       = NULL;
 	u8* buffer		       = NULL;
 	u8* date		       = NULL;
 	u8* formatted_date	       = NULL;
 	u8* title		       = NULL;
 	u8* var_incdir_only_summary    = NULL;
 	char* abs_subdirname	       = NULL;
 	char* temp		       = NULL;
 	char* filename		       = NULL;
 	char* link		       = NULL;
 	unsigned long long saved_state = ST_NONE;
 	size_t buffer_size	       = 0;
 	size_t link_len;
 	pid_t pid;
 	int names_output;
 	int names_total		= 0;
 	int pstatus		= 0;
 	int incdir_only_summary = 0;
 	int result		= 0;
 
 	UNUSED(link_prefix);
 	assert((output != NULL) && (subdirname != NULL));
 
 	if (list_only)
 		; /*print_output(output, "<ul>\n");*/
 	else
 		print_output(output, "<li>\n<details%s>\n<summary>",
 			details_open ? " open" : "");
 	if (macro_body)
 		print_output(output, "%s", macro_body);
 	if (!list_only)
 		print_output(output, "%s</summary>\n<div>\n", subdirname);
 
 	CALLOC(abs_subdirname, char, BUFSIZE);
 	snprintf(abs_subdirname, BUFSIZE, "%s/%s/%s", basedir, incdir,
 		subdirname);
 
 	if ((names_total = scandir(abs_subdirname, &namelist, &filter_slw,
 		     &reverse_alphacompare))
 		< 0)
 	{
 		exit(error(ERR_SCANDIR_FAIL, __FILE__, __func__, __LINE__,
 			"scandir '%s' failed", abs_subdirname));
 	}
 
 	pnamelist    = namelist;
 	names_output = 0;
 	while (names_output < names_total)
 	{
 		pstatus = 0;
 		if (!list_only)
 			print_output(output, "<article>\n");
 		fflush(output);
 		errno = 0;
 		pid   = fork();
 		if (pid > 0)
 			wait(&pstatus);
 		else if (pid == 0)
 		{
 			output = stdout;
 			if (!strcmp(basedir, "."))
 				set_basedir(&basedir, &basedir_size,
 					abs_subdirname);
 			CALLOC(filename, char, BUFSIZE);
 			snprintf(filename, BUFSIZE, "%s/%s", abs_subdirname,
 				(*pnamelist)->d_name);
 			link = strip_ext(filename, BUFSIZE);
 
 			read_file_into_buffer(&input, &buffer, &buffer_size,
 				filename, &input_dirname);
 
 			free_keyvalue(&links, links_count);
 			free(links);
 			links	    = NULL;
 			links_count = 0;
 
 			free_keyvalue(&footnotes, footnote_count);
 			free(footnotes);
 			footnotes	 = NULL;
 			footnote_count	 = 0;
 			current_footnote = 0;
 			while (inline_footnote_count--)
 				free(inline_footnotes[inline_footnote_count]);
 			free(inline_footnotes);
 			inline_footnotes	= NULL;
 			inline_footnote_count	= 0;
 			current_inline_footnote = 0;
 
 			saved_state = state;
 			state	    = ST_INCDIR;
 
 			/* First pass: read YAML, macros and links */
 			result = slweb_parse(output, filename, BUFSIZE, buffer,
 				1, 1);
 			if (result)
 			{
 				warning(1,
 					(u8*)"process_incdir_subdir: "
 					     "slweb_parse error");
 				goto incdir_subdir_child_cleanup;
 			}
 
 			title = get_value(vars, vars_count, (u8*)"title", NULL);
 			date  = get_value(vars, vars_count, (u8*)"date", NULL);
 			formatted_date
 				= format_date(date, list_timestamp_format);
 			if (!formatted_date)
 				exit(error(ERR_FORMAT_DATE_FAIL, __FILE__,
 					__func__, __LINE__,
 					"format_date error"));
 
 			/* Have to temporarily reset this because of potential
 			 * interaction with print_output */
 			var_incdir_only_summary = get_value(vars, vars_count,
 				(u8*)"incdir-only-summary", NULL);
 			incdir_only_summary	= var_incdir_only_summary
 				&& *var_incdir_only_summary == '1';
 			if (list_only && var_incdir_only_summary)
 				var_incdir_only_summary[0] = '0';
 
 			if (list_only)
 			{
 				print_output(output,
 					"<li>%s <a href=\"%s\">%s</a></li>\n",
 					formatted_date,
 					permalink_url ? permalink_url : link,
 					title);
 				fflush(output);
 				/* ... and fallthrough to cleanup */
 			}
 			else if (!result)
 			{
 				if (incdir_only_summary
 					&& var_incdir_only_summary)
 					var_incdir_only_summary[0] = '1';
 				goto skip_incdir_subdir_child_cleanup;
 			}
 
 		incdir_subdir_child_cleanup:
 			cleanup();
 			free(formatted_date);
 			free(link);
 			free(filename);
 			free(buffer);
 			free(abs_subdirname);
 			while (names_total--)
 				free(namelist[names_total]);
 			free(namelist);
 			exit(result);
 
 		skip_incdir_subdir_child_cleanup:
 			state			= ST_INCDIR;
 			current_footnote	= 0;
 			current_inline_footnote = 0;
 
 			/* Second pass: parse and output */
 			result = slweb_parse(output, filename, BUFSIZE, buffer,
 				1, 0);
 
 			state = saved_state;
 
 			if (footer_permalink_text && incdir_only_summary)
 			{
 				if (ext_in_permalink)
 				{
 					link_len = strlen(link);
 					MEMCCPY((link + link_len),
 						timestamp_output_ext,
 						BUFSIZE - link_len, temp);
 				}
 
 				/* TODO: Get rid of orphan <p> just before
 				 * <footer>; would probably need another flag
 				 * and another layer of code, so maybe not
 				 */
 				print_output(output,
 					"<footer>\n"
 					"<p><a href=\"%s\">%s</a>\n"
 					"</footer>\n",
 					permalink_url ? permalink_url : link,
 					footer_permalink_text);
 			}
 
 			fflush(output);
 			cleanup();
 			free(formatted_date);
 			free(link);
 			free(filename);
 			free(buffer);
 			free(abs_subdirname);
 			while (names_total--)
 				free(namelist[names_total]);
 			free(namelist);
 			exit(result);
 		}
 		else
 		{
 			perror(PROGRAMNAME ": fork");
 			exit(error(errno, __FILE__, __func__, __LINE__,
 				"fork failed"));
 		}
 
 		if (!list_only)
 			print_output(output, "</article>\n");
 
 		pnamelist++;
 		names_output++;
 	}
 
 	while (names_total--)
 		free(namelist[names_total]);
 	free(namelist);
 	free(abs_subdirname);
 
 	if (list_only)
 		; /*print_output(output, "</ul>\n");*/
 	else
 		print_output(output, "</div>\n</details>\n</li>\n");
 
 	output_firstcol = 0;
 }
 
 static void
 process_include(FILE* output, const u8* token,
 	const int read_yaml_macros_and_links)
 {
 	FILE* child_output    = NULL;
 	FILE* input	      = NULL;
 	u8* child_output_line = NULL;
 	u8* ptoken;
 	u8* buffer		= NULL;
 	char* include_filename	= NULL;
 	char* pinclude_filename = NULL;
 	char* eol		= NULL;
 	char* filename		= NULL;
 	int arg_pipe_fds[2];
 	int output_pipe_fds[2];
 	size_t buffer_size = 0;
 	pid_t pid	   = 0;
 	int pstatus	   = 0;
 	int result	   = 0;
 
 	assert((output != NULL) && (token != NULL));
 	ptoken = (u8*)strchr((char*)token, ' ');
 	if (!input_filename)
 	{
 		warning(1,
 			(u8*)"process_include: Cannot use 'include' in stdin");
 		return;
 	}
 	if (!ptoken)
 		exit(error(ERR_NO_ARG, __FILE__, __func__, __LINE__,
 			"Directive 'include' requires an argument"));
 	fflush(output);
 	pipe(arg_pipe_fds);
 	pipe(output_pipe_fds);
 	errno = 0;
 	pid   = fork();
 	if (pid > 0) /* parent */
 	{
 		child_output	  = NULL;
 		child_output_line = NULL;
 		close(arg_pipe_fds[PIPE_READ_INDEX]);
 		close(output_pipe_fds[PIPE_WRITE_INDEX]);
 		errno = 0;
 		if (!(child_output
 			    = fdopen(output_pipe_fds[PIPE_READ_INDEX], "r")))
 		{
 			int save_errno = errno;
 			perror(PROGRAMNAME ": fdopen");
 			wait(&pstatus);
 			exit(error(save_errno, __FILE__, __func__, __LINE__,
 				"fdopen failed"));
 		}
 		CALLOC(child_output_line, u8, BUFSIZE);
 		while (!feof(child_output))
 		{
 			eol = NULL;
 			if (!fgets((char*)child_output_line, BUFSIZE,
 				    child_output))
 				continue;
 			eol = strchr((char*)child_output_line, '\n');
 			if (eol)
 				*eol = 0;
 			simple_parse_yaml_line(child_output_line, &vars,
 				&vars_count, &pvars);
 		}
 		free(child_output_line);
 		fclose(child_output);
 		wait(&pstatus);
 	}
 	else if (pid == 0) /* child */
 	{
 		close(arg_pipe_fds[PIPE_WRITE_INDEX]);
 		close(output_pipe_fds[PIPE_READ_INDEX]);
 		errno = 0;
 		if (!(child_output
 			    = fdopen(output_pipe_fds[PIPE_WRITE_INDEX], "w")))
 		{
 			perror(PROGRAMNAME ": fdopen");
 			exit(error(errno, __FILE__, __func__, __LINE__,
 				"fdopen failed"));
 		}
 		CALLOC(include_filename, char, BUFSIZE);
 		pinclude_filename = include_filename;
 		ptoken++;
 		while (ptoken && *ptoken)
 			if (*ptoken != '"')
 				*pinclude_filename++ = *ptoken++;
 			else
 				ptoken++;
 		if (!strcmp(basedir, "."))
 			set_basedir(&basedir, &basedir_size, input_dirname);
 		CALLOC(filename, char, BUFSIZE);
 		snprintf(filename, BUFSIZE, "%s/%s.slw", basedir,
 			include_filename);
 		free(include_filename);
 
 		result = read_file_into_buffer(&input, &buffer, &buffer_size,
 			filename, &input_dirname);
 		if (result)
 			exit(result);
 
 		free_keyvalue(&links, links_count);
 		free(links);
 		links	    = NULL;
 		links_count = 0;
 
 		free_keyvalue(&footnotes, footnote_count);
 		free(footnotes);
 		footnotes	 = NULL;
 		footnote_count	 = 0;
 		current_footnote = 0;
 		while (inline_footnote_count--)
 			free(inline_footnotes[inline_footnote_count]);
 		free(inline_footnotes);
 		inline_footnotes	= NULL;
 		inline_footnote_count	= 0;
 		current_inline_footnote = 0;
 		state			= ST_NONE;
 
 		/* First pass: read YAML, macros and links */
 		result = slweb_parse(output, filename, BUFSIZE, buffer, 1, 1);
 
 		add_css(child_output, 1);
 		if (result || read_yaml_macros_and_links)
 			goto process_include_child_cleanup;
 
 		state			= ST_NONE;
 		current_footnote	= 0;
 		current_inline_footnote = 0;
 
 		/* Second pass: parse and output */
 		result = slweb_parse(output, filename, BUFSIZE, buffer, 1, 0);
 
 	process_include_child_cleanup:
 		fflush(output);
 		cleanup();
 		free(filename);
 		free(buffer);
 		fclose(child_output);
 		exit(result);
 	}
 	else
 	{
 		perror(PROGRAMNAME ": fork");
 		exit(error(errno, __FILE__, __func__, __LINE__, "fork failed"));
 	}
 }
 
 static int
 process_inline_footnote(const u8* token, const int read_yaml_macros_and_links,
 	FILE* output)
 {
 	char* temp = NULL;
 	size_t token_len;
 	assert(token != NULL);
 	current_inline_footnote++;
 	if (read_yaml_macros_and_links)
 	{
 		token_len = strlen((char*)token);
 		inline_footnote_count++;
 		if (inline_footnote_count == 1 && footnote_count > 0)
 			warning(1,
 				(u8*)"Both inline and regular footnotes "
 				     "present");
 		else if (!inline_footnotes)
 		{
 			inline_footnote_count = 1;
 			CALLOC(inline_footnotes, u8*, inline_footnote_count);
 		}
 		else
 			REALLOC(inline_footnotes, u8*,
 				sizeof(u8*) * inline_footnote_count);
 		CALLOC(inline_footnotes[inline_footnote_count - 1], u8,
 			token_len + 1);
 		MEMCCPY(inline_footnotes[inline_footnote_count - 1],
 			(char*)token, token_len + 1, temp);
 	}
 	else
 	{
 		print_output(output,
 			"<a href=\"#inline-footnote-%d\" "
 			"id=\"inline-footnote-text-%d\"><sup>%d</sup></a>",
 			current_inline_footnote, current_inline_footnote,
 			current_inline_footnote);
 		output_firstcol = 0;
 	}
 	return 0;
 }
 
 static void
 process_inline_image(FILE* output, const u8* image_text,
 	const u8* image_file_prefix, const u8* link_prefix, const u8* image_url,
 	const int add_link, const int add_figcaption)
 {
 	assert((output != NULL) && (image_text != NULL));
 	if (add_figcaption)
 		print_output(output, "<figure>\n");
 	if (add_link)
 		print_output(output,
 			"<a href=\"%s%s%s\" title=\"%s\" class=\"image\""
 			" target=\"_blank\">",
 			global_link_prefix ? (const char*)global_link_prefix
 					   : "",
 			link_prefix ? (const char*)link_prefix : "",
 			image_url ? (char*)image_url : "", image_text);
 	print_output(output, "<img src=\"%s\" alt=\"%s\"%s",
 		image_url ? (char*)image_url : "", image_text,
 		image_url ? " " : "");
 	if (image_url)
 		print_image_dimensions(output, image_file_prefix, image_url);
 	print_output(output, ">");
 	output_firstcol = 0;
 	if (add_link)
 		print_output(output, "</a>");
 	if (add_figcaption)
 	{
 		print_output(output, "<figcaption>%s</figcaption>\n</figure>\n",
 			image_text);
 		output_firstcol = 1;
 	}
 }
 
 static int
 process_inline_link(FILE* output, const u8* link_text, const u8* link_prefix,
 	const u8* link_macro_body, const u8* link_url)
 {
 	print_output(output, "<a href=\"%s%s%s\">%s%s</a>",
 		global_link_prefix ? (const char*)global_link_prefix : "",
 		link_prefix ? (const char*)link_prefix : "",
 		link_url ? (char*)link_url : "",
 		link_macro_body ? (char*)link_macro_body : "", link_text);
 	output_firstcol = 0;
 	return 0;
 }
 
 static void
 process_inline_stylesheet(FILE* output, const u8* css_filename, int output_yaml)
 {
 	FILE* css		 = NULL;
 	u8* bufline		 = NULL;
 	char* css_pathname	 = NULL;
 	size_t css_filename_len	 = 0;
 	size_t css_pathname_size = 0;
 
 	assert((output != NULL) && (css_filename != NULL));
 	css_filename_len  = strlen((char*)css_filename);
 	css_pathname_size = basedir_size + css_filename_len + 1;
 
 	CALLOC(css_pathname, char, css_pathname_size);
 	if ((size_t)snprintf(css_pathname, css_pathname_size, "%s/%s", basedir,
 		    css_filename)
 		> css_pathname_size)
 		warning(1, (u8*)"snprintf:%d: Overflow", __LINE__);
 	errno = 0;
 	if (!(css = fopen((const char*)css_pathname, "rt")))
 	{
 		perror(PROGRAMNAME ": fopen");
 		exit(error(errno, __FILE__, __func__, __LINE__,
 			"fopen failed: %s", css_pathname));
 	}
 
 	if (output_yaml)
 	{
 		print_output(output, "inline-stylesheet: %s\n", css_filename);
 		output_firstcol = 1;
 		goto process_inline_stylesheet_cleanup;
 	}
 
 	CALLOC(bufline, u8, BUFSIZE);
 	print_output(output, "<style>\n");
 	while (!feof(css))
 	{
 		if (!fgets((char*)bufline, BUFSIZE, css))
 			break;
 		print_output(output, "%s", bufline);
 	}
 	print_output(output, "</style>\n");
 	output_firstcol = 1;
 
 process_inline_stylesheet_cleanup:
 	free(css_pathname);
 	fclose(css);
 	free(bufline);
 }
 
 static void
 process_italic(FILE* output, const int end_tag)
 {
 	print_output(output, "<%sem>", end_tag ? "/" : "");
 }
 
 static void
 process_kbd(FILE* output, const int end_tag)
 {
 	print_output(output, "<%skbd>", end_tag ? "/" : "");
 }
 
 static void
 process_line_start(FILE* output, const u8* line, const u8* link_prefix,
 	const int first_line_in_doc, const int previous_line_blank,
 	int* previous_line_block, const int read_yaml_macros_and_links,
 	const int list_para, const int new_para_ok)
 {
 	UNUSED(line);
 	UNUSED(link_prefix);
 	if ((first_line_in_doc || previous_line_blank || *previous_line_block)
 		&& !(ANY(state, ST_BLOCKQUOTE | ST_PRE)))
 	{
 		if (!list_para)
 		{
 			if (IN(state, ST_LIST))
 			{
 				CLEAR(state, ST_LIST);
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output);
 					process_list_end(output);
 				}
 			}
 
 			if (IN(state, ST_NUMLIST))
 			{
 				CLEAR(state, ST_NUMLIST);
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output);
 					process_numlist_end(output);
 				}
 			}
 
 			if (IN(state, ST_FOOTNOTE_TEXT))
 				CLEAR(state, ST_FOOTNOTE_TEXT | ST_PARA_OPEN);
 		}
 		if (new_para_ok
 			&& !ANY(state,
 				ST_TABLE | ST_TABLE_HEADER | ST_TABLE_LINE))
 		{
 			if (!read_yaml_macros_and_links)
 			{
 				print_output(output, "<p>");
 				*previous_line_block = 0;
 				output_firstcol	     = 0;
 			}
 			SET(state, ST_PARA_OPEN);
 		}
 	}
 }
 
 static int
 process_link(FILE* output, const u8* link_text, const u8* link_prefix,
 	const u8* link_macro_body, const u8* link_id)
 {
 	u8* url = get_value(links, links_count, link_id, NULL);
 	return process_inline_link(output, link_text, link_prefix,
 		link_macro_body, url);
 }
 
 static void
 process_list_end(FILE* output)
 {
 	print_output(output, "</ul>\n");
 	output_firstcol = 1;
 }
 
 static void
 process_list_item_end(FILE* output)
 {
 	CLEAR(state, ST_PARA_OPEN);
 	print_output(output, "</li>");
 	output_firstcol = 0;
 }
 
 static void
 process_list_item_start(FILE* output)
 {
 	print_output(output, "%s<li><p>", output_firstcol ? "" : "\n");
 }
 
 static void
 process_list_start(FILE* output)
 {
 	print_output(output, "<ul>");
 }
 
 static int
 process_macro(FILE* output, const u8* token, const int end_tag)
 {
 	u8* macro_body;
 	u8* eol;
 	size_t macro_body_len;
 	UNUSED(end_tag);
 	assert((output != NULL) && (token != NULL));
 	macro_body = get_value(macros, macros_count, token + 1, NULL);
 	if (!macro_body)
 		exit(error(ERR_MACRO_UNDEF, __FILE__, __func__, __LINE__,
 			"Macro '%s' undefined", token + 1));
 
 	eol	       = (u8*)strrchr((char*)macro_body, '\n');
 	macro_body_len = strlen((char*)macro_body);
 	if (eol)
 		output_firstcol = macro_body + macro_body_len
 				- (u8*)strrchr((char*)macro_body, '\n')
 			> 0;
 	else
 		output_firstcol = !*macro_body
 			|| *(macro_body + macro_body_len - 1) == '\n';
 	print_output(output, "%s", macro_body);
 	return 0;
 }
 
 static int
 process_macro_def(FILE* output, const u8* token,
 	const int read_yaml_macros_and_links, const int end_tag)
 {
 	char* temp = NULL;
 	assert((output != NULL) && (token != NULL));
 	if (end_tag)
 	{
 		fflush(output);
 		CLEAR(state, ST_MACRO_BODY);
 		return 0;
 	}
 	if (IN(state, ST_MACRO_BODY))
 		exit(error(ERR_NEST_MACRO, __FILE__, __func__, __LINE__,
 			"Cannot nest definitions"));
 
 	if (read_yaml_macros_and_links)
 	{
 		macros_count++;
 		if (!macros)
 		{
 			CALLOC(macros, KeyValue, macros_count);
 			pmacros = macros;
 		}
 		else
 		{
 			REALLOC(macros, KeyValue,
 				macros_count * sizeof(KeyValue));
 			pmacros = macros + macros_count - 1;
 		}
 		CALLOC(pmacros->key, u8, KEYSIZE);
 		MEMCCPY(pmacros->key, (char*)token + 2, KEYSIZE, temp);
 		pmacros->value	    = NULL;
 		pmacros->value_size = 0;
 	}
 	fflush(output);
 	SET(state, ST_MACRO_BODY);
 	return 0;
 }
 
 static void
 process_madeby(FILE* output)
 {
 	print_output(output,
 		"<div id=\"made-by\"><p><small>\n"
 		"Generated by <a href=\"%s\">slweb</a>\n"
 		"© %s Strahinya Radich.\n"
 		"</small></div><!--made-by-->\n",
 		MADEBY_URL, COPYRIGHT_YEAR);
 }
 
 static void
 process_numlist_end(FILE* output)
 {
 	print_output(output, "</ol>\n");
 	output_firstcol = 1;
 }
 
 static void
 process_numlist_start(FILE* output)
 {
 	print_output(output, "<ol>");
 	output_firstcol = 0;
 }
 
 static void
 process_strike(FILE* output, const int end_tag)
 {
 	print_output(output, "<%ss>", end_tag ? "/" : "");
 }
 
 static void
 process_stylesheet(FILE* output, const u8* css_filename, int output_yaml)
 {
 	if (output_yaml)
 		print_output(output, "stylesheet: %s\n", css_filename);
 	else
 		print_output(output, "<link rel=\"stylesheet\" href=\"%s\">\n",
 			css_filename);
 	output_firstcol = 1;
 }
 
 static void
 process_table_body_cell(FILE* output)
 {
 	print_output(output, "</td><td>");
 }
 
 static void
 process_table_body_row_end(FILE* output)
 {
 	print_output(output, "</td></tr>\n");
 }
 
 static void
 process_table_body_row_start(FILE* output)
 {
 	print_output(output, "<tr><td>");
 }
 
 static void
 process_table_body_start(FILE* output, const int start_row)
 {
 	print_output(output, "<tbody>\n");
 	if (start_row)
 		print_output(output, "<tr><td>");
 }
 
 static void
 process_table_end(FILE* output)
 {
 	print_output(output, "</tbody>\n</table>\n");
 }
 
 static void
 process_table_header_cell(FILE* output)
 {
 	print_output(output, "</th><th>");
 }
 
 static void
 process_table_header_end(FILE* output)
 {
 	print_output(output, "</th></tr>\n</thead>\n");
 }
 
 static void
 process_table_start(FILE* output)
 {
 	print_output(output,
 		"<table>\n"
 		"<thead>\n<tr><th>");
 }
 
 static int
 process_tag(FILE* output, const u8* token, const char* source_filename,
 	const u8* link_prefix, const u8* footer_permalink_text,
 	const char* permalink_url, const int ext_in_permalink,
 	const int read_yaml_macros_and_links, int* skip_eol, const int end_tag)
 {
 	UNUSED(source_filename);
 	assert((output != NULL) && (token != NULL) && (source_filename != NULL)
 		&& (skip_eol != NULL));
 	if (!*token)
 		return warning(1, (u8*)"%s:%ld:%ld: Empty tag name",
 			input_filename, lineno, colno);
 	if (!strcmp((char*)token, "git-log")
 		&& !read_yaml_macros_and_links) /* {git-log} */
 	{
 		process_git_log(output);
 	}
 	else if (startswith((char*)token, "csv-count")) /* {csv-count} */
 		process_tsv_count(output, token, read_yaml_macros_and_links, 0);
 	else if (startswith((char*)token, "csv")) /* {csv} */
 		process_csv(output, token, read_yaml_macros_and_links, end_tag);
 	else if (startswith((char*)token, "tsv-count")) /* {tsv-count} */
 		process_tsv_count(output, token, read_yaml_macros_and_links, 1);
 	else if (startswith((char*)token, "tsv")) /* {tsv} */
 		process_tsv(output, token, read_yaml_macros_and_links, end_tag);
 	else if (startswith((char*)token, "include")) /* {include} */
 	{
 		process_include(output, token, read_yaml_macros_and_links);
 		*skip_eol = 1;
 	}
 	else if (startswith((char*)token, "incdir")) /* {incdir} */
 	{
 		process_incdir(output, token, link_prefix,
 			footer_permalink_text, permalink_url, ext_in_permalink,
 			read_yaml_macros_and_links);
 		*skip_eol = 1;
 	}
 	else if (*token == '=') /* {=macro} */
 	{
 		if (*(token + 1) == '!')
 			process_macro_def(output, token,
 				read_yaml_macros_and_links, end_tag);
 		else if ((*(token + 1) != '!') && !read_yaml_macros_and_links)
 			process_macro(output, token, end_tag);
 		*skip_eol = 1;
 	}
 	else if (!read_yaml_macros_and_links) /* general tags */
 	{
 		print_output(output, "<");
 		if (end_tag)
 			print_output(output, "/");
 
 		if (*token == '.' || *token == '#')
 		{
 			print_output(output, "div");
 		}
 
 		while (*token && *token != '#' && *token != '.')
 			print_output(output, "%c", *token++);
 
 		if (!end_tag)
 		{
 			if (*token == '#')
 			{
 				token++;
 				print_output(output, " id=\"");
 				while (*token && *token != '.')
 					print_output(output, "%c", *token++);
 				print_output(output, "\"");
 				if (*token == '.')
 				{
 					token++;
 					print_output(output, " class=\"");
 					while (*token)
 						print_output(output, "%c",
 							*token++);
 					print_output(output, "\"");
 				}
 			}
 			else if (*token == '.')
 			{
 				token++;
 				print_output(output, " class=\"");
 				while (*token && *token != '#')
 					print_output(output, "%c", *token++);
 				print_output(output, "\"");
 				if (*token == '#')
 				{
 					token++;
 					print_output(output, " id=\"");
 					while (*token)
 						print_output(output, "%c",
 							*token++);
 					print_output(output, "\"");
 				}
 			}
 		}
 		print_output(output, ">");
 		output_firstcol = 0;
 	}
 	return 0;
 }
 
 static void
 process_text_token(FILE* output, const u8* line, const u8* link_prefix,
 	const int first_line_in_doc, const int previous_line_blank,
 	int* previous_line_block, const int processed_start_of_line,
 	const int read_yaml_macros_and_links, const int list_para, u8** token,
 	u8** ptoken, size_t* token_size, const int add_enclosing_paragraph,
 	const int new_para_ok)
 {
 	u8* eol;
 	assert((token != NULL) && (ptoken != NULL));
 	if (!(IN(state, ST_YAML)))
 	{
 		if (add_enclosing_paragraph && !processed_start_of_line)
 			process_line_start(output, line, link_prefix,
 				first_line_in_doc, previous_line_blank,
 				previous_line_block, read_yaml_macros_and_links,
 				list_para, new_para_ok);
 		**ptoken = 0;
 		if (**token && !read_yaml_macros_and_links
 			&& !(IN(state, ST_MACRO_BODY)))
 		{
 			print_output(output, "%s", *token);
 			eol = (u8*)strrchr((char*)*token, '\n');
 			if (eol)
 				output_firstcol
 					= *token + strlen((char*)*token) > eol;
 			else
 				output_firstcol = 0;
 		}
 	}
 	RESET_TOKEN(*token, *ptoken, *token_size);
 }
 
 static void
 process_timestamp(FILE* output, const u8* link_prefix, const char* link,
 	const u8* permalink_macro, const u8* date, const int ext_in_permalink)
 {
 	u8* formatted_date = NULL;
 	char* in_filename  = NULL;
 	char* in_line	   = NULL;
 
 	assert((output != NULL) && (link != NULL));
 	formatted_date = format_date(date, article_timestamp_format);
 	if (!formatted_date)
 		goto process_timestamp_cleanup;
 	print_output(output,
 		"<a href=\"%s%s%s%s\""
 		" class=\"timestamp\">%s%s</a>\n",
 		url_is_local(link) && global_link_prefix
 			? (const char*)global_link_prefix
 			: "",
 		url_is_local(link) && link_prefix ? (const char*)link_prefix
 						  : "",
 		link, ext_in_permalink ? timestamp_output_ext : "",
 		permalink_macro ? (char*)permalink_macro : "", formatted_date);
 	output_firstcol = 1;
 
 process_timestamp_cleanup:
 	free(formatted_date);
 	free(in_line);
 	free(in_filename);
 }
 
 static void
 process_tsv(FILE* output, const u8* arg_token,
 	const int read_yaml_macros_and_links, const int end_tag)
 {
 	u8* saveptr   = NULL;
 	u8* args      = NULL;
 	u8* args_base = NULL;
 	size_t args_len;
 
 	assert((output != NULL) && (arg_token != NULL));
 	if (end_tag)
 	{
 		CLEAR(state, ST_TSV_BODY);
 		if (read_yaml_macros_and_links)
 			return;
 		read_tsv(output, tsv_filename, &print_tsv_row);
 		free(tsv_filename);
 		tsv_filename = NULL;
 		free(tsv_template);
 		tsv_template	  = NULL;
 		tsv_template_size = 0;
 	}
 	else
 	{
 		if (ANY(state, ST_CSV_BODY | ST_TSV_BODY))
 			exit(error(ERR_NEST_CSV, __FILE__, __func__, __LINE__,
 				"Can't nest csv/tsv directives"));
 		SET(state, ST_TSV_BODY);
 		if (read_yaml_macros_and_links)
 			return;
 		tsv_iter = 0;
 		(void)strtok_r((char*)arg_token, " ", (char**)&saveptr);
 		args = (u8*)strtok_r(NULL, " ", (char**)&saveptr);
 		if (!args)
 			exit(error(ERR_NO_ARG, __FILE__, __func__, __LINE__,
 				"Arguments required"));
 		args_len = strlen((char*)args);
 		if (*args != '"' || *(args + args_len - 1) != '"')
 			exit(error(ERR_ARG_NOTSTR, __FILE__, __func__, __LINE__,
 				"First argument must be a string"));
 		if (!tsv_filename)
 			CALLOC(tsv_filename, char, BUFSIZE);
 		args_base = (u8*)strdup((char*)args + 1);
 		*(args_base + strlen((char*)args_base) - 1) = 0;
 		snprintf(tsv_filename, BUFSIZE, "%s/%s.tsv", input_dirname,
 			(char*)args_base);
 		free(args_base);
 		args = (u8*)strtok_r(NULL, " ", (char**)&saveptr);
 		if (args)
 		{
 			errno	 = 0;
 			tsv_iter = (size_t)strtol((char*)args, NULL, 10);
 			if (errno)
 			{
 				perror(PROGRAMNAME ": strtol");
 				exit(error(errno, __FILE__, __func__, __LINE__,
 					"Invalid argument '%s'", args));
 			}
 		}
 	}
 }
 
 static void
 process_tsv_count(FILE* output, const u8* arg_token,
 	const int read_yaml_macros_and_links, const int is_tsv)
 {
 	FILE* tsv     = NULL;
 	u8* saveptr   = NULL;
 	u8* args      = NULL;
 	u8* args_base = NULL;
 	char* bufline = NULL;
 	char* eol     = NULL;
 	size_t args_len;
 	size_t tsv_lines = 0;
 
 	assert((output != NULL) && (arg_token != NULL));
 	if (read_yaml_macros_and_links)
 		return;
 	tsv_iter = 0;
 	(void)strtok_r((char*)arg_token, " ", (char**)&saveptr);
 	args = (u8*)strtok_r(NULL, " ", (char**)&saveptr);
 	if (!args)
 		exit(error(ERR_NO_ARG, __FILE__, __func__, __LINE__,
 			"Arguments required"));
 	args_len = strlen((char*)args);
 	if (*args != '"' || *(args + args_len - 1) != '"')
 		exit(error(ERR_ARG_NOTSTR, __FILE__, __func__, __LINE__,
 			"First argument must be a string"));
 	if (!tsv_filename)
 		CALLOC(tsv_filename, char, BUFSIZE);
 	args_base = (u8*)strdup((char*)args + 1);
 	*(args_base + strlen((char*)args_base) - 1) = 0;
 	snprintf(tsv_filename, BUFSIZE, "%s/%s.%csv", input_dirname,
 		(char*)args_base, is_tsv ? 't' : 'c');
 	free(args_base);
 	errno = 0;
 	if (!(tsv = fopen(tsv_filename, "rt")))
 	{
 		perror(PROGRAMNAME ": fopen");
 		exit(error(errno, __FILE__, __func__, __LINE__,
 			"fopen failed: %s", tsv_filename));
 	}
 	CALLOC(bufline, char, BUFSIZE);
 	while (!feof(tsv))
 	{
 		eol = NULL;
 		if (!fgets(bufline, BUFSIZE, tsv))
 			break;
 		eol = strchr(bufline, '\n');
 		if (eol)
 		{
 			*eol = 0;
 			tsv_lines++;
 		}
 	}
 	fclose(tsv);
 
 	/* And take back one kadam for the header row */
 	print_output(output, "%ld", tsv_lines - 1);
 
 	free(bufline);
 	free(tsv_filename);
 	tsv_filename = NULL;
 }
 
 static void
 read_csv(FILE* output, const char* filename, csv_callback_t callback)
 {
 	FILE* csv    = NULL;
 	u8* bufline  = NULL;
 	u8* pbufline = NULL;
 	u8* token    = NULL;
 	u8* ptoken   = NULL;
 	u8* csv_header[MAX_CSV_REGISTERS];
 	u8* csv_register[MAX_CSV_REGISTERS];
 	u8* csv_delimiter	       = NULL;
 	u8* eol			       = NULL;
 	char* temp		       = NULL;
 	size_t csv_lineno	       = 0;
 	size_t token_size	       = 0;
 	unsigned char csv_state	       = ST_CS_NONE;
 	unsigned char current_header   = 0;
 	unsigned char current_register = 0;
 	unsigned char i;
 
 	assert((output != NULL) && (filename != NULL) && (callback != NULL));
 	csv_delimiter = get_value(vars, vars_count, (u8*)"csv-delimiter", NULL);
 	errno	      = 0;
 	if (!(csv = fopen(filename, "rt")))
 	{
 		perror(PROGRAMNAME ": fopen");
 		exit(error(errno, __FILE__, __func__, __LINE__,
 			"fopen failed: %s", filename));
 	}
 	CALLOC(bufline, u8, BUFSIZE);
 	token_size = BUFSIZE;
 	CALLOC(token, u8, token_size);
 	for (i = 0; i < MAX_CSV_REGISTERS; i++)
 		CALLOC(csv_header[i], u8, BUFSIZE);
 	for (i = 0; i < MAX_CSV_REGISTERS; i++)
 		CALLOC(csv_register[i], u8, BUFSIZE);
 	while (!feof(csv) && (!csv_iter || csv_lineno <= csv_iter))
 	{
 		eol = NULL;
 		if (!fgets((char*)bufline, BUFSIZE, csv))
 			break;
 		eol = (u8*)strchr((char*)bufline, '\n');
 		if (eol)
 			*eol = 0;
 		pbufline = bufline;
 		RESET_TOKEN(token, ptoken, token_size);
 		current_register = 0;
 	csv_bufline_start:
 		if (!*pbufline)
 			goto csv_bufline_done;
 		switch (*pbufline)
 		{
 		case '"':
 			if (IN(csv_state, ST_CS_QUOTE))
 				csv_state &= ~ST_CS_QUOTE;
 			else
 				csv_state |= ST_CS_QUOTE;
 			pbufline++;
 			break;
 		case ';':
 		case ',':
 			if (IN(csv_state, ST_CS_QUOTE))
 				CHECKCOPY(token, ptoken, token_size, pbufline);
 			else
 			{
 				*ptoken = 0;
 				if (csv_lineno > 0
 					&& current_register < MAX_CSV_REGISTERS)
 				{
 					MEMCCPY(csv_register[current_register],
 						(char*)token, BUFSIZE, temp);
 					current_register++;
 				}
 				else if (csv_lineno <= 0
 					&& current_header < MAX_CSV_REGISTERS)
 				{
 					MEMCCPY(csv_header[current_header],
 						(char*)token, BUFSIZE, temp);
 					current_header++;
 				}
 				RESET_TOKEN(token, ptoken, token_size);
 				pbufline++;
 			}
 			break;
 		default:
 			if (IN(csv_state, ST_CS_QUOTE))
 				CHECKCOPY(token, ptoken, token_size, pbufline);
 			else if (csv_delimiter && *pbufline == *csv_delimiter)
 			{
 				*ptoken = 0;
 				if (csv_lineno > 0
 					&& current_register < MAX_CSV_REGISTERS)
 				{
 					MEMCCPY(csv_register[current_register],
 						(char*)token, BUFSIZE, temp);
 					current_register++;
 				}
 				else if (csv_lineno <= 0
 					&& current_header < MAX_CSV_REGISTERS)
 				{
 					MEMCCPY(csv_header[current_header],
 						(char*)token, BUFSIZE, temp);
 					current_header++;
 				}
 				RESET_TOKEN(token, ptoken, token_size);
 				pbufline++;
 			}
 			else
 				CHECKCOPY(token, ptoken, token_size, pbufline);
 		}
 		goto csv_bufline_start;
 	csv_bufline_done:
 		*ptoken = 0;
 		if (csv_lineno > 0)
 		{
 			if (current_register < MAX_CSV_REGISTERS)
 			{
 				MEMCCPY(csv_register[current_register],
 					(char*)token, BUFSIZE, temp);
 				current_register++;
 			}
 		}
 		else
 		{
 			if (current_header < MAX_CSV_REGISTERS)
 			{
 				MEMCCPY(csv_header[current_header],
 					(char*)token, BUFSIZE, temp);
 				current_header++;
 			}
 		}
 		RESET_TOKEN(token, ptoken, token_size);
 
 		if (csv_lineno > 0 && pbufline != bufline)
 			(*callback)(output, csv_header, csv_register);
 
 		for (i = 0; i < MAX_CSV_REGISTERS; i++)
 			*csv_register[i] = 0;
 		csv_lineno++;
 	}
 	fclose(csv);
 	for (i = MAX_CSV_REGISTERS; i > 0; i--)
 		free(csv_register[i - 1]);
 	for (i = MAX_CSV_REGISTERS; i > 0; i--)
 		free(csv_header[i - 1]);
 	free(token);
 	free(bufline);
 }
 
 static int
 read_file_into_buffer(FILE** input, u8** buffer, size_t* buffer_size,
 	const char* input_filename, char** input_dirname)
 {
 	struct stat fs;
 	char* slash = NULL;
 	char* pinput_dirname;
 	const char* pinput_filename;
 
 	assert((input != NULL) && (buffer != NULL) && (buffer_size != NULL)
 		&& (input_dirname != NULL));
 	errno  = 0;
 	*input = fopen(input_filename, "r");
 	if (!*input)
 	{
 		perror(PROGRAMNAME ": fopen");
 		return error(errno, __FILE__, __func__, __LINE__,
 			"fopen failed: %s", input_filename);
 	}
 
 	errno = 0;
 	fstat(fileno(*input), &fs);
 	if (S_ISDIR(fs.st_mode))
 		return error(EISDIR, __FILE__, __func__, __LINE__,
 			"Is a directory: %s", input_filename);
 
 	free(*buffer);
 	*buffer_size = fs.st_size + 1;
 	CALLOC(*buffer, u8, *buffer_size);
 	fread((void*)*buffer, 1, *buffer_size, *input);
 	free(*input_dirname);
 
 	slash = strrchr(input_filename, '/');
 	if (slash)
 	{
 		CALLOC(*input_dirname, char, strlen(input_filename) + 1);
 		pinput_dirname	= *input_dirname;
 		pinput_filename = input_filename;
 		while (pinput_filename && *pinput_filename
 			&& pinput_filename != slash)
 			*pinput_dirname++ = *pinput_filename++;
 	}
 	else
 	{
 		CALLOC(*input_dirname, char, 2);
 		**input_dirname = '.';
 	}
 	fclose(*input);
 
 	return 0;
 }
 
 static int
 read_tsv(FILE* output, const char* filename, tsv_callback_t callback)
 {
 	FILE* tsv = NULL;
 	u8* tsv_header[MAX_TSV_REGISTERS];
 	u8* tsv_register[MAX_TSV_REGISTERS];
 	u8* bufline		       = NULL;
 	u8* pbufline		       = NULL;
 	u8* token		       = NULL;
 	u8* ptoken		       = NULL;
 	u8* eol			       = NULL;
 	char* ctemp		       = NULL;
 	size_t tsv_lineno	       = 0;
 	size_t token_size	       = 0;
 	unsigned char current_header   = 0;
 	unsigned char current_register = 0;
 	unsigned char i;
 
 	assert((output != NULL) && (filename != NULL) && (callback != NULL));
 	errno = 0;
 	if (!(tsv = fopen(filename, "rt")))
 	{
 		perror(PROGRAMNAME ": fopen");
 		exit(error(errno, __FILE__, __func__, __LINE__,
 			"fopen failed: %s", filename));
 	}
 
 	CALLOC(bufline, u8, BUFSIZE);
 	token_size = BUFSIZE;
 	CALLOC(token, u8, token_size);
 	for (i = 0; i < MAX_TSV_REGISTERS; i++)
 		CALLOC(tsv_header[i], u8, BUFSIZE);
 	for (i = 0; i < MAX_TSV_REGISTERS; i++)
 		CALLOC(tsv_register[i], u8, BUFSIZE);
 
 	while (!feof(tsv) && (!tsv_iter || tsv_lineno <= tsv_iter))
 	{
 		eol = NULL;
 		if (!fgets((char*)bufline, BUFSIZE, tsv))
 			break;
 		eol = (u8*)strchr((char*)bufline, '\n');
 		if (eol)
 			*eol = 0;
 		pbufline = bufline;
 		RESET_TOKEN(token, ptoken, token_size);
 		current_register = 0;
 	tsv_bufline_start:
 		if (!*pbufline)
 			goto tsv_bufline_done;
 		switch (*pbufline)
 		{
 		case '\t':
 			*ptoken = 0;
 			if (tsv_lineno > 0
 				&& current_register < MAX_TSV_REGISTERS)
 			{
 				MEMCCPY(tsv_register[current_register],
 					(char*)token, BUFSIZE, ctemp);
 				current_register++;
 			}
 			else if (tsv_lineno <= 0
 				&& current_header < MAX_TSV_REGISTERS)
 			{
 				MEMCCPY(tsv_header[current_header],
 					(char*)token, BUFSIZE, ctemp);
 				current_header++;
 			}
 			RESET_TOKEN(token, ptoken, token_size);
 			pbufline++;
 			break;
 		default:
 			CHECKCOPY(token, ptoken, token_size, pbufline);
 		}
 		goto tsv_bufline_start;
 	tsv_bufline_done:
 		*ptoken = 0;
 		if (tsv_lineno > 0)
 		{
 			if (current_register < MAX_TSV_REGISTERS)
 			{
 				MEMCCPY(tsv_register[current_register],
 					(char*)token, BUFSIZE, ctemp);
 				current_register++;
 			}
 		}
 		else
 		{
 			if (current_header < MAX_TSV_REGISTERS)
 			{
 				MEMCCPY(tsv_header[current_header],
 					(char*)token, BUFSIZE, ctemp);
 				current_header++;
 			}
 		}
 		RESET_TOKEN(token, ptoken, token_size);
 
 		if (tsv_lineno > 0 && pbufline != bufline)
 			(*callback)(output, tsv_header, tsv_register);
 
 		for (i = 0; i < MAX_TSV_REGISTERS; i++)
 			*tsv_register[i] = 0;
 		tsv_lineno++;
 	}
 	fclose(tsv);
 	for (i = MAX_TSV_REGISTERS; i > 0; i--)
 		free(tsv_register[i - 1]);
 	for (i = MAX_TSV_REGISTERS; i > 0; i--)
 		free(tsv_header[i - 1]);
 	free(token);
 	free(bufline);
 
 	return 0;
 }
 
 static int
 reverse_alphacompare(const struct dirent** a, const struct dirent** b)
 {
 	assert((a != NULL) && (b != NULL));
 	return -1 * strcmp((*a)->d_name, (*b)->d_name);
 }
 
 static int
 set_basedir(char** basedir, size_t* basedir_size, const char* arg)
 {
 	size_t arg_len;
 	char* temp = NULL;
 	assert((basedir != NULL) && (*basedir != NULL) && (basedir_size != NULL)
 		&& (arg != NULL));
 	arg_len = strlen(arg);
 	ENSURE_SIZE(*basedir, temp, *basedir_size, (arg_len + 1), (arg_len + 1),
 		set_basedir_alloc_error, char);
 	MEMCCPY(*basedir, arg, *basedir_size, temp);
 	return 0;
 set_basedir_alloc_error:
 	exit(error(errno, __FILE__, __func__, __LINE__, "Allocation error"));
 	return 1;
 }
 
 static int
 set_global_link_prefix(char** global_link_prefix,
 	size_t* global_link_prefix_size, const char* arg)
 {
 	char* temp = NULL;
 	size_t arg_len;
 	assert((arg != NULL) && (global_link_prefix != NULL)
 		&& (*global_link_prefix != NULL)
 		&& (global_link_prefix_size != NULL));
 	arg_len = strlen(arg);
 	ENSURE_SIZE(*global_link_prefix, temp, *global_link_prefix_size,
 		(arg_len + 1), (arg_len + 1),
 		set_global_link_prefix_alloc_error, char);
 	MEMCCPY(*global_link_prefix, arg, *global_link_prefix_size, temp);
 	return 0;
 set_global_link_prefix_alloc_error:
 	exit(error(errno, __FILE__, __func__, __LINE__, "Allocation error"));
 	return 1;
 }
 
 static int
 simple_parse_yaml_line(const u8* line, KeyValue** vars, size_t* vars_count,
 	KeyValue** pvars)
 {
 	KeyValue* cvar	= NULL;
 	u8* token	= NULL;
 	u8* ptoken	= NULL;
 	u8* var_key	= NULL;
 	const u8* pline = line;
 	char* temp	= NULL;
 	int in_arg	= 0;
 	int found	= 0;
 
 	assert((line != NULL) && (vars != NULL) && (vars_count != NULL)
 		&& (pvars != NULL));
 	CALLOC(token, u8, BUFSIZE);
 	ptoken	= token;
 	*ptoken = 0;
 	while (*pline)
 	{
 		if (!in_arg && *pline == ':')
 		{
 			in_arg	= 1;
 			*ptoken = 0;
 			var_key = (u8*)strdup((char*)token);
 			if (!var_key)
 				exit(error(ENOMEM, __FILE__, __func__, __LINE__,
 					"strdup failed (out of "
 					"memory?)"));
 			ptoken	= token;
 			*ptoken = 0;
 			pline++;
 		}
 		else if (*pline == ' ' || *pline == '\t')
 			pline++;
 		else
 			*ptoken++ = *pline++;
 	}
 	if (*token)
 		*ptoken = 0;
 	if (var_key && *var_key && *token)
 	{
 		found = 0;
 		cvar  = *vars;
 		while (!found && cvar != *vars + *vars_count)
 		{
 			if (!strcmp((const char*)cvar->key, (const char*)var_key)
 				&& cvar->value_size
 				&& !strcmp((const char*)cvar->value,
 					(const char*)token))
 				found = 1;
 			cvar++;
 		}
 		if (!found)
 		{
 			(*vars_count)++;
 			if (!*vars)
 			{
 				CALLOC(*vars, KeyValue, *vars_count);
 				*pvars = *vars;
 			}
 			else
 			{
 				REALLOCARRAY(*vars, KeyValue, *vars_count);
 				*pvars = *vars + *vars_count - 1;
 			}
 			CALLOC((*pvars)->key, u8, KEYSIZE);
 			MEMCCPY((*pvars)->key, (char*)var_key, KEYSIZE, temp);
 			(*pvars)->value_size = strlen((char*)token) + 1;
 			CALLOC((*pvars)->value, u8, (*pvars)->value_size);
 			MEMCCPY((*pvars)->value, (char*)token,
 				(*pvars)->value_size, temp);
 		}
 	}
 	free(var_key);
 	free(token);
 	return 0;
 }
 
 static int
 startswith(const char* s, const char* what)
 {
 	assert((s != NULL) && (what != NULL));
 	do
 	{
 		if (*s++ != *what++)
 			return 0;
 	} while (*s && *what);
 	return !*what;
 }
 
 static char*
 strip_ext(const char* fn, const size_t fn_size)
 {
 	char* newname	= NULL;
 	char* pnewname	= NULL;
 	const char* pfn = NULL;
 	char* dot	= NULL;
 
 	assert(fn != NULL);
 	dot = strrchr(fn, '.');
 	if (!dot)
 		return NULL;
 	errno	= 0;
 	newname = strndup(fn, fn_size);
 	if (!newname)
 	{
 		perror(PROGRAMNAME ": strndup");
 		exit(error(errno, __FILE__, __func__, __LINE__,
 			"Allocation error"));
 	}
 	pnewname = newname;
 	pfn	 = fn;
 	while (pfn != dot && *pfn)
 		*pnewname++ = *pfn++;
 	*pnewname = 0;
 	return newname;
 }
 
 static int
 url_is_local(const char* url)
 {
 	return !(startswith(url, "http://") || startswith(url, "https://")
 		|| startswith(url, "gemini://") || startswith(url, "ftp://")
 		|| startswith(url, "ftps://") || startswith(url, "mailto://"));
 }
 
 static int
 usage(void)
 {
 	printf("Usage:\t%s -h | --help | -V | --full-version | -v | --version\n"
 	       "\t%s [-b | --body-only] [-d directory | --basedir directory]"
 	       " [-p URL | --global-link-prefix URL] [filename]\n",
 		PROGRAMNAME, PROGRAMNAME);
 	return 0;
 }
 
 static int
 version(const int full)
 {
 	printf("%s %s, committed on %s\n", PROGRAMNAME, VERSION, DATE);
 	if (full)
 		puts(COPYRIGHT);
 	return 0;
 }
 
 static int
 warning(const int code, const u8* fmt, ...)
 {
 	char buf[BUFSIZE];
 	va_list args;
 	va_start(args, fmt);
 	vsnprintf(buf, sizeof(buf), (const char*)fmt, args);
 	va_end(args);
 	fprintf(stderr, "Warning: %s\n", buf);
 	return code;
 }
 
 #define APPEND_TOKEN(what, what_len)                                       \
 	do                                                                 \
 	{                                                                  \
 		token_len = ptoken - token;                                \
 		ENSURE_SIZE(token, temp, token_size, token_len + what_len, \
 			token_len + what_len, parse_alloc_error, u8);      \
 		MEMCCPY((token + token_len), what, token_size - token_len, \
 			temp);                                             \
 		ptoken = temp ? temp - 1 : &token[token_size - 1];         \
 	} while (0)
 
 static int
 slweb_parse(FILE* output, const char* source_filename, const size_t sfn_size,
 	const u8* buffer, const int body_only,
 	const int read_yaml_macros_and_links)
 {
 	const u8* pbuffer	    = NULL;
 	u8* author		    = NULL;
 	u8* date		    = NULL;
 	u8* eol			    = NULL;
 	u8* ext_in_permalink	    = NULL;
 	u8* footer_permalink_text   = NULL;
 	u8* header_text		    = NULL;
 	u8* image_file_prefix	    = NULL;
 	u8* line		    = NULL;
 	u8* link_macro		    = NULL;
 	u8* link_prefix		    = NULL;
 	u8* link_text		    = NULL;
 	u8* permalink_url	    = NULL;
 	u8* pline		    = NULL;
 	u8* ptoken		    = NULL;
 	u8* temp		    = NULL;
 	u8* temp2		    = NULL;
 	u8* title		    = NULL;
 	u8* title_heading_level	    = NULL;
 	u8* token		    = NULL;
 	u8* var_add_article_header  = NULL;
 	u8* var_add_figcaption	    = NULL;
 	u8* var_add_footnote_div    = NULL;
 	u8* var_add_image_links	    = NULL;
 	u8* var_incdir_only_summary = NULL;
 	size_t entity_len	    = 0;
 	size_t heading_count	    = 0;
 	size_t line_len		    = 0;
 	size_t line_size	    = 0;
 	size_t link_size	    = 0;
 	size_t pline_len	    = 0;
 	size_t token_len	    = 0;
 	size_t token_size	    = 0;
 	size_t value_len	    = 0;
 	int add_figcaption	    = 1;
 	int add_footnote_div	    = 0;
 	int add_image_links	    = 1;
 	int break_mark		    = 0;
 	int end_tag		    = 0;
 	int first_line_in_doc	    = 1;
 	int footnote_at_line_start  = 0;
 	int keep_token		    = 0;
 	int list_para		    = 0;
 	int madeby_present	    = 0;
 	int previous_line_blank	    = 0;
 	int previous_line_block	    = 0;
 	int processed_start_of_line = 0;
 	int save_errno;
 	int skip_change_first_line_in_doc = 0;
 	int skip_eol			  = 0;
 	unsigned char heading_level	  = 0;
 
 	assert((output != NULL) && (buffer != NULL));
 	title = get_value(vars, vars_count, (u8*)"title", NULL);
 	title_heading_level
 		= get_value(vars, vars_count, (u8*)"title-heading-level", NULL);
 	header_text   = get_value(vars, vars_count, (u8*)"header-text", NULL);
 	author	      = get_value(vars, vars_count, (u8*)"author", NULL);
 	date	      = get_value(vars, vars_count, (u8*)"date", NULL);
 	permalink_url = get_value(vars, vars_count, (u8*)"permalink-url", NULL);
 	image_file_prefix
 		= get_value(vars, vars_count, (u8*)"image-file-prefix", NULL);
 	ext_in_permalink
 		= get_value(vars, vars_count, (u8*)"ext-in-permalink", NULL);
 	var_add_article_header
 		= get_value(vars, vars_count, (u8*)"add-article-header", NULL);
 	var_add_image_links
 		= get_value(vars, vars_count, (u8*)"add-image-links", NULL);
 	add_image_links = !(var_add_image_links && *var_add_image_links == '0');
 	var_add_figcaption
 		= get_value(vars, vars_count, (u8*)"add-figcaption", NULL);
 	add_figcaption = !(var_add_figcaption && *var_add_figcaption == '0');
 	var_add_footnote_div
 		= get_value(vars, vars_count, (u8*)"add-footnote-div", NULL);
 	add_footnote_div = var_add_footnote_div && *var_add_footnote_div == '1';
 	link_prefix = get_value(vars, vars_count, (u8*)"link-prefix", NULL);
 	footer_permalink_text = get_value(vars, vars_count,
 		(u8*)"incdir-footer-permalink-text", NULL);
 	var_incdir_only_summary
 		= get_value(vars, vars_count, (u8*)"incdir-only-summary", NULL);
 	incdir_only_summary
 		= var_incdir_only_summary && *var_incdir_only_summary == '1';
 
 	line_size = BUFSIZE;
 	CALLOC(line, u8, line_size);
 	token_size = BUFSIZE;
 	CALLOC(token, u8, BUFSIZE);
 	CALLOC(link_macro, u8, BUFSIZE);
 
 	pbuffer	   = buffer;
 	pvars	   = vars;
 	pmacros	   = macros;
 	plinks	   = links;
 	pfootnotes = footnotes;
 	lineno	   = 0;
 
 	if (!read_yaml_macros_and_links && !body_only)
 	{
 		begin_html_and_head(output);
 		add_css(output, 0);
 		end_head_start_body(output);
 	}
 
 	if (!read_yaml_macros_and_links)
 		begin_article(output, source_filename, sfn_size, link_prefix,
 			var_add_article_header && *var_add_article_header == '1',
 			author, title, header_text, (char*)title_heading_level,
 			date, ext_in_permalink && *ext_in_permalink != '0',
 			(char*)permalink_url);
 
 	RESET_TOKEN(token, ptoken, token_size);
 
 do_buffer:
 	eol = (u8*)strchr((char*)pbuffer, '\n');
 	if (!eol)
 		goto done_buffer;
 
 	pline = line;
 	while (pbuffer != eol)
 		CHECKCOPY(line, pline, line_size, pbuffer);
 
 	if (pbuffer == eol)
 		pbuffer++;
 
 	*pline	 = 0;
 	pline	 = line;
 	line_len = strlen((char*)line);
 
 	lineno++;
 	colno			= 1;
 	output_firstcol		= 1;
 	processed_start_of_line = 0;
 	skip_eol		= 0;
 	list_para		= 0;
 
 do_line:
 	if (!pline || !*pline)
 		goto done_line;
 	switch (*pline)
 	{
 	case '-':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_MACRO_BODY | ST_PRE | ST_YAML_VAL))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		else if (colno == 1 && strlen((char*)pline) > 2
 			&& startswith((char*)pline, "---"))
 		{
 			skip_eol = 1;
 
 			if (!(IN(state, ST_YAML)) && lineno > 1
 				&& !read_yaml_macros_and_links)
 				process_horizontal_rule(output);
 			else
 			{
 				if (lineno == 1)
 					SET(state, ST_YAML);
 				else
 					CLEAR(state, ST_YAML);
 
 				skip_change_first_line_in_doc = 1;
 			}
 			pline = NULL;
 		}
 		else if (colno == 1 && *(pline + 1) == ' ')
 		{
 			if (IN(state, ST_NUMLIST))
 			{
 				CLEAR(state, ST_NUMLIST);
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output);
 					process_numlist_end(output);
 				}
 			}
 			if (!read_yaml_macros_and_links)
 			{
 				if (!(IN(state, ST_LIST)))
 					process_list_start(output);
 				else
 					process_list_item_end(output);
 				process_list_item_start(output);
 				SET(state, ST_PARA_OPEN);
 			}
 
 			processed_start_of_line = 1;
 			skip_eol		= 0;
 
 			state |= ST_LIST;
 
 			pline += 2;
 			colno += 2;
 		}
 		else if (IN(state, ST_SUMMARY) && *(pline + 1) == '/')
 		{
 			/* Output existing text up to -/ */
 			process_text_token(output, line, link_prefix,
 				first_line_in_doc, previous_line_blank,
 				&previous_line_block, processed_start_of_line,
 				read_yaml_macros_and_links, list_para, &token,
 				&ptoken, &token_size, 1, 1);
 			processed_start_of_line = 1;
 
 			state &= ~(ST_SUMMARY | ST_PARA_OPEN);
 
 			pline += 2;
 			colno += 2;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case ':':
 		if (IN(state, ST_YAML)
 			&& !(ANY(state,
 				ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 					| ST_HEADING | ST_IMAGE | ST_MACRO_BODY
 					| ST_PRE | ST_TAG | ST_YAML_VAL))
 			&& read_yaml_macros_and_links)
 		{
 			*ptoken = 0;
 
 			vars_count++;
 
 			if (!vars)
 			{
 				CALLOC(vars, KeyValue, vars_count);
 				pvars = vars;
 			}
 			else
 			{
 				REALLOCARRAY(vars, KeyValue, vars_count);
 				pvars = vars + vars_count - 1;
 			}
 			CALLOC(pvars->key, u8, KEYSIZE);
 			MEMCCPY(pvars->key, (char*)token, KEYSIZE, temp);
 			pvars->value	  = NULL;
 			pvars->value_size = 0;
 
 			state |= ST_YAML_VAL;
 			RESET_TOKEN(token, ptoken, token_size);
 			pline++;
 			colno++;
 
 			while (pline && (*pline == ' ' || *pline == '\t'))
 			{
 				pline++;
 				colno++;
 			}
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case '~':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_HTML_TAG | ST_IMAGE | ST_KBD
 				    | ST_LINK_SECOND_ARG
 				    | ST_LINK_SECOND_ARG_END | ST_MACRO_BODY
 				    | ST_PRE | ST_TAG | ST_YAML))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (strlen((char*)pline) > 1 && *(pline + 1) == '~')
 		{
 			u8* entity = (u8*)"&nbsp;";
 			entity_len = strlen((char*)entity);
 			/* Handle ~~ within footnotes, headings and link
 			 * text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 				APPEND_TOKEN(entity, entity_len);
 			else
 			{
 				/* Output existing text up to ~~ */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 				processed_start_of_line = 1;
 
 				if (!read_yaml_macros_and_links
 					&& !(ANY(state,
 						ST_PRE | ST_CODE | ST_HEADING)))
 					print_output(output, (char*)entity);
 			}
 
 			pline += 2;
 			colno += 2;
 		}
 		else if (strlen((char*)pline) > 1 && *(pline + 1) == '!')
 		{
 			u8* entity = (u8*)"&#8203;";
 			entity_len = strlen((char*)entity);
 			/* Handle ~! within footnotes, headings and link
 			 * text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 				APPEND_TOKEN(entity, entity_len);
 			else
 			{
 				/* Output existing text up to ~! */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 				processed_start_of_line = 1;
 
 				if (!read_yaml_macros_and_links
 					&& !(ANY(state,
 						ST_PRE | ST_CODE | ST_HEADING)))
 					print_output(output, (char*)entity);
 			}
 
 			pline += 2;
 			colno += 2;
 		}
 		else if (strlen((char*)pline) > 1 && *(pline + 1) == '-')
 		{
 			u8* entity = (u8*)"&#8209;";
 			entity_len = strlen((char*)entity);
 			/* Handle ~- within footnotes, headings and link
 			 * text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 				APPEND_TOKEN(entity, entity_len);
 			else
 			{
 				/* Output existing text up to ~- */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 				processed_start_of_line = 1;
 
 				if (!read_yaml_macros_and_links
 					&& !(ANY(state,
 						ST_PRE | ST_CODE | ST_HEADING)))
 					print_output(output, (char*)entity);
 			}
 
 			pline += 2;
 			colno += 2;
 		}
 		else
 		{
 			/* Handle ~ within footnotes, headings and link
 			 * text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 				APPEND_TOKEN(IN(state, ST_STRIKE) ? "</s>"
 								  : "<s>",
 					sizeof(IN(state, ST_STRIKE) ? "</s>"
 								    : "<s>"));
 			else
 			{
 				/* Output existing text up to ~ */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 				processed_start_of_line = 1;
 
 				if (!read_yaml_macros_and_links
 					&& !(ANY(state,
 						ST_PRE | ST_CODE | ST_HEADING)))
 					process_strike(output,
 						(IN(state, ST_STRIKE)));
 			}
 
 			state ^= ST_STRIKE;
 			pline++;
 			colno++;
 		}
 		break;
 
 	case '`':
 		if (ANY(state,
 			    ST_DISPLAY_FORMULA | ST_FORMULA | ST_IMAGE
 				    | ST_MACRO_BODY))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (colno == 1 && strlen((char*)pline) > 2
 			&& startswith((char*)pline, "```"))
 		{
 			state ^= ST_PRE;
 
 			if (!read_yaml_macros_and_links)
 			{
 				if (IN(state, ST_PRE))
 				{
 					if (IN(state, ST_PARA_OPEN))
 						state &= ~ST_PARA_OPEN;
 					print_output(output, "<pre>");
 				}
 				else
 				{
 					print_output(output, "</pre>");
 					previous_line_block = 1;
 					/*if (IN(state, ST_PARA_OPEN))
 						print_output(output, "<p>");*/
 				}
 				output_firstcol = 0;
 			}
 
 			/* Skip the rest of the line (language) */
 			pline = NULL;
 		}
 		else if (!ANY(state, ST_PRE | ST_TAG | ST_YAML))
 		{
 			/* Handle ` within footnotes, headings and link
 			 * text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 				APPEND_TOKEN(IN(state, ST_CODE) ? "</code>"
 								: "<code>",
 					sizeof(IN(state, ST_CODE) ? "</code>"
 								  : "<code>"));
 			else
 			{
 				/* Output existing text up to ` */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 				processed_start_of_line = 1;
 
 				if (!read_yaml_macros_and_links
 					&& !(ANY(state, ST_PRE | ST_HEADING)))
 					process_code(output, IN(state, ST_CODE));
 			}
 
 			state ^= ST_CODE;
 
 			pline++;
 			colno++;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case '#':
 		if (colno == 1
 			&& !(ANY(state,
 				ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 					| ST_MACRO_BODY | ST_PRE | ST_YAML)))
 		{
 			if (IN(state, ST_LIST))
 			{
 				state &= ~ST_LIST;
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output);
 					process_list_end(output);
 				}
 			}
 
 			if (IN(state, ST_NUMLIST))
 			{
 				state &= ~ST_NUMLIST;
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output);
 					process_numlist_end(output);
 				}
 			}
 
 			state |= ST_HEADING;
 			heading_level = 1;
 			pline++;
 			colno++;
 		}
 		else if (IN(state, ST_HEADING) && *(pline - 1) == '#')
 		{
 			if (heading_level < MAX_HEADING_LEVEL)
 				heading_level++;
 			pline++;
 			colno++;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case '_':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_HTML_TAG | ST_IMAGE | ST_LINK_SECOND_ARG
 				    | ST_LINK_SECOND_ARG_END | ST_MACRO_BODY
 				    | ST_PRE | ST_TAG | ST_YAML))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (strlen((char*)pline) > 1 && *(pline + 1) == '_')
 		{
 			/* Handle __ within footnotes, headings and link
 			 * text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 				APPEND_TOKEN(IN(state, ST_BOLD) ? "</strong>"
 								: "<strong>",
 					sizeof(IN(state, ST_BOLD)
 							? "</strong>"
 							: "<strong>"));
 			else
 			{
 				/* Output existing text up to __ */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 				processed_start_of_line = 1;
 
 				if (!read_yaml_macros_and_links
 					&& !(ANY(state,
 						ST_PRE | ST_CODE | ST_HEADING)))
 					process_bold(output, IN(state, ST_BOLD));
 			}
 
 			state ^= ST_BOLD;
 			pline += 2;
 			colno += 2;
 		}
 		else
 		{
 			/* Handle _ within footnotes, headings and link
 			 * text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 				APPEND_TOKEN(IN(state, ST_ITALIC) ? "</em>"
 								  : "<em>",
 					sizeof(IN(state, ST_ITALIC) ? "</em>"
 								    : "<em>"));
 			else
 			{
 				/* Output existing text up to _ */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 				processed_start_of_line = 1;
 
 				if (!read_yaml_macros_and_links
 					&& !(ANY(state,
 						ST_PRE | ST_CODE | ST_HEADING)))
 					process_italic(output,
 						IN(state, ST_ITALIC));
 			}
 
 			state ^= ST_ITALIC;
 			pline++;
 			colno++;
 		}
 		break;
 
 	case 'o':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_HTML_TAG | ST_IMAGE | ST_MACRO_BODY
 				    | ST_PRE | ST_YAML))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (colno == 1 && strlen((char*)pline) > 1
 			&& *(pline + 1) == ' ')
 		{
 			if (IN(state, ST_NUMLIST))
 			{
 				state &= ~ST_NUMLIST;
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output);
 					process_numlist_end(output);
 				}
 			}
 			if (!read_yaml_macros_and_links)
 			{
 				if (!(IN(state, ST_LIST)))
 					process_list_start(output);
 				else
 					process_list_item_end(output);
 				process_list_item_start(output);
 				state |= ST_PARA_OPEN;
 			}
 
 			processed_start_of_line = 1;
 			skip_eol		= 0;
 
 			state |= ST_LIST;
 
 			pline += 2;
 			colno += 2;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case '*':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_HTML_TAG | ST_IMAGE | ST_MACRO_BODY
 				    | ST_PRE | ST_YAML))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		pline_len = strlen((char*)pline);
 		if (colno == 1 && pline_len > 1 && *(pline + 1) == '[')
 		{
 			process_line_start(output, line, link_prefix,
 				first_line_in_doc, previous_line_blank,
 				&previous_line_block,
 				read_yaml_macros_and_links, list_para, 1);
 
 			/* Ignore abbreviations (for now) */
 			pline = NULL;
 		}
 		else if (colno == 1 && pline_len > 2
 			&& startswith((char*)pline, "***"))
 		{
 			skip_eol = 1;
 			if (!read_yaml_macros_and_links)
 				process_horizontal_rule(output);
 			pline = NULL;
 		}
 		else if (colno == 1 && strlen((char*)pline) > 1
 			&& *(pline + 1) == ' ')
 		{
 			if (IN(state, ST_NUMLIST))
 			{
 				CLEAR(state, ST_NUMLIST);
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output);
 					process_numlist_end(output);
 				}
 			}
 			if (!read_yaml_macros_and_links)
 			{
 				if (!(IN(state, ST_LIST)))
 					process_list_start(output);
 				else
 					process_list_item_end(output);
 				process_list_item_start(output);
 				SET(state, ST_PARA_OPEN);
 			}
 
 			processed_start_of_line = 1;
 			skip_eol		= 0;
 			SET(state, ST_LIST);
 			pline += 2;
 			colno += 2;
 		}
 		else if (pline_len > 1 && *(pline + 1) == '*')
 		{
 			/* Handle ** within footnotes, headings and link
 			 * text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 				APPEND_TOKEN(IN(state, ST_BOLD) ? "</strong>"
 								: "<strong>",
 					sizeof(IN(state, ST_BOLD)
 							? "</strong>"
 							: "<strong>"));
 			else
 			{
 				/* Output existing text up to * */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 				processed_start_of_line = 1;
 
 				if (!read_yaml_macros_and_links
 					&& !(ANY(state,
 						ST_PRE | ST_CODE | ST_HEADING)))
 					process_bold(output, IN(state, ST_BOLD));
 			}
 			TOGGLE(state, ST_BOLD);
 			pline += 2;
 			colno += 2;
 		}
 		else
 		{
 			/* Handle * within footnotes, headings and link
 			 * text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 				APPEND_TOKEN(IN(state, ST_ITALIC) ? "</em>"
 								  : "<em>",
 					sizeof(IN(state, ST_ITALIC) ? "</em>"
 								    : "<em>"));
 			else
 			{
 				/* Output existing text up to * */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 				processed_start_of_line = 1;
 				if (!read_yaml_macros_and_links
 					&& !(ANY(state,
 						ST_PRE | ST_CODE | ST_HEADING)))
 					process_italic(output,
 						IN(state, ST_ITALIC));
 			}
 			TOGGLE(state, ST_ITALIC);
 			pline++;
 			colno++;
 		}
 		break;
 
 	case ' ':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA | ST_IMAGE
 				    | ST_MACRO_BODY | ST_PRE | ST_YAML_VAL))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if ((IN(state, ST_HEADING)) && !(IN(state, ST_HEADING_TEXT)))
 		{
 			if (!read_yaml_macros_and_links)
 			{
 				heading_count++;
 				process_heading_start(output, heading_level,
 					heading_count);
 				output_firstcol = 0;
 			}
 			SET(state, ST_HEADING_TEXT);
 			pline++;
 			colno++;
 			break;
 		}
 
 		if (colno == 1 && strlen((char*)pline) > 1
 			&& startswith((char*)pline, "  "))
 		{
 			list_para = 1;
 			process_text_token(output, line, link_prefix,
 				first_line_in_doc, previous_line_blank,
 				&previous_line_block, processed_start_of_line,
 				read_yaml_macros_and_links, list_para, &token,
 				&ptoken, &token_size, 1, 1);
 			processed_start_of_line = 1;
 			while (*pline == ' ' || *pline == '\t')
 			{
 				pline++;
 				colno++;
 			}
 			break;
 		}
 
 		if (strlen((char*)pline) == 2 && *(pline + 1) == ' ')
 		{
 			APPEND_TOKEN("<br>", sizeof("<br>"));
 			output_firstcol = 0;
 			pline += 2;
 			colno++;
 		}
 		else if (IN(state, ST_LINK_MACRO))
 		{
 			*ptoken = 0;
 			MEMCCPY(link_macro, (char*)token, BUFSIZE, temp);
 			*(link_macro + strlen((char*)token)) = 0;
 			RESET_TOKEN(token, ptoken, token_size);
 			CLEAR(state, ST_LINK_MACRO);
 		}
 		else if (!(IN(state, ST_HEADING) && *(pline - 1) == '#'))
 			CHECKCOPY(token, ptoken, token_size, pline);
 		colno++;
 		break;
 
 	case '{':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_HTML_TAG | ST_PRE | ST_YAML
 				    | ST_YAML_VAL))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (!IN(state, ST_MACRO_BODY))
 			goto parse_lbrace_not_macro;
 
 		*ptoken	  = 0;
 		token_len = strlen((char*)token);
 		skip_eol  = 1;
 		if (read_yaml_macros_and_links)
 		{
 			if (!macros)
 			{
 				macros_count = 1;
 				CALLOC(macros, KeyValue, macros_count);
 				pmacros = macros;
 			}
 			if (pmacros->value)
 			{
 				size_t value_len
 					= strlen((char*)pmacros->value);
 				if (pmacros->value_size
 					< value_len + token_len + 1)
 				{
 					pmacros->value_size += token_len;
 					REALLOC(pmacros->value, u8,
 						pmacros->value_size);
 				}
 				MEMCCPY((pmacros->value + value_len), token,
 					pmacros->value_size - value_len, temp);
 			}
 			else
 			{
 				pmacros->value_size = token_len + 1;
 				CALLOC(pmacros->value, u8, pmacros->value_size);
 				MEMCCPY(pmacros->value, (char*)token,
 					pmacros->value_size, temp);
 			}
 		}
 		goto parse_lbrace_end;
 
 	parse_lbrace_not_macro:
 		/* Output existing text up to { */
 		process_text_token(output, line, link_prefix, first_line_in_doc,
 			previous_line_blank, &previous_line_block,
 			processed_start_of_line, read_yaml_macros_and_links,
 			list_para, &token, &ptoken, &token_size, 0, 1);
 		processed_start_of_line = 1;
 
 	parse_lbrace_end:
 		SET(state, ST_TAG);
 		RESET_TOKEN(token, ptoken, token_size);
 		pline++;
 		colno++;
 		break;
 
 	case '/':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA | ST_IMAGE
 				    | ST_PRE | ST_HEADING | ST_YAML_VAL))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if ((IN(state, ST_TAG)) && pline != line && *(pline - 1) == '{')
 		{
 			end_tag = 1;
 			pline++;
 		}
 		else if (*(pline + 1) == '-')
 		{
 			/* Output existing text up to /- */
 			process_text_token(output, line, link_prefix,
 				first_line_in_doc, previous_line_blank,
 				&previous_line_block, processed_start_of_line,
 				read_yaml_macros_and_links, list_para, &token,
 				&ptoken, &token_size, 0, 0);
 			processed_start_of_line = 1;
 			SET(state, ST_SUMMARY);
 			if (!read_yaml_macros_and_links)
 			{
 				SET(state, ST_PARA_OPEN);
 				print_output(output, "<p>\n");
 				output_firstcol = 1;
 			}
 			pline += 2;
 			colno++;
 		}
 		else
 			CHECKCOPY(token, ptoken, token_size, pline);
 
 		colno++;
 		break;
 
 	case '}':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA | ST_IMAGE
 				    | ST_PRE | ST_YAML | ST_YAML_VAL))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		*ptoken = 0;
 		if (IN(state, ST_MACRO_BODY)
 			&& !(end_tag && startswith((const char*)token, "=")))
 		{
 			if (read_yaml_macros_and_links)
 			{
 				token_len = strlen((char*)token);
 				skip_eol  = 1;
 				value_len = strlen((char*)pmacros->value);
 				if (pmacros->value_size
 					< value_len + token_len + 4)
 				{
 					pmacros->value_size += token_len + 3;
 					REALLOC(pmacros->value, u8,
 						pmacros->value_size);
 				}
 				if ((size_t)snprintf((char*)pmacros->value,
 					    pmacros->value_size, "{%s%s}",
 					    end_tag ? "/" : "", (char*)token)
 					> pmacros->value_size)
 					warning(1, (u8*)"snprintf:%d: Overflow",
 						__LINE__);
 			}
 
 			*token = 0;
 			ptoken = token;
 			CLEAR(state, ST_TAG);
 			end_tag = 0;
 		}
 		else if (IN(state, ST_TAG))
 		{
 			CLEAR(state, ST_TAG);
 			if (break_mark)
 			{
 				CLEAR(state, ST_PARA_OPEN);
 				if (IN(state, ST_LIST))
 				{
 					CLEAR(state, ST_LIST);
 					if (!read_yaml_macros_and_links)
 					{
 						process_list_item_end(output);
 						process_list_end(output);
 					}
 				}
 				else if (IN(state, ST_NUMLIST))
 				{
 					CLEAR(state, ST_NUMLIST);
 					if (!read_yaml_macros_and_links)
 					{
 						process_list_item_end(output);
 						process_numlist_end(output);
 					}
 				}
 			}
 			if (!strcmp((char*)token, "made-by"))
 				madeby_present = 1;
 			else
 				process_tag(output, token, source_filename,
 					link_prefix, footer_permalink_text,
 					(const char*)permalink_url,
 					ext_in_permalink
 						&& *ext_in_permalink != '0',
 					read_yaml_macros_and_links, &skip_eol,
 					end_tag);
 
 			RESET_TOKEN(token, ptoken, token_size);
 			break_mark	    = 0;
 			end_tag		    = 0;
 			previous_line_block = 0;
 		}
 		pline++;
 		colno++;
 		break;
 
 	case '|':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_HTML_TAG | ST_IMAGE | ST_PRE | ST_TAG
 				    | ST_YAML))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (strlen((char*)pline) > 1 && *(pline + 1) == '|')
 		{
 			/* Handle || within footnotes, headings and link
 			 * text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 				APPEND_TOKEN(IN(state, ST_KBD) ? "</kbd>"
 							       : "<kbd>",
 					sizeof(IN(state, ST_KBD) ? "</kbd>"
 								 : "<kbd>"));
 			else
 			{
 				/* Output existing text up to || */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 				processed_start_of_line = 1;
 
 				if (!read_yaml_macros_and_links
 					&& !(ANY(state,
 						ST_PRE | ST_CODE | ST_HEADING)))
 				{
 					TOGGLE(state, ST_KBD);
 					process_kbd(output,
 						!(IN(state, ST_KBD)));
 					output_firstcol = 0;
 				}
 			}
 			pline += 2;
 			colno += 2;
 		}
 		/* Partial tables (for templating) */
 		else if (!(IN(state, ST_PRE)) && colno == 1
 			&& strlen((char*)pline) > 1 && *(pline + 1) == '@')
 		{
 			skip_eol = 1;
 			pline += 2;
 			colno += 2;
 			switch (*pline)
 			{
 			case '\\':
 				if (!read_yaml_macros_and_links)
 				{
 					process_table_start(output);
 					output_firstcol = 0;
 				}
 				pline = NULL;
 				break;
 
 			case '#':
 				SET(state, ST_TABLE_HEADER);
 				pline++;
 				colno++;
 				break;
 
 			case '-':
 				CLEAR(state, ST_TABLE_HEADER);
 				if (!read_yaml_macros_and_links)
 				{
 					process_table_body_start(output, 0);
 					output_firstcol = 1;
 				}
 				pline = NULL;
 				break;
 
 			case ' ':
 				SET(state, ST_TABLE);
 				if (!read_yaml_macros_and_links)
 				{
 					process_table_body_row_start(output);
 					output_firstcol = 0;
 				}
 				break;
 
 			case '/':
 				CLEAR(state, ST_TABLE);
 				if (!read_yaml_macros_and_links)
 				{
 					process_table_end(output);
 					output_firstcol = 1;
 				}
 				pline = NULL;
 				break;
 
 			default:
 				warning(1, (u8*)"Invalid partial table line");
 				CHECKCOPY(token, ptoken, token_size, pline);
 				colno++;
 			}
 		}
 		else if (!(IN(state, ST_PRE)) && colno == 1)
 		{
 			skip_eol = 1;
 			if (IN(state, ST_TABLE_HEADER))
 			{
 				CLEAR(state, ST_TABLE_HEADER);
 				SET(state, ST_TABLE_LINE);
 				pline = NULL;
 				break;
 			}
 
 			if (IN(state, ST_TABLE_LINE))
 			{
 				CLEAR(state, ST_TABLE_LINE);
 				SET(state, ST_TABLE);
 				if (!read_yaml_macros_and_links)
 				{
 					process_table_body_start(output, 1);
 					output_firstcol = 0;
 				}
 			}
 			else if (IN(state, ST_TABLE))
 			{
 				if (!read_yaml_macros_and_links)
 				{
 					process_table_body_row_start(output);
 					output_firstcol = 0;
 				}
 			}
 			else
 			{
 				SET(state, ST_TABLE_HEADER);
 				if (!read_yaml_macros_and_links)
 				{
 					process_table_start(output);
 					output_firstcol = 0;
 				}
 			}
 
 			pline++;
 			colno++;
 		}
 		else if (IN(state, ST_TABLE_HEADER))
 		{
 			*ptoken = 0;
 			if (!read_yaml_macros_and_links)
 			{
 				print_output(output, "%s", token);
 				if (*token)
 					output_firstcol = 0;
 				if (strlen((char*)pline) > 1)
 				{
 					process_table_header_cell(output);
 					output_firstcol = 0;
 				}
 				else
 				{
 					process_table_header_end(output);
 					output_firstcol = 1;
 				}
 			}
 			RESET_TOKEN(token, ptoken, token_size);
 			pline++;
 			colno++;
 		}
 		else if (IN(state, ST_TABLE))
 		{
 			*ptoken = 0;
 			if (!read_yaml_macros_and_links)
 			{
 				print_output(output, "%s", token);
 				if (*token)
 					output_firstcol = 0;
 				if (strlen((char*)pline) > 1)
 				{
 					process_table_body_cell(output);
 					output_firstcol = 0;
 				}
 				else
 				{
 					process_table_body_row_end(output);
 					output_firstcol = 1;
 				}
 			}
 			RESET_TOKEN(token, ptoken, token_size);
 			pline++;
 			colno++;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case '<':
 		if (read_yaml_macros_and_links
 			|| ANY(state,
 				ST_DISPLAY_FORMULA | ST_FORMULA | ST_IMAGE))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (ANY(state, ST_CODE | ST_KBD | ST_PRE))
 		{
 			APPEND_TOKEN("&lt;", sizeof("&lt;"));
 			pline++;
 			colno++;
 			break;
 		}
 		SET(state, ST_HTML_TAG);
 		CHECKCOPY(token, ptoken, token_size, pline);
 		colno++;
 		break;
 
 	case '>':
 		CLEAR(state, ST_HTML_TAG);
 		if (ANY(state,
 			    ST_DISPLAY_FORMULA | ST_FORMULA | ST_IMAGE
 				    | ST_MACRO_BODY))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (!read_yaml_macros_and_links
 			&& !ANY(state, ST_CODE | ST_HEADING | ST_PRE)
 			&& colno == 1)
 		{
 			if (!read_yaml_macros_and_links
 				&& !(IN(state, ST_BLOCKQUOTE)))
 			{
 				CLEAR(state, ST_PARA_OPEN);
 				process_blockquote(output, 0);
 				output_firstcol = 0;
 			}
 			SET(state, ST_BLOCKQUOTE);
 			pline++;
 			colno++;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case '!':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_FOOTNOTE_TEXT | ST_HEADING | ST_IMAGE
 				    | ST_INLINE_FOOTNOTE | ST_LINK
 				    | ST_MACRO_BODY | ST_PRE))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if ((IN(state, ST_TAG)) && pline != line
 			&& (*(pline - 1) == '{'
 				|| (end_tag && pline != line + 1
 					&& *(pline - 1) == '/'
 					&& *(pline - 2) == '{')))
 		{
 			break_mark = 1;
 			pline++;
 		}
 		else if (strlen((char*)pline) > 1 && *(pline + 1) == '[')
 		{
 			/* Output existing text up to ! */
 			*ptoken = 0;
 			process_text_token(output, line, link_prefix,
 				first_line_in_doc, previous_line_blank,
 				&previous_line_block, processed_start_of_line,
 				read_yaml_macros_and_links, list_para, &token,
 				&ptoken, &token_size, 0, 1);
 			processed_start_of_line = 1;
 			RESET_TOKEN(token, ptoken, token_size);
 			SET(state, ST_IMAGE);
 			keep_token = 1;
 			pline += 2;
 			colno += 2;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 
 		break;
 
 	case '=':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_MACRO_BODY | ST_PRE | ST_TAG))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (colno != 1 && *(pline - 1) == '[')
 		{
 			SET(state, ST_LINK_MACRO);
 			pline++;
 			colno++;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case '[':
 		pline_len = strlen((char*)pline);
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_HEADING | ST_IMAGE | ST_MACRO_BODY
 				    | ST_PRE))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (IN(state, ST_FOOTNOTE_TEXT))
 			CLEAR(state, ST_FOOTNOTE_TEXT | ST_PARA_OPEN);
 
 		if (pline_len > 1 && *(pline + 1) == '^')
 		{
 			footnote_at_line_start = colno == 1;
 			if (*token)
 			{
 				/* Output existing text up to [^ */
 				*ptoken = 0;
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 			}
 			processed_start_of_line = 1;
 
 			RESET_TOKEN(token, ptoken, token_size);
 			SET(state, ST_FOOTNOTE);
 			pline += 2;
 			colno += 2;
 			break;
 		}
 
 		if (*token)
 		{
 			/* Output existing text up to [ */
 			*ptoken = 0;
 			process_text_token(output, line, link_prefix,
 				first_line_in_doc, previous_line_blank,
 				&previous_line_block, processed_start_of_line,
 				read_yaml_macros_and_links, list_para, &token,
 				&ptoken, &token_size, 1, 1);
 		}
 		processed_start_of_line = 1;
 
 		RESET_TOKEN(token, ptoken, token_size);
 		SET(state, ST_LINK);
 		keep_token  = 1;
 		*link_macro = 0;
 		pline++;
 		colno++;
 
 		if (*pline == '(')
 		{
 			APPEND_TOKEN("<span>", sizeof("<span>"));
 			SET(state, ST_LINK_SPAN);
 			pline++;
 			colno++;
 		}
 
 		break;
 
 	case '(':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_FOOTNOTE_TEXT | ST_HEADING
 				    | ST_INLINE_FOOTNOTE | ST_LINK_SECOND_ARG_END
 				    | ST_MACRO_BODY | ST_PRE))
 			CHECKCOPY(token, ptoken, token_size, pline);
 		else if (*link_macro && (IN(state, ST_LINK)))
 		{
 			APPEND_TOKEN("<span>", sizeof("<span>"));
 			SET(state, ST_LINK_SPAN);
 			pline++;
 		}
 		else
 			CHECKCOPY(token, ptoken, token_size, pline);
 		colno++;
 		break;
 
 	case ')':
 		if (ANY(state,
 			    ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_LINK_SECOND_ARG_END))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		pline_len = strlen((char*)pline);
 
 		if (IN(state, ST_LINK_SPAN) && pline_len > 1
 			&& *(pline + 1) == ']')
 		{
 			APPEND_TOKEN("</span>", sizeof("</span>"));
 			CLEAR(state, ST_LINK_SPAN);
 			pline++;
 			colno++;
 		}
 		else if (ANY(state, ST_LINK_SECOND_ARG | ST_IMAGE_SECOND_ARG))
 		{
 			*ptoken = 0;
 			if (!read_yaml_macros_and_links)
 			{
 				if (IN(state, ST_LINK_SECOND_ARG))
 					process_inline_link(output, link_text,
 						link_prefix,
 						get_value(macros, macros_count,
 							link_macro, NULL),
 						token);
 				else
 				{
 					if (add_figcaption
 						&& IN(state, ST_PARA_OPEN))
 						CLEAR(state, ST_PARA_OPEN);
 					process_inline_image(output, link_text,
 						image_file_prefix, link_prefix,
 						token, add_image_links,
 						add_figcaption);
 					if (add_figcaption)
 						previous_line_block = 1;
 				}
 			}
 			RESET_TOKEN(token, ptoken, token_size);
 			CLEAR(state,
 				ST_LINK | ST_LINK_SECOND_ARG | ST_IMAGE
 					| ST_IMAGE_SECOND_ARG);
 			pline++;
 		}
 		else
 			CHECKCOPY(token, ptoken, token_size, pline);
 		colno++;
 		break;
 
 	case ']':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_HEADING | ST_MACRO_BODY | ST_PRE))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		*ptoken = 0;
 		if (IN(state, ST_INLINE_FOOTNOTE))
 		{
 			process_inline_footnote(token,
 				read_yaml_macros_and_links, output);
 			keep_token = 0;
 			RESET_TOKEN(token, ptoken, token_size);
 			CLEAR(state, ST_INLINE_FOOTNOTE);
 			pline++;
 			colno++;
 		}
 		else if (IN(state, ST_FOOTNOTE))
 		{
 			int footnote_definition = (strlen((char*)pline) > 1)
 				&& (*(pline + 1) == ':')
 				&& footnote_at_line_start;
 			process_footnote(output, token,
 				footnote_definition
 					&& read_yaml_macros_and_links,
 				!footnote_definition
 					&& !read_yaml_macros_and_links);
 			RESET_TOKEN(token, ptoken, token_size);
 			CLEAR(state, ST_FOOTNOTE);
 			footnote_at_line_start = 0;
 			pline++;
 			colno++;
 			if (footnote_definition)
 			{
 				pline++;
 				colno++;
 				while (*pline == ' ' || *pline == '\t')
 				{
 					pline++;
 					colno++;
 				}
 				SET(state, ST_FOOTNOTE_TEXT);
 			}
 		}
 		else if (IN(state, ST_LINK_SECOND_ARG))
 		{
 			if (!read_yaml_macros_and_links)
 				process_link(output, link_text, link_prefix,
 					get_value(macros, macros_count,
 						link_macro, NULL),
 					token);
 			RESET_TOKEN(token, ptoken, token_size);
 			CLEAR(state, ST_LINK | ST_LINK_SECOND_ARG);
 			pline++;
 			colno++;
 		}
 		else if (IN(state, ST_IMAGE_SECOND_ARG))
 		{
 			if (!read_yaml_macros_and_links)
 			{
 				if (add_figcaption && IN(state, ST_PARA_OPEN))
 					CLEAR(state, ST_PARA_OPEN);
 				process_image(output, link_text,
 					image_file_prefix, link_prefix, token,
 					add_image_links, add_figcaption);
 				if (add_figcaption)
 					previous_line_block = 1;
 			}
 			RESET_TOKEN(token, ptoken, token_size);
 			CLEAR(state, ST_IMAGE | ST_IMAGE_SECOND_ARG);
 			pline++;
 			colno++;
 		}
 		else if (strlen((char*)pline) > 1)
 		{
 			switch (*(pline + 1))
 			{
 			case ':':
 				process_line_start(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					read_yaml_macros_and_links, list_para,
 					0);
 
 				links_count++;
 
 				if (!links)
 				{
 					CALLOC(links, KeyValue, links_count);
 					plinks = links;
 				}
 				else
 				{
 					REALLOCARRAY(links, KeyValue,
 						links_count);
 					plinks = links + links_count - 1;
 				}
 				CALLOC(plinks->key, u8, KEYSIZE);
 				MEMCCPY(plinks->key, (char*)token, KEYSIZE,
 					temp);
 				plinks->value	   = NULL;
 				plinks->value_size = 0;
 				pline += 2;
 				colno += 2;
 				while (pline
 					&& (*pline == ' ' || *pline == '\t'))
 				{
 					pline++;
 					colno++;
 				}
 				RESET_TOKEN(token, ptoken, token_size);
 				keep_token = 0;
 				SET(state, ST_LINK_SECOND_ARG_END);
 				break;
 
 			case '[':
 			case '(':
 				token_len = strlen((char*)token);
 				if (link_text && token_len + 1 > link_size)
 				{
 					link_size = token_len + 1;
 					REALLOC(link_text, u8, link_size);
 				}
 				else if (!link_text)
 				{
 					link_size = token_len + 1;
 					CALLOC(link_text, u8, link_size);
 				}
 				MEMCCPY(link_text, (char*)token, link_size,
 					temp);
 				pline += 2;
 				colno += 2;
 				RESET_TOKEN(token, ptoken, token_size);
 				keep_token = 0;
 				if (IN(state, ST_LINK))
 					SET(state, ST_LINK_SECOND_ARG);
 				else
 					SET(state, ST_IMAGE_SECOND_ARG);
 				break;
 			default:
 				CHECKCOPY(token, ptoken, token_size, pline);
 				colno++;
 				CLEAR(state, ST_LINK | ST_IMAGE);
 				break;
 			}
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case '^':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_FOOTNOTE_TEXT | ST_IMAGE
 				    | ST_INLINE_FOOTNOTE | ST_PRE | ST_YAML))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (strlen((char*)pline) > 1 && *(pline + 1) == '[')
 		{
 			/* Output existing text up to ^[ */
 			*ptoken = 0;
 			process_text_token(output, line, link_prefix,
 				first_line_in_doc, previous_line_blank,
 				&previous_line_block, processed_start_of_line,
 				read_yaml_macros_and_links, list_para, &token,
 				&ptoken, &token_size, 1, 1);
 			processed_start_of_line = 1;
 			RESET_TOKEN(token, ptoken, token_size);
 			SET(state, ST_INLINE_FOOTNOTE);
 			keep_token = 1;
 			pline += 2;
 			colno += 2;
 			break;
 		}
 
 		CHECKCOPY(token, ptoken, token_size, pline);
 		colno++;
 		break;
 
 	case '\\':
 		*ptoken = 0;
 		if (ANY(state,
 			    ST_DISPLAY_FORMULA | ST_FORMULA | ST_HTML_TAG
 				    | ST_IMAGE | ST_LINK_SECOND_ARG
 				    | ST_LINK_SECOND_ARG_END | ST_MACRO_BODY))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (strlen((char*)pline) > 1)
 		{
 			pline++;
 			colno++;
 
 			CHECKCOPY(token, ptoken, token_size, pline);
 		}
 		else
 		{
 			pline = NULL;
 			break;
 		}
 
 		colno++;
 		break;
 
 	case '$':
 		if (ANY(state,
 			    ST_CODE | ST_CSV_BODY | ST_IMAGE | ST_PRE
 				    | ST_TSV_BODY | ST_YAML))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		if (strlen((char*)pline) > 1 && *(pline + 1) == '$')
 		{
 			if (IN(state, ST_FORMULA))
 				exit(error(ERR_NEST_MATH, __FILE__, __func__,
 					__LINE__,
 					"Display formula within an open "
 					"formula"));
 
 			if (!(IN(state, ST_DISPLAY_FORMULA)))
 			{
 				/* Output existing text up to $$ */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 			}
 			processed_start_of_line = 1;
 			TOGGLE(state, ST_DISPLAY_FORMULA);
 			if (IN(state, ST_DISPLAY_FORMULA))
 				keep_token = 1;
 			else
 			{
 				*ptoken = 0;
 				if (!read_yaml_macros_and_links)
 					process_formula(output, token, 1);
 				keep_token = 0;
 				RESET_TOKEN(token, ptoken, token_size);
 			}
 			pline += 2;
 			colno += 2;
 		}
 		else
 		{
 			if (IN(state, ST_DISPLAY_FORMULA))
 				exit(error(ERR_NEST_MATH, __FILE__, __func__,
 					__LINE__,
 					"Formula within an open display "
 					"formula"));
 			if (!(IN(state, ST_FORMULA)))
 			{
 				/* Output existing text up to $ */
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 			}
 			processed_start_of_line = 1;
 			TOGGLE(state, ST_FORMULA);
 			if (IN(state, ST_FORMULA))
 				keep_token = 1;
 			else
 			{
 				*ptoken = 0;
 				if (!read_yaml_macros_and_links)
 					process_formula(output, token, 0);
 				keep_token = 0;
 				RESET_TOKEN(token, ptoken, token_size);
 			}
 			pline++;
 			colno++;
 		}
 		break;
 
 	case '1': /* FALLTHROUGH */
 	case '2':
 	case '3':
 	case '4':
 	case '5':
 	case '6':
 	case '7':
 	case '8':
 	case '9':
 	case '0':
 		if (ANY(state,
 			    ST_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 				    | ST_MACRO_BODY | ST_PRE | ST_YAML_VAL))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		else if ((colno == 1 || all_numeric(line, pline))
 			&& strlen((char*)pline) > 1
 			&& (*(pline + 1) == '.' || *(pline + 1) == ')'))
 		{
 			ptoken	= token;
 			*ptoken = 0;
 			if (IN(state, ST_LIST))
 			{
 				CLEAR(state, ST_LIST);
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output);
 					process_list_end(output);
 				}
 			}
 			if (!read_yaml_macros_and_links)
 			{
 				if (!(IN(state, ST_NUMLIST)))
 					process_numlist_start(output);
 				else
 					process_list_item_end(output);
 				process_list_item_start(output);
 				SET(state, ST_PARA_OPEN);
 			}
 			processed_start_of_line = 1;
 			skip_eol		= 0;
 			SET(state, ST_NUMLIST);
 			pline += 2;
 			colno += 2;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case '"':
 		if (ANY(state, ST_CODE | ST_KBD | ST_PRE))
 		{
 			APPEND_TOKEN("&quot;", sizeof("&quot;"));
 			pline++;
 		}
 		else
 			CHECKCOPY(token, ptoken, token_size, pline);
 		colno++;
 
 		break;
 
 	case '&':
 		if (ANY(state, ST_CODE | ST_KBD | ST_PRE) || !*(pline + 1)
 			|| isspace(*(pline + 1)))
 		{
 			APPEND_TOKEN("&amp;", sizeof("&amp;"));
 			pline++;
 		}
 		else
 			CHECKCOPY(token, ptoken, token_size, pline);
 		colno++;
 
 		break;
 
 	default:
 		CHECKCOPY(token, ptoken, token_size, pline);
 		colno++;
 	}
 	goto do_line;
 
 done_line:
 	*ptoken = 0;
 
 	if (*token && read_yaml_macros_and_links && (IN(state, ST_YAML_VAL)))
 	{
 		*ptoken = 0;
 		if (!vars)
 		{
 			vars_count = 1;
 			CALLOC(vars, KeyValue, vars_count);
 			pvars = vars;
 		}
 		pvars->value_size = strlen((char*)token) + 1;
 		CALLOC(pvars->value, u8, pvars->value_size);
 		MEMCCPY(pvars->value, (char*)token, pvars->value_size, temp);
 	}
 	else if (keep_token)
 		APPEND_TOKEN(ANY(state, ST_IMAGE | ST_LINK) ? " " : "\n", 1);
 	else
 	{
 		if (*token)
 		{
 			*ptoken	  = 0;
 			token_len = strlen((char*)token);
 			if (IN(state, ST_MACRO_BODY))
 			{
 				skip_eol = 1;
 				if (!read_yaml_macros_and_links)
 					goto skip_macro_read;
 				if (!macros)
 				{
 					macros_count = 1;
 					CALLOC(macros, KeyValue, macros_count);
 					pmacros = macros;
 				}
 				if (pmacros->value)
 				{
 					size_t value_len
 						= strlen((char*)pmacros->value);
 
 					if (pmacros->value_size
 						< value_len + token_len + 1)
 					{
 						pmacros->value_size += BUFSIZE;
 						REALLOC(pmacros->value, u8,
 							pmacros->value_size);
 					}
 					MEMCCPY((pmacros->value + value_len),
 						token,
 						pmacros->value_size - value_len,
 						temp);
 					value_len += token_len;
 					if (temp)
 						MEMCCPY_EXT((temp - 1),
 							pmacros->value, "\n",
 							pmacros->value_size
 								- value_len,
 							temp2);
 				}
 				else
 				{
 					pmacros->value_size = BUFSIZE;
 					CALLOC(pmacros->value, u8,
 						pmacros->value_size);
 					MEMCCPY(pmacros->value, (char*)token,
 						pmacros->value_size, temp);
 					if (!temp)
 						goto skip_macro_cat;
 					MEMCCPY_EXT((temp - 1), pmacros->value,
 						"\n",
 						pmacros->value_size
 							- ((u8*)temp
 								- pmacros->value),
 						temp2);
 				skip_macro_cat:;
 				}
 			skip_macro_read:;
 			}
 			else if (IN(state, ST_FOOTNOTE_TEXT))
 			{
 				skip_eol = 1;
 				if (!read_yaml_macros_and_links)
 					goto skip_footnote_read;
 				if (!footnotes)
 				{
 					footnote_count = 1;
 					CALLOC(footnotes, KeyValue,
 						footnote_count);
 					pfootnotes = footnotes;
 				}
 				if (pfootnotes->value)
 				{
 					size_t value_len = strlen(
 						(char*)pfootnotes->value);
 					if (pfootnotes->value_size
 						< value_len + token_len + 1)
 					{
 						pfootnotes->value_size
 							+= BUFSIZE;
 						REALLOC(pfootnotes->value, u8,
 							pfootnotes->value_size);
 					}
 					MEMCCPY((pfootnotes->value + value_len),
 						token,
 						pfootnotes->value_size
 							- value_len,
 						temp);
 					if (temp)
 						MEMCCPY_EXT((temp - 1),
 							(pfootnotes->value
 								+ value_len),
 							"\n",
 							pfootnotes->value_size
 								- value_len,
 							temp2);
 				}
 				else
 				{
 					pfootnotes->value_size = BUFSIZE;
 					CALLOC(pfootnotes->value, u8,
 						pfootnotes->value_size);
 					MEMCCPY(pfootnotes->value, token,
 						pfootnotes->value_size, temp);
 					if (temp)
 						MEMCCPY_EXT((temp - 1),
 							(pfootnotes->value
 								+ value_len),
 							"\n",
 							pfootnotes->value_size
 								- value_len,
 							temp2);
 				}
 				*token = 0;
 				ptoken = token;
 			skip_footnote_read:;
 			}
 			else if (ANY(state,
 					 ST_LINK_SECOND_ARG
 						 | ST_LINK_SECOND_ARG_END))
 			{
 				if (read_yaml_macros_and_links)
 				{
 					if (!links)
 					{
 						links_count = 1;
 						CALLOC(links, KeyValue,
 							links_count);
 						plinks = links;
 					}
 					plinks->value_size
 						= strlen((char*)token) + 1;
 					CALLOC(plinks->value, u8,
 						plinks->value_size);
 					MEMCCPY(plinks->value, (char*)token,
 						plinks->value_size, temp);
 				}
 			}
 			else if (IN(state, ST_HEADING))
 			{
 				CLEAR(state, ST_HEADING | ST_HEADING_TEXT);
 				if (!read_yaml_macros_and_links)
 				{
 					process_heading(output, token,
 						heading_level);
 					output_firstcol = 0;
 				}
 				first_line_in_doc = 0;
 				RESET_TOKEN(token, ptoken, token_size);
 				heading_level = 0;
 			}
 			else if (!ANY(state,
 					 ST_DISPLAY_FORMULA | ST_FORMULA
 						 | ST_IMAGE | ST_LINK))
 				process_text_token(output, line, link_prefix,
 					first_line_in_doc, previous_line_blank,
 					&previous_line_block,
 					processed_start_of_line,
 					read_yaml_macros_and_links, list_para,
 					&token, &ptoken, &token_size, 1, 1);
 		}
 
 		if (!ANY(state,
 			    ST_PRE | ST_IMAGE_SECOND_ARG | ST_LINK_SECOND_ARG
 				    | ST_LINK_SECOND_ARG_END)
 			&& (!*pbuffer || *pbuffer == '\n'))
 		{
 			if (IN(state, ST_PARA_OPEN))
 			{
 				if (IN(state, ST_LIST))
 					skip_eol = 1;
 				CLEAR(state, ST_PARA_OPEN);
 			}
 
 			if (!*pbuffer && (IN(state, ST_LIST)))
 			{
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output);
 					process_list_end(output);
 				}
 				CLEAR(state, ST_LIST);
 			}
 
 			if (!*pbuffer && (IN(state, ST_NUMLIST)))
 			{
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output);
 					process_numlist_end(output);
 				}
 				CLEAR(state, ST_NUMLIST);
 			}
 
 			if (!*pbuffer && (IN(state, ST_FOOTNOTE_TEXT)))
 			{
 				CLEAR(state, ST_FOOTNOTE_TEXT);
 				*ptoken	  = 0;
 				token_len = strlen((char*)token);
 				skip_eol  = 1;
 				if (!read_yaml_macros_and_links)
 					goto skip_footnote_text_read;
 				if (!footnotes)
 				{
 					footnote_count = 1;
 					CALLOC(footnotes, KeyValue,
 						footnote_count);
 					pfootnotes = footnotes;
 				}
 				if (pfootnotes->value)
 				{
 					size_t value_len = strlen(
 						(char*)pfootnotes->value);
 					if (pfootnotes->value_size
 						< value_len + token_len + 1)
 					{
 						pfootnotes->value_size
 							= value_len + token_len
 							+ 1;
 						REALLOC(pfootnotes->value, u8,
 							pfootnotes->value_size);
 					}
 					MEMCCPY((pfootnotes->value + value_len),
 						token,
 						pfootnotes->value_size
 							- value_len,
 						temp);
 				}
 				else
 				{
 					pfootnotes->value_size = token_len + 1;
 					CALLOC(pfootnotes->value, u8,
 						pfootnotes->value_size);
 					MEMCCPY(pfootnotes->value, (char*)token,
 						pfootnotes->value_size, temp);
 				}
 				*token = 0;
 				ptoken = token;
 			skip_footnote_text_read:;
 			}
 		}
 
 		if (IN(state, ST_BLOCKQUOTE) && (!*pbuffer || *pbuffer != '>'))
 		{
 			CLEAR(state, ST_BLOCKQUOTE);
 			if (!read_yaml_macros_and_links)
 			{
 				process_blockquote(output, 1);
 				previous_line_block = 1;
 				output_firstcol	    = 0;
 			}
 		}
 
 		if (ANY(state, ST_TABLE_HEADER | ST_TABLE_LINE)
 			&& (!line_len || !*pbuffer))
 		{
 			if (!read_yaml_macros_and_links)
 			{
 				warning(1, (u8*)"Malformed table");
 				process_table_end(output);
 				output_firstcol = 1;
 			}
 			CLEAR(state, ST_TABLE_HEADER | ST_TABLE_LINE);
 		}
 
 		if ((IN(state, ST_TABLE)) && (!line_len || !*pbuffer))
 		{
 			if (!read_yaml_macros_and_links)
 			{
 				process_table_end(output);
 				output_firstcol = 1;
 			}
 			CLEAR(state, ST_TABLE);
 		}
 
 		previous_line_blank = 0;
 	}
 
 	if (!skip_eol && !keep_token && !read_yaml_macros_and_links
 		&& !ANY(state,
 			ST_YAML | ST_YAML_VAL | ST_LINK_SECOND_ARG
 				| ST_LINK_SECOND_ARG_END))
 	{
 		print_output(output, "\n");
 		output_firstcol = 1;
 	}
 
 	if (!keep_token)
 		RESET_TOKEN(token, ptoken, token_size);
 
 	if (!skip_change_first_line_in_doc && !(IN(state, ST_YAML)))
 		first_line_in_doc = 0;
 
 	skip_change_first_line_in_doc = 0;
 	if (line_len == 0)
 		previous_line_blank = 1;
 
 	/* Lasts until the end of line */
 	CLEAR(state,
 		ST_YAML_VAL | ST_IMAGE_SECOND_ARG | ST_LINK_SECOND_ARG
 			| ST_LINK_SECOND_ARG_END);
 
 	if (pbuffer && *pbuffer)
 		goto do_buffer;
 done_buffer:
 	if (!read_yaml_macros_and_links)
 	{
 		if ((footnote_count > 0) || (inline_footnote_count > 0))
 			end_footnotes(output, add_footnote_div);
 
 		if (madeby_present)
 		{
 			process_madeby(output);
 			output_firstcol = 1;
 		}
 
 		if (!body_only)
 			end_body_and_html(output);
 	}
 
 	free(link_text);
 	free(link_macro);
 	free(token);
 	free(line);
 	return ERR_NONE;
 
 parse_alloc_error:
 	save_errno = errno;
 	free(link_text);
 	free(link_macro);
 	free(token);
 	free(line);
 	return save_errno;
 }
 
 int
 main(const int argc, const char** argv)
 {
 	FILE* input  = NULL;
 	FILE* output = stdout;
 	u8* buffer   = NULL;
 	u8* eol	     = NULL;
 	const char* arg;
 	char* temp	   = NULL;
 	Command cmd	   = CMD_NONE;
 	size_t buffer_size = 0;
 	int body_only	   = 0;
 	int result	   = ERR_NONE;
 
 	UNUSED(argc);
 	basedir_size = 2;
 	CALLOC(basedir, char, basedir_size);
 	*basedir = '.';
 
 	while ((arg = *++argv))
 	{
 		if (*arg == '-')
 		{
 			char c;
 			arg++;
 			c = *arg++;
 
 			if (c == '-')
 			{
 				if (!strcmp(arg, "full-version"))
 					cmd = CMD_FULL_VERSION;
 				else if (!strcmp(arg, "version"))
 					cmd = CMD_VERSION;
 
 				else if (!strcmp(arg, "body-only"))
 					body_only = 1;
 				else if (startswith(arg, "basedir"))
 				{
 					arg += strlen("basedir");
 					result = set_basedir(&basedir,
 						&basedir_size, arg);
 					if (result)
 						exit(result);
 				}
 				else if (startswith(arg, "global-link-prefix"))
 				{
 					arg += strlen("global-link-prefix");
 					result = set_global_link_prefix(
 						&global_link_prefix,
 						&global_link_prefix_size, arg);
 					if (result)
 						exit(result);
 				}
 				else if (!strcmp(arg, "help"))
 					exit(usage());
 				else
 				{
 					usage();
 					exit(error(ERR_BAD_CL_ARG, __FILE__,
 						__func__, __LINE__,
 						"Invalid argument: --%s", arg));
 				}
 			}
 			else
 			{
 				switch (c)
 				{
 				case 'b':
 					body_only = 1;
 					break;
 				case 'd':
 					cmd = CMD_BASEDIR;
 					break;
 				case 'h':
 					exit(usage());
 					break;
 				case 'p':
 					cmd = CMD_LINK_PREFIX;
 					break;
 				case 'V':
 					cmd = CMD_FULL_VERSION;
 					break;
 				case 'v':
 					cmd = CMD_VERSION;
 					break;
 				default:
 					usage();
 					return error(ERR_BAD_CL_ARG, __FILE__,
 						__func__, __LINE__,
 						"Invalid argument: -%c", c);
 				}
 			}
 		}
 		else
 		{
 			switch (cmd)
 			{
 			case CMD_BASEDIR:
 				result = set_basedir(&basedir, &basedir_size,
 					arg);
 				if (result)
 					exit(result);
 				break;
 			case CMD_LINK_PREFIX:
 				result = set_global_link_prefix(&global_link_prefix,
 					&global_link_prefix_size, arg);
 				if (result)
 					exit(result);
 				break;
 			default:
 				ifn_size = BUFSIZE;
 				CALLOC(input_filename, char, ifn_size);
 				MEMCCPY(input_filename, arg, ifn_size, temp);
 			}
 			cmd = CMD_NONE;
 		}
 	}
 
 	switch (cmd)
 	{
 	case CMD_BASEDIR:
 		exit(error(ERR_NO_ARG, __FILE__, __func__, __LINE__,
 			"Argument required"));
 	case CMD_FULL_VERSION:
 		version(1);
 		exit(0);
 	case CMD_VERSION:
 		version(0);
 		exit(0);
 	default:;
 	}
 
 	if (input_filename)
 	{
 		result = read_file_into_buffer(&input, &buffer, &buffer_size,
 			input_filename, &input_dirname);
 		if (result)
 			exit(result);
 	}
 	else
 	{
 		u8* bufline	    = NULL;
 		u8* pbufline	    = NULL;
 		size_t buffer_len   = 0;
 		size_t buffer_size  = 0;
 		size_t bufline_len  = 0;
 		size_t bufline_size = 0;
 
 		input = stdin;
 
 		CALLOC(input_dirname, char, 2);
 		*input_dirname = '.';
 
 		bufline_size = BUFSIZE;
 		CALLOC(bufline, u8, bufline_size);
 		buffer_size = BUFSIZE;
 		CALLOC(buffer, u8, buffer_size); /* freed in slweb_cleanup */
 		pbufline = bufline;
 
 	do_input:
 		if (feof(input))
 			goto done_input;
 
 		if (!fgets((char*)pbufline, bufline_size - (pbufline - bufline),
 			    input))
 			goto done_input;
 
 		eol = (u8*)strchr((char*)pbufline, '\n');
 		if (eol)
 			*(eol + 1) = 0; /* slweb_parse will look for newline */
 		else
 		{
 			bufline_size += BUFSIZE;
 			REALLOC(bufline, u8, bufline_size);
 			pbufline = bufline + bufline_size - BUFSIZE - 1;
 			goto do_input;
 		}
 
 		/* bufline is done, add it to buffer */
 		bufline_len = strlen((char*)bufline);
 		if (buffer_len + bufline_len + 1 > buffer_size)
 		{
 			buffer_size += BUFSIZE;
 			REALLOC(buffer, u8, buffer_size);
 		}
 
 		MEMCCPY((buffer + buffer_len), bufline,
 			buffer_size - buffer_len, temp);
 		buffer_len += bufline_len;
 		goto do_input;
 
 	done_input:
 		free(bufline);
 	}
 
 	vars		      = NULL;
 	vars_count	      = 0;
 	macros		      = NULL;
 	macros_count	      = 0;
 	links		      = NULL;
 	links_count	      = 0;
 	footnotes	      = NULL;
 	footnote_count	      = 0;
 	inline_footnotes      = NULL;
 	inline_footnote_count = 0;
 
 	/* First pass: read YAML, macros and links */
 	if ((result = slweb_parse(output, input_filename, ifn_size, buffer,
 		     body_only, 1)))
 		goto slweb_cleanup;
 
 	state			= ST_NONE;
 	current_footnote	= 0;
 	current_inline_footnote = 0;
 
 	/* Second pass: parse and output */
 	if ((result = slweb_parse(output, input_filename, ifn_size, buffer,
 		     body_only, 0)))
 		goto slweb_cleanup;
 
 slweb_cleanup:
 	cleanup();
 	free(buffer);
 	return result;
 }