slw2gmi

slw2gmi.c (122510B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2021-2024  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 
 #include "defs.h"
 
 static size_t lineno		      = 0;
 static size_t colno		      = 1;
 static int output_firstcol	      = 1;
 static int skip_para_end	      = 0;
 static const char* input_filename     = NULL;
 static char* input_dirname	      = NULL;
 static char* basedir		      = NULL;
 static size_t basedir_size	      = 0;
 static char* incdir		      = NULL;
 static char* global_link_prefix	      = NULL;
 static size_t global_link_prefix_size = 0;
 static KeyValue* vars		      = NULL;
 static KeyValue* pvars		      = NULL;
 static size_t vars_count	      = 0;
 static KeyValue* macros		      = NULL;
 static KeyValue* pmacros	      = NULL;
 static size_t macros_count	      = 0;
 static KeyValue* links		      = NULL;
 static KeyValue* plinks		      = NULL;
 static size_t links_count	      = 0;
 static KeyValue* paralinks	      = NULL;
 static KeyValue* pparalinks	      = NULL;
 static size_t paralinks_count	      = 0;
 static KeyValue* footnotes	      = NULL;
 static KeyValue* pfootnotes	      = NULL;
 static size_t footnote_count	      = 0;
 static size_t current_footnote	      = 0;
 static u8** inline_footnotes	      = NULL;
 static size_t inline_footnote_count   = 0;
 static size_t current_inline_footnote = 0;
 static u8* csv_template		      = NULL;
 static size_t csv_template_size	      = 0;
 static char* csv_filename	      = NULL;
 static long csv_iter		      = 0;
 static u8* tsv_template		      = NULL;
 static size_t tsv_template_size	      = 0;
 static char* tsv_filename	      = NULL;
 static long tsv_iter		      = 0;
 static ULLONG state		      = ST_NONE;
 static int incdir_only_summary	      = 0;
 
 #define COPYRIGHT                                                            \
 	("  This program is licensed under the terms of GNU GPL v3"          \
 	 " or (at your option)\n"                                            \
 	 "  any later version. Copyright (C) 2021-2024  Strahinya Radich.\n" \
 	 "  See the file LICENSE for exact copyright and license "           \
 	 "details.")
 
 #define CHECKEXITNOMEM(ptr, func)                                             \
 	do                                                                    \
 	{                                                                     \
 		if (!ptr)                                                     \
 			exit(error(ENOMEM,                                    \
 				(u8*)"" #func                                 \
 				     ":%d: Memory allocation failed (out of " \
 				     "memory?)",                              \
 				__LINE__));                                   \
 	} while (0)
 
 #define CALLOC(ptr, ptrtype, nmemb)                   \
 	do                                            \
 	{                                             \
 		ptr = calloc(nmemb, sizeof(ptrtype)); \
 		CHECKEXITNOMEM(ptr, calloc);          \
 	} while (0)
 
 #define REALLOC(ptr, ptrtype, newsize)                   \
 	do                                               \
 	{                                                \
 		ptrtype* newptr = realloc(ptr, newsize); \
 		CHECKEXITNOMEM(newptr, realloc);         \
 		ptr = newptr;                            \
 	} while (0)
 
 #define REALLOCARRAY(ptr, membtype, newcount) \
 	REALLOC(ptr, membtype, sizeof(membtype) * newcount);
 
 #define CHECKCOPY(token, ptoken, token_size, pline)     \
 	do                                              \
 	{                                               \
 		if (ptoken + 2 > token + token_size)    \
 		{                                       \
 			size_t old_size = token_size;   \
 			token_size += BUFSIZE;          \
 			REALLOC(token, u8, token_size); \
 			ptoken = token + old_size - 1;  \
 		}                                       \
 		*ptoken++ = *pline++;                   \
 	} while (0)
 
 #define RESET_TOKEN(token, ptoken, token_size)  \
 	do                                      \
 	{                                       \
 		token_size = BUFSIZE;           \
 		REALLOC(token, u8, token_size); \
 		*token = 0;                     \
 		ptoken = token;                 \
 	} while (0)
 
 int slweb_cleanup(void);
 int usage(void);
 int version(const int full);
 
 int
 version(const int full)
 {
 	printf("%s %s, committed on %s\n", PROGRAMNAME, VERSION, DATE);
 	if (full)
 		puts(COPYRIGHT);
 	return 0;
 }
 
 int
 usage(void)
 {
 	printf("Usage:\t%s -h | --help | -V | --full-version | -v | --version\n"
 	       "\t%s [-d directory | --basedir directory]"
 	       " [-p URL | --global-link-prefix URL] [filename]\n",
 		PROGRAMNAME, PROGRAMNAME);
 	return 0;
 }
 
 int
 error(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, "%s:%s:%lu:%lu: %s\n", PROGRAMNAME,
 		input_filename ? input_filename : "(stdin)", lineno, colno,
 		buf);
 	return code;
 }
 
 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;
 }
 
 int
 free_keyvalue(KeyValue** list, const size_t list_count)
 {
 	if (!list || !*list)
 		return 1;
 
 	for (size_t index = 0; index < list_count; index++)
 	{
 		KeyValue* current = *list + index;
 		free(current->value);
 		free(current->key);
 	}
 	return 0;
 }
 
 int
 slweb_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(&paralinks, paralinks_count);
 	free_keyvalue(&links, links_count);
 	free_keyvalue(&macros, macros_count);
 	free_keyvalue(&vars, vars_count);
 	free(footnotes);
 	free(paralinks);
 	free(links);
 	free(macros);
 	free(vars);
 
 	return 0;
 }
 
 u8* format_date(const u8* date_arg, const char* timestamp_format);
 int simple_parse_yaml_line(const u8* line, KeyValue** vars, size_t* vars_count,
 	KeyValue** pvars);
 int slweb_parse(FILE* output, const char* source_filename, const u8* buffer,
 	const int read_yaml_macros_and_links);
 
 int
 startswith(const char* s, const char* what)
 {
 	if (!s || !what)
 		return 0;
 
 	do
 	{
 		if (*s++ != *what++)
 			return 0;
 	} while (*s && *what);
 
 	return !*what;
 }
 
 int
 endswith(const char* s, const char* what)
 {
 	const char* ps	  = s;
 	const char* pwhat = what;
 
 	if (!s || !what)
 		return 0;
 
 	if (!*what)
 		return 1;
 
 	while (*ps)
 		ps++;
 	while (*pwhat)
 		pwhat++;
 
 	while (ps != s && pwhat != what)
 		if (*ps-- != *pwhat--)
 			return 0;
 
 	return *ps == *pwhat && pwhat == what;
 }
 
 int
 all_numeric(const u8* start, const u8* end)
 {
 	const u8* ps = start;
 	while (ps != end)
 	{
 		if (*ps && !isdigit((const int)*ps))
 			return 0;
 		ps++;
 	}
 	return 1;
 }
 
 u8*
 get_value(KeyValue* list, const size_t list_count, const u8* key,
 	KeyValue** cursor)
 {
 	if (!list)
 		return NULL;
 	KeyValue* plist = list;
 	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;
 }
 
 int
 set_basedir(char** basedir, size_t* basedir_size, const char* arg)
 {
 	size_t basedir_len = 0;
 	size_t arg_len	   = strlen(arg);
 
 	if (arg_len < 1)
 		exit(error(1, (u8*)"set_basedir: Argument required"));
 
 	if (arg_len + 1 > *basedir_size)
 	{
 		*basedir_size = arg_len + 1;
 		REALLOC(*basedir, char, *basedir_size);
 	}
 
 	if (strlcpy(*basedir, arg, *basedir_size) >= *basedir_size)
 		warning(1, (u8*)"strlcpy:%d: Overflow", __LINE__);
 	basedir_len = strlen(*basedir);
 	if (*(*basedir + basedir_len - 1) == '/')
 		*(*basedir + basedir_len - 1) = 0;
 
 	return 0;
 }
 
 int
 set_global_link_prefix(char** global_link_prefix,
 	size_t* global_link_prefix_size, const char* arg)
 {
 	size_t arg_len = strlen(arg);
 
 	if (arg_len < 1)
 		exit(error(1, (u8*)"set_global_link_prefix: Argument required"));
 
 	if (arg_len + 1 > *global_link_prefix_size)
 	{
 		*global_link_prefix_size = arg_len + 1;
 		REALLOC(*global_link_prefix, char, *global_link_prefix_size);
 	}
 	if (strlcpy(*global_link_prefix, arg, *global_link_prefix_size)
 		>= *global_link_prefix_size)
 		warning(1, (u8*)"strlcpy:%d: Overflow", __LINE__);
 	*(*global_link_prefix + arg_len) = 0;
 
 	return 0;
 }
 
 char*
 strip_ext(const char* fn)
 {
 	char* newname	= NULL;
 	char* pnewname	= NULL;
 	const char* pfn = NULL;
 	char* dot	= NULL;
 
 	dot = strrchr(fn, '.');
 
 	if (!dot)
 		return NULL;
 
 	CALLOC(newname, char, strlen(fn) + 1);
 	pnewname = newname;
 	pfn	 = fn;
 
 	while (pfn != dot && *pfn)
 		*pnewname++ = *pfn++;
 
 	return newname;
 }
 
 int
 print_output(FILE* output, const char* fmt, ...)
 {
 	char buf[BUFSIZE];
 	va_list args;
 	u8* var_incdir_only_summary = NULL;
 	// int incdir_only_summary	    = 0;
 
 	if (!output || !fmt)
 		exit(error(EINVAL, (u8*)"print_output: Invalid argument"));
 
 	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);
 			if (strlcpy((char*)csv_template, buf, csv_template_size)
 				>= csv_template_size)
 				warning(1, (u8*)"strlcpy:%d: Overflow",
 					__LINE__);
 		}
 		else
 		{
 			if (strlen((char*)csv_template) + buf_len
 				> csv_template_size)
 			{
 				csv_template_size += BUFSIZE;
 				REALLOC(csv_template, u8, csv_template_size);
 			}
 			if (strlcat((char*)csv_template, buf, csv_template_size)
 				> csv_template_size)
 				warning(1, (u8*)"strlcat:%d: Overflow",
 					__LINE__);
 		}
 	}
 	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);
 			if (strlcpy((char*)tsv_template, buf, tsv_template_size)
 				>= tsv_template_size)
 				warning(1, (u8*)"strlcpy:%d: Overflow",
 					__LINE__);
 		}
 		else
 		{
 			if (strlen((char*)tsv_template) + buf_len
 				> tsv_template_size)
 			{
 				tsv_template_size += BUFSIZE;
 				REALLOC(tsv_template, u8, tsv_template_size);
 			}
 			if (strlcat((char*)tsv_template, buf, tsv_template_size)
 				> tsv_template_size)
 				warning(1, (u8*)"strlcat:%d: Overflow",
 					__LINE__);
 		}
 	}
 	else
 		vfprintf(output, fmt, args);
 	va_end(args);
 	return 0;
 }
 
 #define PIPE_READ_INDEX	 0
 #define PIPE_WRITE_INDEX 1
 
 int
 print_command(FILE* output, const char* command, const u8* pass_arguments[],
 	const u8* pipe_arguments[], const int strip_newlines)
 {
 	if (!command || !pass_arguments)
 		exit(error(EINVAL, (u8*)"print_command: Invalid argument"));
 
 	pid_t pid   = 0;
 	int pstatus = 0;
 	int arg_pipe_fds[2];
 	int output_pipe_fds[2];
 
 	fflush(output);
 	pipe(arg_pipe_fds);
 	pipe(output_pipe_fds);
 	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)
 		exit(error(errno, (u8*)"print_command: fork failed"));
 
 	/* Parent */
 	close(arg_pipe_fds[PIPE_READ_INDEX]);
 	close(output_pipe_fds[PIPE_WRITE_INDEX]);
 	FILE* cmd_input	 = fdopen(arg_pipe_fds[PIPE_WRITE_INDEX], "w");
 	FILE* cmd_output = fdopen(output_pipe_fds[PIPE_READ_INDEX], "r");
 
 	if (!cmd_input || !cmd_output)
 	{
 		perror("fdopen");
 		exit(error(1, (u8*)"print_command: 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);
 
 	u8* cmd_output_line = NULL;
 	CALLOC(cmd_output_line, u8, BUFSIZE);
 	while (!feof(cmd_output))
 	{
 		char* eol = NULL;
 
 		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);
 	pid_t 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;
 }
 
 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;
 
 	*input = fopen(input_filename, "r");
 	if (!*input)
 	{
 		perror("fopen");
 		return error(ENOENT,
 			(u8*)"read_file_into_buffer: fopen failed: %s",
 			input_filename);
 	}
 
 	fstat(fileno(*input), &fs);
 	if (S_ISDIR(fs.st_mode))
 		return error(EISDIR,
 			(u8*)"read_file_into_buffer: 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);
 		char* pinput_dirname	    = *input_dirname;
 		const char* 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;
 }
 
 int read_csv(FILE* output, const char* filename, csv_callback_t callback);
 int read_tsv(FILE* output, const char* filename, tsv_callback_t callback);
 
 int
 process_heading_start(FILE* output, const UBYTE heading_level)
 {
 	if (!output_firstcol)
 		print_output(output, "\n");
 	for (size_t i = 0; i < heading_level; i++)
 		print_output(output, "#");
 	print_output(output, " ");
 	output_firstcol = 0;
 	return 0;
 }
 
 int
 process_heading(FILE* output, const u8* token)
 {
 	if (!token || strlen((char*)token) < 1)
 		warning(1, (u8*)"Empty heading");
 
 	print_output(output, "%s\n", token ? (char*)token : "");
 	output_firstcol = 1;
 
 	return 0;
 }
 
 int
 process_git_log(FILE* output)
 {
 	if (!input_filename)
 		return warning(1, (u8*)"Cannot use 'git-log' in stdin");
 
 	char* basename	     = NULL;
 	size_t basename_size = BUFSIZE;
 	CALLOC(basename, char, basename_size);
 	char* slash  = strrchr(input_filename, '/');
 	pid_t result = 0;
 
 	if (slash)
 	{
 		if (strlcpy(basename, slash + 1, basename_size) >= basename_size)
 			warning(1, (u8*)"strlcpy:%d: Overflow", __LINE__);
 	}
 	else
 	{
 		if (strlcpy(basename, input_filename, basename_size)
 			>= basename_size)
 			warning(1, (u8*)"strlcpy:%d: Overflow", __LINE__);
 	}
 
 	u8* pipe_args[] = {(u8*)basename, NULL};
 
 	print_output(output, "Previous commit: ");
 	result = print_command(output, CMD_GIT_LOG,
 		(const u8**)CMD_GIT_LOG_ARGS, (const u8**)pipe_args, 0);
 	print_output(output, "\n");
 	output_firstcol = 1;
 
 	free(basename);
 
 	return result ? warning(result, (u8*)"git-log: Cannot run git") : 0;
 }
 
 #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)
 
 int
 print_tsv_row(FILE* output, u8** tsv_header, u8** tsv_register)
 {
 	u8* ptsv_template	= tsv_template;
 	UBYTE tsv_state		= ST_CS_NONE;
 	UBYTE num		= 0;
 	UBYTE conditional_index = 0;
 
 tsv_template_start:
 	if (!*ptsv_template)
 		goto tsv_template_done;
 	if (IN(tsv_state, ST_CS_ESCAPE))
 	{
 		PRINTTSVIF("%c", *ptsv_template);
 		tsv_state &= ~ST_CS_ESCAPE;
 		ptsv_template++;
 		goto tsv_template_start;
 	}
 
 	switch (*ptsv_template)
 	{
 	case '\\':
 		tsv_state |= ST_CS_ESCAPE;
 		ptsv_template++;
 		break;
 	case '$':
 		if (IN(tsv_state, ST_CS_REGISTER))
 		{
 			PRINTTSVIF("%c", '$');
 			tsv_state &= ~ST_CS_REGISTER;
 		}
 		else
 			tsv_state |= ST_CS_REGISTER;
 		ptsv_template++;
 		break;
 	case '#':
 		if (IN(tsv_state, ST_CS_HEADER))
 		{
 			error(1,
 				(u8*)"print_tsv_row: Invalid header register"
 				     " mark");
 			tsv_state &= ~(ST_CS_REGISTER | ST_CS_HEADER);
 		}
 		else if (IN(tsv_state, ST_CS_REGISTER))
 		{
 			tsv_state &= ~ST_CS_REGISTER;
 			tsv_state |= ST_CS_HEADER;
 		}
 		else
 			PRINTTSVIF("%c", '#');
 		ptsv_template++;
 		break;
 	case '?':
 		if (IN(tsv_state, ST_CS_COND))
 		{
 			error(1,
 				(u8*)"print_tsv_row: Invalid conditional"
 				     " mark");
 			tsv_state &= ~ST_CS_COND;
 		}
 		else if (IN(tsv_state, ST_CS_REGISTER))
 		{
 			tsv_state &= ~ST_CS_REGISTER;
 			tsv_state |= ST_CS_COND;
 		}
 		else
 			PRINTTSVIF("%c", '?');
 		ptsv_template++;
 		break;
 	case '!':
 		if (ALL(tsv_state, ST_CS_COND | ST_CS_COND_NONEMPTY))
 		{
 			tsv_state &= ~(ST_CS_COND | ST_CS_COND_NONEMPTY);
 			tsv_state |= ST_CS_COND_EMPTY;
 		}
 		else if (IN(tsv_state, ST_CS_COND))
 		{
 			error(1,
 				(u8*)"print_tsv_row: Empty conditional"
 				     " before/without nonempty conditional");
 			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))
 			tsv_state &= ~(ST_CS_COND | ST_CS_COND_EMPTY);
 		else if (ALL(tsv_state, ST_CS_COND))
 			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';
 			tsv_state &= ~ST_CS_COND;
 			tsv_state |= ST_CS_COND_NONEMPTY;
 		}
 		else if (IN(tsv_state, ST_CS_HEADER))
 		{
 			num = *ptsv_template - '0';
 			PRINTTSVIF("%s", tsv_header[num - 1]);
 			tsv_state &= ~ST_CS_HEADER;
 		}
 		else if (IN(tsv_state, ST_CS_REGISTER))
 		{
 			num = *ptsv_template - '0';
 			PRINTTSVIF("%s", tsv_register[num - 1]);
 			tsv_state &= ~ST_CS_REGISTER;
 		}
 		else
 			PRINTTSVIF("%c", *ptsv_template);
 		ptsv_template++;
 		break;
 	default:
 		if (IN(tsv_state, ST_CS_HEADER))
 		{
 			error(1,
 				(u8*)"print_tsv_row: Invalid header register"
 				     " mark");
 			tsv_state &= ~ST_CS_HEADER;
 		}
 		else if (IN(tsv_state, ST_CS_REGISTER))
 		{
 			error(1, (u8*)"print_tsv_row: Invalid register mark");
 			tsv_state &= ~ST_CS_REGISTER;
 		}
 		else
 			PRINTTSVIF("%c", *ptsv_template);
 		ptsv_template++;
 	}
 	goto tsv_template_start;
 tsv_template_done:
 	return 0;
 }
 
 int
 read_tsv(FILE* output, const char* filename, tsv_callback_t callback)
 {
 	if (!callback)
 		exit(error(EINVAL, (u8*)"read_tsv: Invalid callback argument"));
 
 	FILE* tsv	  = NULL;
 	size_t tsv_lineno = 0;
 	u8* bufline	  = NULL;
 	u8* pbufline	  = NULL;
 	u8* token	  = NULL;
 	u8* ptoken	  = NULL;
 	size_t token_size = 0;
 	u8* tsv_header[MAX_TSV_REGISTERS];
 	UBYTE current_header = 0;
 	u8* tsv_register[MAX_TSV_REGISTERS];
 	UBYTE current_register = 0;
 
 	if (!(tsv = fopen(filename, "rt")))
 	{
 		perror("fopen");
 		exit(error(ENOENT, (u8*)"read_tsv: fopen failed: %s", filename));
 	}
 
 	CALLOC(bufline, u8, BUFSIZE);
 	token_size = BUFSIZE;
 	CALLOC(token, u8, token_size);
 	for (UBYTE i = 0; i < MAX_TSV_REGISTERS; i++)
 		CALLOC(tsv_header[i], u8, BUFSIZE);
 	for (UBYTE i = 0; i < MAX_TSV_REGISTERS; i++)
 		CALLOC(tsv_register[i], u8, BUFSIZE);
 
 	while (!feof(tsv) && (!tsv_iter || tsv_lineno <= tsv_iter))
 	{
 		u8* 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)
 			{
 				if (strlcpy((char*)tsv_register[current_register],
 					    (char*)token, BUFSIZE)
 					>= BUFSIZE)
 					warning(1, (u8*)"strlcpy:%d: Overflow",
 						__LINE__);
 				current_register++;
 			}
 			else if (tsv_lineno <= 0
 				&& current_header < MAX_TSV_REGISTERS)
 			{
 				if (strlcpy((char*)tsv_header[current_header],
 					    (char*)token, BUFSIZE)
 					>= BUFSIZE)
 					warning(1, (u8*)"strlcpy:%d: Overflow",
 						__LINE__);
 				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)
 			{
 				if (strlcpy((char*)tsv_register[current_register],
 					    (char*)token, BUFSIZE)
 					>= BUFSIZE)
 					warning(1, (u8*)"strlcpy:%d: Overflow",
 						__LINE__);
 				current_register++;
 			}
 		}
 		else
 		{
 			if (current_header < MAX_TSV_REGISTERS)
 			{
 				if (strlcpy((char*)tsv_header[current_header],
 					    (char*)token, BUFSIZE)
 					>= BUFSIZE)
 					warning(1, (u8*)"strlcpy:%d: Overflow",
 						__LINE__);
 				current_header++;
 			}
 		}
 		RESET_TOKEN(token, ptoken, token_size);
 
 		if (tsv_lineno > 0 && pbufline != bufline)
 			(*callback)(output, tsv_header, tsv_register);
 
 		for (UBYTE i = 0; i < MAX_TSV_REGISTERS; i++)
 			*tsv_register[i] = 0;
 		tsv_lineno++;
 	}
 	fclose(tsv);
 	for (UBYTE i = MAX_TSV_REGISTERS; i > 0; i--)
 		free(tsv_register[i - 1]);
 	for (UBYTE i = MAX_TSV_REGISTERS; i > 0; i--)
 		free(tsv_header[i - 1]);
 	free(token);
 	free(bufline);
 
 	return 0;
 }
 
 int
 process_tsv(FILE* output, const u8* arg_token,
 	const int read_yaml_macros_and_links, const int end_tag)
 {
 	if (end_tag)
 	{
 		state &= ~ST_TSV_BODY;
 
 		if (read_yaml_macros_and_links)
 			return 0;
 
 		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(1,
 				(u8*)"process_tsv: Can't nest csv/tsv "
 				     "directives"));
 
 		state |= ST_TSV_BODY;
 
 		if (read_yaml_macros_and_links)
 			return 0;
 
 		tsv_iter    = 0;
 		u8* saveptr = NULL;
 		u8* args    = NULL;
 
 		(void)strtok_r((char*)arg_token, " ", (char**)&saveptr);
 		args = (u8*)strtok_r(NULL, " ", (char**)&saveptr);
 		if (!args)
 			exit(error(EINVAL,
 				(u8*)"process_tsv: Arguments required"));
 		size_t args_len = strlen((char*)args);
 		if (*args != '"' || *(args + args_len - 1) != '"')
 			exit(error(EINVAL,
 				(u8*)"process_tsv: First argument must be a "
 				     "string"));
 		if (!tsv_filename)
 			CALLOC(tsv_filename, char, BUFSIZE);
 		u8* 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 = strtol((char*)args, NULL, 10);
 			if (errno)
 				exit(error(errno,
 					(u8*)"process_tsv: Invalid argument "
 					     "'%s'",
 					args));
 		}
 	}
 
 	return 0;
 }
 
 #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)
 
 int
 print_csv_row(FILE* output, u8** csv_header, u8** csv_register)
 {
 	u8* pcsv_template	= csv_template;
 	UBYTE csv_state		= ST_CS_NONE;
 	UBYTE num		= 0;
 	UBYTE conditional_index = 0;
 
 csv_template_start:
 	if (!*pcsv_template)
 		goto csv_template_done;
 	if (IN(csv_state, ST_CS_ESCAPE))
 	{
 		PRINTCSVIF("%c", *pcsv_template);
 		csv_state &= ~ST_CS_ESCAPE;
 		pcsv_template++;
 		goto csv_template_start;
 	}
 
 	switch (*pcsv_template)
 	{
 	case '\\':
 		csv_state |= ST_CS_ESCAPE;
 		pcsv_template++;
 		break;
 	case '$':
 		if (IN(csv_state, ST_CS_REGISTER))
 		{
 			PRINTCSVIF("%c", '$');
 			csv_state &= ~ST_CS_REGISTER;
 		}
 		else
 			csv_state |= ST_CS_REGISTER;
 		pcsv_template++;
 		break;
 	case '#':
 		if (IN(csv_state, ST_CS_HEADER))
 		{
 			error(1, (u8*)"print_csv_row: Invalid header register mark");
 			csv_state &= ~(ST_CS_REGISTER | ST_CS_HEADER);
 		}
 		else if (IN(csv_state, ST_CS_REGISTER))
 		{
 			csv_state &= ~ST_CS_REGISTER;
 			csv_state |= ST_CS_HEADER;
 		}
 		else
 			PRINTCSVIF("%c", '#');
 		pcsv_template++;
 		break;
 	case '?':
 		if (IN(csv_state, ST_CS_COND))
 		{
 			error(1, (u8*)"print_csv_row: Invalid conditional mark");
 			csv_state &= ~ST_CS_COND;
 		}
 		else if (IN(csv_state, ST_CS_REGISTER))
 		{
 			csv_state &= ~ST_CS_REGISTER;
 			csv_state |= ST_CS_COND;
 		}
 		else
 			PRINTCSVIF("%c", '?');
 		pcsv_template++;
 		break;
 	case '!':
 		if (ALL(csv_state, ST_CS_COND | ST_CS_COND_NONEMPTY))
 		{
 			csv_state &= ~(ST_CS_COND | ST_CS_COND_NONEMPTY);
 			csv_state |= ST_CS_COND_EMPTY;
 		}
 		else if (IN(csv_state, ST_CS_COND))
 		{
 			error(1,
 				(u8*)"print_csv_row: Empty conditional "
 				     "before/without nonempty"
 				     " conditional");
 			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))
 			csv_state &= ~(ST_CS_COND | ST_CS_COND_EMPTY);
 		else if (ALL(csv_state, ST_CS_COND))
 			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';
 			csv_state &= ~ST_CS_COND;
 			csv_state |= ST_CS_COND_NONEMPTY;
 		}
 		else if (IN(csv_state, ST_CS_HEADER))
 		{
 			num = *pcsv_template - '0';
 			PRINTCSVIF("%s", csv_header[num - 1]);
 			csv_state &= ~ST_CS_HEADER;
 		}
 		else if (IN(csv_state, ST_CS_REGISTER))
 		{
 			num = *pcsv_template - '0';
 			PRINTCSVIF("%s", csv_register[num - 1]);
 			csv_state &= ~ST_CS_REGISTER;
 		}
 		else
 			PRINTCSVIF("%c", *pcsv_template);
 		pcsv_template++;
 		break;
 	default:
 		if (IN(csv_state, ST_CS_HEADER))
 		{
 			error(1, (u8*)"print_csv_row: Invalid header register mark");
 			csv_state &= ~ST_CS_HEADER;
 		}
 		else if (IN(csv_state, ST_CS_REGISTER))
 		{
 			error(1, (u8*)"print_csv_row: Invalid register mark");
 			csv_state &= ~ST_CS_REGISTER;
 		}
 		else
 			PRINTCSVIF("%c", *pcsv_template);
 		pcsv_template++;
 	}
 	goto csv_template_start;
 csv_template_done:
 	return 0;
 }
 
 int
 read_csv(FILE* output, const char* filename, csv_callback_t callback)
 {
 	if (!callback)
 		exit(error(EINVAL, (u8*)"read_csv: Invalid callback argument"));
 
 	FILE* csv	  = NULL;
 	size_t csv_lineno = 0;
 	u8* bufline	  = NULL;
 	u8* pbufline	  = NULL;
 	u8* token	  = NULL;
 	u8* ptoken	  = NULL;
 	size_t token_size = 0;
 	UBYTE csv_state	  = ST_CS_NONE;
 	u8* csv_header[MAX_CSV_REGISTERS];
 	UBYTE current_header = 0;
 	u8* csv_register[MAX_CSV_REGISTERS];
 	UBYTE current_register = 0;
 	u8* csv_delimiter
 		= get_value(vars, vars_count, (u8*)"csv-delimiter", NULL);
 
 	if (!(csv = fopen(filename, "rt")))
 	{
 		perror("fopen");
 		exit(error(ENOENT, (u8*)"read_csv: fopen failed: %s", filename));
 	}
 
 	CALLOC(bufline, u8, BUFSIZE);
 	token_size = BUFSIZE;
 	CALLOC(token, u8, token_size);
 	for (UBYTE i = 0; i < MAX_CSV_REGISTERS; i++)
 		CALLOC(csv_header[i], u8, BUFSIZE);
 	for (UBYTE i = 0; i < MAX_CSV_REGISTERS; i++)
 		CALLOC(csv_register[i], u8, BUFSIZE);
 
 	while (!feof(csv) && (!csv_iter || csv_lineno <= csv_iter))
 	{
 		u8* 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)
 				{
 					if (strlcpy((char*)csv_register
 							    [current_register],
 						    (char*)token, BUFSIZE)
 						>= BUFSIZE)
 						warning(1, (u8*)"strlcpy:%d: Overflow",
 							__LINE__);
 					current_register++;
 				}
 				else if (csv_lineno <= 0
 					&& current_header < MAX_CSV_REGISTERS)
 				{
 					if (strlcpy((char*)csv_header
 							    [current_header],
 						    (char*)token, BUFSIZE)
 						>= BUFSIZE)
 						warning(1, (u8*)"strlcpy:%d: Overflow",
 							__LINE__);
 					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)
 				{
 					if (strlcpy((char*)csv_register
 							    [current_register],
 						    (char*)token, BUFSIZE)
 						>= BUFSIZE)
 						warning(1, (u8*)"strlcpy:%d: Overflow",
 							__LINE__);
 					current_register++;
 				}
 				else if (csv_lineno <= 0
 					&& current_header < MAX_CSV_REGISTERS)
 				{
 					if (strlcpy((char*)csv_header
 							    [current_header],
 						    (char*)token, BUFSIZE)
 						>= BUFSIZE)
 						warning(1, (u8*)"strlcpy:%d: Overflow",
 							__LINE__);
 					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)
 			{
 				if (strlcpy((char*)csv_register[current_register],
 					    (char*)token, BUFSIZE)
 					>= BUFSIZE)
 					warning(1, (u8*)"strlcpy:%d: Overflow",
 						__LINE__);
 				current_register++;
 			}
 		}
 		else
 		{
 			if (current_header < MAX_CSV_REGISTERS)
 			{
 				if (strlcpy((char*)csv_header[current_header],
 					    (char*)token, BUFSIZE)
 					>= BUFSIZE)
 					warning(1, (u8*)"strlcpy:%d: Overflow",
 						__LINE__);
 				current_header++;
 			}
 		}
 		RESET_TOKEN(token, ptoken, token_size);
 
 		if (csv_lineno > 0 && pbufline != bufline)
 			(*callback)(output, csv_header, csv_register);
 
 		for (UBYTE i = 0; i < MAX_CSV_REGISTERS; i++)
 			*csv_register[i] = 0;
 		csv_lineno++;
 	}
 	fclose(csv);
 	for (UBYTE i = MAX_CSV_REGISTERS; i > 0; i--)
 		free(csv_register[i - 1]);
 	for (UBYTE i = MAX_CSV_REGISTERS; i > 0; i--)
 		free(csv_header[i - 1]);
 	free(token);
 	free(bufline);
 
 	return 0;
 }
 
 int
 process_csv(FILE* output, const u8* arg_token,
 	const int read_yaml_macros_and_links, const int end_tag)
 {
 	if (end_tag)
 	{
 		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(1,
 				(u8*)"read_csv: Can't nest csv/tsv"
 				     " directives"));
 
 		state |= ST_CSV_BODY;
 
 		if (read_yaml_macros_and_links)
 			return 0;
 
 		csv_iter    = 0;
 		u8* saveptr = NULL;
 		u8* args    = NULL;
 
 		(void)strtok_r((char*)arg_token, " ", (char**)&saveptr);
 		args = (u8*)strtok_r(NULL, " ", (char**)&saveptr);
 		if (!args)
 			exit(error(EINVAL, (u8*)"read_csv: Arguments required"));
 		size_t args_len = strlen((char*)args);
 		if (*args != '"' || *(args + args_len - 1) != '"')
 			exit(error(EINVAL,
 				(u8*)"read_csv: First argument must be a "
 				     "string"));
 		if (!csv_filename)
 			CALLOC(csv_filename, char, BUFSIZE);
 		u8* 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 = strtol((char*)args, NULL, 10);
 			if (errno)
 				exit(error(errno,
 					(u8*)"read_csv: Invalid argument '%s'",
 					args));
 		}
 	}
 
 	return 0;
 }
 
 int
 process_include(FILE* output, const u8* token,
 	const int read_yaml_macros_and_links)
 {
 	u8* ptoken;
 	char* include_filename	= NULL;
 	char* pinclude_filename = NULL;
 	pid_t pid		= 0;
 	int pstatus		= 0;
 	int arg_pipe_fds[2];
 	int output_pipe_fds[2];
 
 	ptoken = (u8*)strchr((char*)token, ' ');
 
 	if (!input_filename)
 		return warning(1, (u8*)"Cannot use 'include' in stdin");
 
 	if (!ptoken)
 		exit(error(1,
 			(u8*)"process_include: Directive 'include' requires"
 			     " an argument"));
 
 	fflush(output);
 	pipe(arg_pipe_fds);
 	pipe(output_pipe_fds);
 	pid = fork();
 
 	if (pid > 0) /* parent */
 	{
 		FILE* child_output    = NULL;
 		u8* child_output_line = NULL;
 		close(arg_pipe_fds[PIPE_READ_INDEX]);
 		close(output_pipe_fds[PIPE_WRITE_INDEX]);
 		if (!(child_output
 			    = fdopen(output_pipe_fds[PIPE_READ_INDEX], "r")))
 		{
 			wait(&pstatus);
 			perror("fdopen");
 			exit(error(1, (u8*)"process_include: fdopen failed"));
 		}
 
 		CALLOC(child_output_line, u8, BUFSIZE);
 		while (!feof(child_output))
 		{
 			char* 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 */
 	{
 		char* filename	   = NULL;
 		FILE* input	   = NULL;
 		FILE* output	   = stdout;
 		u8* buffer	   = NULL;
 		size_t buffer_size = 0;
 		int result	   = 0;
 		FILE* child_output = NULL;
 
 		close(arg_pipe_fds[PIPE_WRITE_INDEX]);
 		close(output_pipe_fds[PIPE_READ_INDEX]);
 		if (!(child_output
 			    = fdopen(output_pipe_fds[PIPE_WRITE_INDEX], "w")))
 		{
 			perror("fdopen");
 			exit(error(1, (u8*)"process_include: 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);
 
 		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(&paralinks, paralinks_count);
 		free(paralinks);
 		paralinks	= NULL;
 		paralinks_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, buffer, 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, buffer, 0);
 
 	process_include_child_cleanup:
 		fflush(output);
 		slweb_cleanup();
 		free(filename);
 		free(buffer);
 		fclose(child_output);
 		exit(result);
 	}
 	else
 		exit(error(1, (u8*)"process_include: fork failed"));
 
 	return 0;
 }
 
 int
 process_list_start(FILE* output)
 {
 	return 0;
 }
 
 int
 process_list_item_start(FILE* output)
 {
 	print_output(output, "%s* ", output_firstcol ? "" : "\n");
 	state |= ST_PARA_OPEN;
 	return 0;
 }
 
 int process_paralinks(FILE* output, const u8* link_prefix);
 
 int
 process_list_item_end(FILE* output, const u8* link_prefix)
 {
 	if (IN(state, ST_PARA_OPEN))
 	{
 		state &= ~ST_PARA_OPEN;
 		print_output(output, "\n\n");
 		output_firstcol = 1;
 		process_paralinks(output, link_prefix);
 	}
 	return 0;
 }
 
 int
 process_list_end(FILE* output)
 {
 	return 0;
 }
 
 int
 process_numlist_start(FILE* output)
 {
 	return 0;
 }
 
 int
 process_numlist_end(FILE* output)
 {
 	return 0;
 }
 
 int
 filter_subdirs(const struct dirent* node)
 {
 	if (!node
 		|| ((*node->d_name == '.')
 			&& (!*(node->d_name + 1)
 				|| ((*(node->d_name + 1) == '.')
 					&& !(*(node->d_name + 2))))))
 		return 0;
 
 	struct stat st;
 	char* nodename = NULL;
 
 	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;
 }
 
 int
 filter_slw(const struct dirent* node)
 {
 	if (!node
 		|| ((*node->d_name == '.')
 			&& (!*(node->d_name + 1)
 				|| ((*(node->d_name + 1) == '.')
 					&& !(*(node->d_name + 2))))))
 		return 0;
 
 	size_t node_len = strlen(node->d_name);
 	size_t slw_len	= strlen(".slw");
 
 	if (slw_len >= node_len)
 		return 0;
 	return !strcmp(node->d_name + strlen(node->d_name) - slw_len, ".slw");
 }
 
 int
 reverse_alphacompare(const struct dirent** a, const struct dirent** b)
 {
 	if (!a || !b)
 		return 0;
 
 	return -1 * strcmp((*a)->d_name, (*b)->d_name);
 }
 
 int process_timestamp(FILE* output, const u8* link_prefix, const char* link,
 	const u8* permalink_macro, const u8* date, const u8* title,
 	const int ext_in_permalink);
 
 int
 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;
 	long names_total = 0;
 	long names_output;
 	char* abs_subdirname = NULL;
 
 	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)
 	{
 		perror("scandir");
 		exit(error(errno,
 			(u8*)"process_incdir_subdir: scandir '%s' failed",
 			abs_subdirname));
 	}
 
 	pnamelist    = namelist;
 	names_output = 0;
 	while (names_output < names_total)
 	{
 		int pstatus = 0;
 
 		fflush(output);
 		pid_t pid = fork();
 
 		if (pid > 0)
 			wait(&pstatus);
 		else if (pid == 0)
 		{
 			FILE* input	   = NULL;
 			FILE* output	   = stdout;
 			u8* buffer	   = NULL;
 			size_t buffer_size = 0;
 			int result	   = 0;
 			ULLONG saved_state = ST_NONE;
 			char* filename	   = NULL;
 			char* abs_filename = NULL;
 			char* link	   = NULL;
 			u8* title	   = NULL;
 			u8* date	   = NULL;
 
 			if (!strcmp(basedir, "."))
 				set_basedir(&basedir, &basedir_size,
 					abs_subdirname);
 			CALLOC(filename, char, BUFSIZE);
 			CALLOC(abs_filename, char, BUFSIZE);
 			CALLOC(link, char, BUFSIZE);
 			snprintf(filename, BUFSIZE, "%s/%s", subdirname,
 				(*pnamelist)->d_name);
 			snprintf(abs_filename, BUFSIZE, "%s/%s", abs_subdirname,
 				(*pnamelist)->d_name);
 			link = strip_ext(filename);
 
 			read_file_into_buffer(&input, &buffer, &buffer_size,
 				abs_filename, &input_dirname);
 
 			free_keyvalue(&links, links_count);
 			free(links);
 			links	    = NULL;
 			links_count = 0;
 
 			free_keyvalue(&paralinks, paralinks_count);
 			free(paralinks);
 			paralinks	= 0;
 			paralinks_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;
 			output_firstcol = 1;
 			skip_para_end	= 0;
 
 			/* First pass: read YAML, macros and links */
 			result = slweb_parse(output, abs_filename, buffer, 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);
 
 			process_timestamp(output, link_prefix, link, NULL, date,
 				title, ext_in_permalink);
 
 			state = saved_state;
 
 		incdir_subdir_child_cleanup:
 			fflush(output);
 			slweb_cleanup();
 			free(link);
 			free(abs_filename);
 			free(filename);
 			free(buffer);
 			free(abs_subdirname);
 			while (names_total--)
 				free(namelist[names_total]);
 			free(namelist);
 			exit(result);
 		}
 		else
 			exit(error(1,
 				(u8*)"process_incdir_subdir: 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;
 	return 0;
 }
 
 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)
 {
 	u8* saveptr = NULL;
 	/* skipping the first token (incdir) */
 	u8* arg		= NULL;
 	size_t arg_len	= 0;
 	long num	= 5;
 	u8* macro_body	= NULL;
 	int names_total = 0;
 	struct dirent** namelist;
 	struct dirent** pnamelist;
 	long names_output;
 	int details_open = 1;
 	int list_only	 = 0;
 	int pass;
 	u8* parg = 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(1, (u8*)"process_incdir: Arguments required"));
 
 	arg_len = strlen((char*)arg);
 
 	if (*arg != '"' || *(arg + arg_len - 1) != '"')
 		exit(error(1, (u8*)"process_incdir: 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(1,
 					(u8*)"process_incdir: Invalid "
 					     "argument"));
 			parg++;
 		}
 		errno = 0;
 		num   = strtol((char*)arg, NULL, 10);
 		if (errno)
 			exit(error(errno,
 				(u8*)"process_incdir: Invalid parameter "
 				     "'num'"));
 	}
 	pass++;
 	if (pass < 3)
 		goto incdir_next_arg;
 
 incdir_done_args:
 	/*print_output(output, "<ul class=\"incdir\">\n")*/;
 
 	if ((names_total = scandir(incdir, &namelist, &filter_subdirs,
 		     &reverse_alphacompare))
 		< 0)
 	{
 		perror("scandir");
 		exit(error(errno, (u8*)"process_incdir: 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");*/
 	}
 	/*print_output(output, "\n");*/
 	output_firstcol = 1;
 
 	while (names_total--)
 		free(namelist[names_total]);
 	free(namelist);
 	free(incdir);
 
 	return 0;
 }
 
 int url_is_local(const char* url);
 
 u8*
 format_date(const u8* date_arg, const char* timestamp_format)
 {
 	const char* ptimestamp_format = NULL;
 	u8* day			      = NULL;
 	u8* month		      = NULL;
 	u8* year		      = NULL;
 	u8* formatted_date	      = NULL;
 	u8* ptr			      = NULL;
 	u8* date		      = NULL;
 
 	date = (u8*)strdup((const char*)date_arg);
 	if (!date)
 		goto format_date_cleanup;
 
 	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;
 	while (*ptimestamp_format)
 	{
 		if (*ptimestamp_format == 'd' || *ptimestamp_format == 'D')
 		{
 			if (strlcat((char*)formatted_date, (char*)day,
 				    DATEBUFSIZE)
 				> DATEBUFSIZE)
 				warning(1, (u8*)"strlcat:%d: Overflow",
 					__LINE__);
 		}
 		else if (*ptimestamp_format == 'm' || *ptimestamp_format == 'M')
 		{
 			if (strlcat((char*)formatted_date, (char*)month,
 				    DATEBUFSIZE)
 				> DATEBUFSIZE)
 				warning(1, (u8*)"strlcat:%d: Overflow",
 					__LINE__);
 		}
 		else if (*ptimestamp_format == 'y' || *ptimestamp_format == 'Y')
 		{
 			if (strlcat((char*)formatted_date, (char*)year,
 				    DATEBUFSIZE)
 				> DATEBUFSIZE)
 				warning(1, (u8*)"strlcat:%d: Overflow",
 					__LINE__);
 		}
 		else
 			*(formatted_date + strlen((char*)formatted_date))
 				= *ptimestamp_format;
 
 		ptimestamp_format++;
 	}
 	return formatted_date;
 
 format_date_cleanup:
 	free(formatted_date);
 	free(date);
 
 	return NULL;
 }
 
 int
 process_timestamp(FILE* output, const u8* link_prefix, const char* link,
 	const u8* permalink_macro, const u8* date, const u8* title,
 	const int ext_in_permalink)
 {
 	char* in_filename  = NULL;
 	char* in_line	   = NULL;
 	u8* formatted_date = NULL;
 
 	formatted_date = format_date(date, timestamp_format);
 	if (!formatted_date)
 		goto process_timestamp_cleanup;
 
 	print_output(output, "=> %s%s%s%s\t%s %s\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 : "",
 		formatted_date, title ? (const char*)title : "");
 	output_firstcol = 1;
 
 process_timestamp_cleanup:
 	free(formatted_date);
 	free(in_line);
 	free(in_filename);
 
 	return 0;
 }
 
 int
 process_macro_def(FILE* output, const u8* token,
 	const int read_yaml_macros_and_links, const int end_tag)
 {
 	if (end_tag)
 	{
 		fflush(output);
 		state &= ~ST_MACRO_BODY;
 		return 0;
 	}
 
 	if (IN(state, ST_MACRO_BODY))
 		exit(error(1,
 			(u8*)"process_macro_def: 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);
 		if (strlcpy((char*)pmacros->key, (char*)token + 2, KEYSIZE)
 			>= KEYSIZE)
 			warning(1, (u8*)"strlcpy:%d: Overflow", __LINE__);
 		pmacros->value	    = NULL;
 		pmacros->value_size = 0;
 	}
 	fflush(output);
 	state |= ST_MACRO_BODY;
 
 	return 0;
 }
 
 int
 process_macro(FILE* output, const u8* token, const int end_tag)
 {
 	u8* macro_body;
 	u8* eol;
 	size_t macro_body_len;
 
 	macro_body = get_value(macros, macros_count, token + 1, NULL);
 	if (!macro_body)
 		exit(error(1, (u8*)"process_macro: 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;
 }
 
 int process_para_end(FILE* output, const u8* link_prefix,
 	const int previous_line_blank, const int read_yaml_macros_and_links);
 
 int
 process_tag(FILE* output, const u8* token, const char* source_filename,
 	const u8* link_prefix, const int previous_line_blank,
 	const int first_line_in_doc, 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)
 {
 	if (!token || strlen((char*)token) < 1)
 		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")) /* {csv} */
 		process_csv(output, token, read_yaml_macros_and_links, end_tag);
 	else if (startswith((char*)token, "tsv")) /* {csv} */
 		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 (startswith((char*)token, "p") && !read_yaml_macros_and_links)
 	{
 		skip_para_end = 1;
 		*skip_eol     = 1;
 		if (end_tag)
 		{
 			process_para_end(output, link_prefix,
 				previous_line_blank,
 				read_yaml_macros_and_links);
 			output_firstcol = 1;
 		}
 	}
 
 	return 0;
 }
 
 int
 process_bold(FILE* output, int end_tag)
 {
 	return 0;
 }
 
 int
 process_italic(FILE* output, int end_tag)
 {
 	return 0;
 }
 
 int
 process_code(FILE* output, int end_tag)
 {
 	return 0;
 }
 
 int
 process_blockquote(FILE* output, int end_tag)
 {
 	if (end_tag)
 		print_output(output, "\n\n");
 	else
 		print_output(output, "%s>", output_firstcol ? "" : "\n");
 	return 0;
 }
 
 int
 process_kbd(FILE* output, int end_tag)
 {
 	return 0;
 }
 
 int
 process_madeby(FILE* output)
 {
 	print_output(output,
 		"Generated by slw2gmi © %s Strahinya Radich.\n"
 		"=> %s slw2gmi\n",
 		COPYRIGHTYEAR, MADEBY_URL);
 
 	output_firstcol = 1;
 	return 0;
 }
 
 int
 process_strike(FILE* output, int end_tag)
 {
 	print_output(output, "~");
 	return 0;
 }
 
 int
 process_table_start(FILE* output)
 {
 	return 0;
 }
 
 int
 process_table_header_cell(FILE* output)
 {
 	return 0;
 }
 
 int
 process_table_header_end(FILE* output)
 {
 	print_output(output, "\n");
 	return 0;
 }
 
 int
 process_table_body_start(FILE* output, int start_row)
 {
 	return 0;
 }
 
 int
 process_table_body_row_start(FILE* output)
 {
 	return 0;
 }
 
 int
 process_table_body_cell(FILE* output)
 {
 	return 0;
 }
 
 int
 process_table_body_row_end(FILE* output)
 {
 	print_output(output, "\n");
 	return 0;
 }
 
 int
 process_table_end(FILE* output)
 {
 	return 0;
 }
 
 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://"));
 }
 
 int
 process_inline_link(FILE* output, const u8* link_text)
 {
 	print_output(output, "%s", link_text);
 	return 0;
 }
 
 int
 process_link(FILE* output, const u8* link_text)
 {
 	return process_inline_link(output, link_text);
 }
 
 int
 process_inline_image(FILE* output, const u8* image_text)
 {
 	print_output(output, "%s ", image_text);
 	return 0;
 }
 
 int
 process_image(FILE* output, const u8* image_text)
 {
 	return process_inline_image(output, image_text);
 }
 
 int
 process_paralinks(FILE* output, const u8* link_prefix)
 {
 	KeyValue* pparalink = paralinks;
 	if (!skip_para_end)
 	{
 		/*
 		 *if (!output_firstcol && (paralinks_count > 0))
 		 *    print_output(output, "\n");
 		 */
 
 		/*print_output(output, "\n");*/
 	}
 	// fprintf(stderr, "PL_count=%ld\n", paralinks_count);
 	while (pparalink < paralinks + paralinks_count)
 	{
 		if (pparalink->key)
 		{
 			/*fprintf(stderr, "PL{%s=%s}\n", pparalink->key,
 				pparalink->value);*/
 			if (!output_firstcol)
 				print_output(output, "\n");
 			print_output(output, "=> %s%s%s\t%s\n",
 				url_is_local((const char*)pparalink->key)
 						&& global_link_prefix
 					? (const char*)global_link_prefix
 					: "",
 				url_is_local((const char*)pparalink->key)
 						&& link_prefix
 					? (const char*)link_prefix
 					: "",
 				pparalink->key, pparalink->value);
 			output_firstcol = 1;
 		}
 		pparalink++;
 	}
 	if (paralinks_count > 0)
 		print_output(output, "\n");
 
 	free_keyvalue(&paralinks, paralinks_count);
 	free(paralinks);
 	paralinks	= NULL;
 	paralinks_count = 0;
 	pparalinks	= paralinks;
 
 	return 0;
 }
 
 int
 process_para_end(FILE* output, const u8* link_prefix,
 	const int previous_line_blank, const int read_yaml_macros_and_links)
 {
 	if (!read_yaml_macros_and_links && !skip_para_end
 		&& !previous_line_blank)
 		print_output(output, "\n");
 	process_paralinks(output, link_prefix);
 
 	return 0;
 }
 
 int
 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)
 {
 	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))
 			{
 				state &= ~ST_LIST;
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output,
 						link_prefix);
 					process_list_end(output);
 				}
 			}
 
 			if (IN(state, ST_NUMLIST))
 			{
 				state &= ~ST_NUMLIST;
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output,
 						link_prefix);
 					process_numlist_end(output);
 				}
 			}
 
 			if (IN(state, ST_FOOTNOTE_TEXT))
 			{
 				if (!read_yaml_macros_and_links
 					&& (IN(state, ST_PARA_OPEN)))
 				{
 					process_para_end(output, link_prefix,
 						previous_line_blank,
 						read_yaml_macros_and_links);
 					output_firstcol = 1;
 				}
 				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, "%s",
 					output_firstcol && previous_line_blank
 						? ""
 						: "\n");
 				*previous_line_block = 0;
 			}
 			output_firstcol = 1;
 			skip_para_end	= 0;
 			state |= ST_PARA_OPEN;
 		}
 	}
 	return 0;
 }
 
 int
 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)
 {
 	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);
 			u8* eol = (u8*)strrchr((char*)*token, '\n');
 			if (eol)
 				output_firstcol
 					= *token + strlen((char*)*token) - eol
 					> 0;
 			else
 				output_firstcol = 0;
 		}
 	}
 	RESET_TOKEN(*token, *ptoken, *token_size);
 	return 0;
 }
 
 int
 process_inline_footnote(const u8* token, const int read_yaml_macros_and_links,
 	FILE* output)
 {
 	current_inline_footnote++;
 
 	if (read_yaml_macros_and_links)
 	{
 		size_t 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);
 
 		if (strlcpy((char*)inline_footnotes[inline_footnote_count - 1],
 			    (char*)token, token_len + 1)
 			>= token_len + 1)
 			warning(1, (u8*)"strlcpy:%d: Overflow", __LINE__);
 		*(inline_footnotes[inline_footnote_count - 1] + token_len) = 0;
 	}
 	else
 	{
 		print_output(output, "(%d)", current_inline_footnote);
 		output_firstcol = 0;
 	}
 
 	return 0;
 }
 
 int
 process_footnote(FILE* output, const u8* token, const int footnote_definition,
 	const int footnote_output)
 {
 	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)
 		{
 			CALLOC(footnotes, KeyValue, footnote_count);
 			pfootnotes = footnotes;
 		}
 		else
 		{
 			REALLOCARRAY(footnotes, KeyValue, footnote_count);
 			pfootnotes = footnotes + footnote_count - 1;
 		}
 		CALLOC(pfootnotes->key, u8, KEYSIZE);
 		if (strlcpy((char*)pfootnotes->key, (char*)token, KEYSIZE)
 			>= KEYSIZE)
 			warning(1, (u8*)"strlcpy:%d: Overflow", __LINE__);
 		pfootnotes->value      = NULL;
 		pfootnotes->value_size = 0;
 	}
 
 	if (footnote_output)
 	{
 		print_output(output, "(%d)", current_footnote);
 		output_firstcol = 0;
 	}
 
 	return 0;
 }
 
 int
 process_horizontal_rule(FILE* output, const u8* link_prefix,
 	const int previous_line_blank, const int read_yaml_macros_and_links)
 {
 	/* Temporarily break paragraph as hr is para-level */
 	if (IN(state, ST_PARA_OPEN))
 		process_para_end(output, link_prefix, previous_line_blank,
 			read_yaml_macros_and_links);
 	print_output(output, "————————————————————\n");
 	if (IN(state, ST_PARA_OPEN))
 		print_output(output, "\n");
 	return 0;
 }
 
 int
 process_formula(FILE* output, const u8* token, int display_formula)
 {
 	return 0;
 }
 
 int
 begin_article(FILE* output, const char* source_filename, 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, int first_line_in_doc,
 	int* previous_line_blank, const char* permalink_url)
 {
 	if (title)
 	{
 		process_heading_start(output, 1);
 		process_heading(output, title);
 	}
 	int save_incdir = IN(state, ST_INCDIR);
 	state &= ~ST_INCDIR;
 
 	if (header_text)
 		print_output(output, "%s\n\n", (char*)header_text);
 
 	if (author)
 		print_output(output, "%s\n\n", author);
 
 	if (date && source_filename)
 	{
 		char* link = strip_ext((const char*)source_filename);
 
 		if (ext_in_permalink
 			&& strlcat(link, timestamp_output_ext, sizeof link)
 				> sizeof link)
 			warning(1, (u8*)"strlcat:%d: Overflow", __LINE__);
 
 		free(link);
 	}
 
 	/*if (author || date || header_text || title)
 		print_output(output, "\n");*/
 
 	output_firstcol	     = author || date || header_text || title;
 	*previous_line_blank = author || header_text || title;
 
 	if (save_incdir)
 		state |= ST_INCDIR;
 
 	return 0;
 }
 
 int
 end_footnotes(FILE* output, const u8* link_prefix, const int add_footnote_div,
 	const int previous_line_blank, const int read_yaml_macros_and_links)
 {
 	size_t footnote = 0;
 
 	if (IN(state, ST_PARA_OPEN))
 	{
 		output_firstcol = 1;
 		state &= ~ST_PARA_OPEN;
 		if (paralinks_count > 0)
 			process_paralinks(output, link_prefix);
 	}
 
 	process_horizontal_rule(output, link_prefix, previous_line_blank,
 		read_yaml_macros_and_links);
 	output_firstcol = 1;
 
 	for (footnote = 0; footnote < inline_footnote_count; footnote++)
 	{
 		print_output(output, "%d. %s\n\n", footnote + 1,
 			(char*)inline_footnotes[footnote]);
 		output_firstcol = 1;
 	}
 
 	KeyValue* pfootnote = footnotes;
 	footnote	    = 0;
 	while (pfootnote && footnote < footnote_count)
 	{
 		print_output(output, "%d. %s\n\n", footnote + 1,
 			(char*)pfootnote->value);
 		output_firstcol = 1;
 		pfootnote++;
 		footnote++;
 	}
 
 	return 0;
 }
 
 int
 simple_parse_yaml_line(const u8* line, KeyValue** vars, size_t* vars_count,
 	KeyValue** pvars)
 {
 	u8* token	= NULL;
 	u8* ptoken	= NULL;
 	u8* var_key	= NULL;
 	const u8* pline = line;
 	int in_arg	= 0;
 
 	if (!line || !vars || !vars_count || !pvars)
 		exit(error(EINVAL,
 			(u8*)"simple_parse_yaml_line: Invalid argument"));
 
 	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,
 					(u8*)"simple_parse_yaml_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)
 	{
 		int found      = 0;
 		KeyValue* cvar = NULL;
 
 		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);
 			if (strlcpy((char*)(*pvars)->key, (char*)var_key,
 				    KEYSIZE)
 				>= KEYSIZE)
 				warning(1, (u8*)"strlcpy:%d: Overflow",
 					__LINE__);
 			(*pvars)->value_size = strlen((char*)token) + 1;
 			CALLOC((*pvars)->value, u8, (*pvars)->value_size);
 			if (strlcpy((char*)(*pvars)->value, (char*)token,
 				    (*pvars)->value_size)
 				>= (*pvars)->value_size)
 				warning(1, (u8*)"strlcpy:%d: Overflow",
 					__LINE__);
 		}
 	}
 	free(var_key);
 	free(token);
 	return 0;
 }
 
 int
 slweb_parse(FILE* output, const char* source_filename, const u8* buffer,
 	const int read_yaml_macros_and_links)
 {
 	u8* title		   = NULL;
 	u8* title_heading_level	   = NULL;
 	u8* header_text		   = NULL;
 	u8* author		   = NULL;
 	u8* date		   = NULL;
 	u8* permalink_url	   = NULL;
 	u8* ext_in_permalink	   = NULL;
 	u8* var_add_article_header = NULL;
 	/*u8* var_add_image_links		  = NULL;
 	u8* var_add_figcaption		  = NULL;*/
 	u8* var_add_footnote_div    = NULL;
 	u8* footer_permalink_text   = NULL;
 	u8* var_incdir_only_summary = NULL;
 	/*u8* image_file_prefix		  = NULL;*/
 	u8* link_prefix			  = NULL;
 	const u8* pbuffer		  = NULL;
 	u8* line			  = NULL;
 	u8* pline			  = NULL;
 	size_t line_len			  = 0;
 	size_t line_size		  = 0;
 	u8* token			  = NULL;
 	u8* ptoken			  = NULL;
 	size_t token_size		  = 0;
 	u8* link_text			  = NULL;
 	size_t link_size		  = 0;
 	u8* link_macro			  = NULL;
 	UBYTE heading_level		  = 0;
 	int end_tag			  = 0;
 	int first_line_in_doc		  = 1;
 	int skip_change_first_line_in_doc = 0;
 	int skip_eol			  = 0;
 	int keep_token			  = 0;
 	int previous_line_blank		  = 0;
 	int previous_line_block		  = 0;
 	int processed_start_of_line	  = 0;
 	/*int add_image_links		  = 1;
 	int add_figcaption		  = 1;*/
 	int add_footnote_div	   = 0;
 	int list_para		   = 0;
 	int footnote_at_line_start = 0;
 	size_t pline_len	   = 0;
 	int madeby_present	   = 0;
 	u8* eol			   = NULL;
 
 	if (!buffer)
 		exit(error(1, (u8*)"slweb_parse: Empty buffer"));
 
 	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;
 	pparalinks = paralinks;
 	pfootnotes = footnotes;
 	lineno	   = 0;
 
 	if (!read_yaml_macros_and_links)
 		begin_article(output, source_filename, 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',
 			first_line_in_doc, &previous_line_blank,
 			(char*)permalink_url);
 
 	RESET_TOKEN(token, ptoken, token_size);
 
 	output_firstcol = 1;
 
 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;
 	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 (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 			break;
 		}
 		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, link_prefix,
 					previous_line_blank,
 					read_yaml_macros_and_links);
 				output_firstcol = 1;
 			}
 			else
 			{
 				if (lineno == 1)
 					state |= ST_YAML;
 				else
 					state &= ~ST_YAML;
 
 				skip_change_first_line_in_doc = 1;
 			}
 			pline = NULL;
 		}
 		else if (colno == 1 && *(pline + 1) == ' ')
 		{
 			if (IN(state, ST_NUMLIST))
 			{
 				state &= ~ST_NUMLIST;
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output,
 						link_prefix);
 					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,
 						link_prefix);
 				process_list_item_start(output);
 			}
 
 			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;
 
 			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);
 			if (strlcpy((char*)pvars->key, (char*)token, KEYSIZE)
 				>= KEYSIZE)
 				warning(1, (u8*)"strlcpy:%d: Overflow",
 					__LINE__);
 			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 if (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 			break;
 		}
 		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*)" ";
 			/* Handle ~~ within footnotes, headings
 			 * and link text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 			{
 				size_t entity_len = strlen((char*)entity);
 				size_t token_len  = 0;
 
 				*ptoken	  = 0;
 				token_len = strlen((char*)token);
 
 				if (token_len + entity_len < BUFSIZE)
 				{
 					if (strlcat((char*)token, (char*)entity,
 						    token_size)
 						> token_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 					ptoken += 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, " ");
 			}
 
 			pline += 2;
 			colno += 2;
 		}
 		else if (strlen((char*)pline) > 1 && *(pline + 1) == '-')
 		{
 			u8* entity = (u8*)"-";
 			/* Handle ~- within footnotes, headings
 			 * and link text specially */
 			if (ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 			{
 				size_t entity_len = strlen((char*)entity);
 				size_t token_len  = 0;
 
 				*ptoken	  = 0;
 				token_len = strlen((char*)token);
 
 				if (token_len + entity_len < BUFSIZE)
 				{
 					if (strlcat((char*)token, (char*)entity,
 						    token_size)
 						> token_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 					ptoken += 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, "-");
 			}
 
 			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))
 			{
 				u8* tag = IN(state, ST_STRIKE) ? (u8*)"</s>"
 							       : (u8*)"<s>";
 				size_t tag_len	 = strlen((char*)tag);
 				size_t token_len = 0;
 
 				*ptoken	  = 0;
 				token_len = strlen((char*)token);
 
 				if (token_len + tag_len < BUFSIZE)
 				{
 					if (strlcat((char*)token, (char*)tag,
 						    token_size)
 						> token_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 					ptoken += tag_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)))
 					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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 			break;
 		}
 
 		if (colno == 1 && strlen((char*)pline) > 2
 			&& startswith((char*)pline, "```"))
 		{
 			state ^= ST_PRE;
 
 			if (!read_yaml_macros_and_links)
 			{
 				print_output(output, "%s```%s",
 					IN(state, ST_PRE) && !output_firstcol
 						? "\n"
 						: "",
 					IN(state, ST_PRE) ? "" : "\n\n");
 				output_firstcol = !IN(state, ST_PRE);
 			}
 
 			/* Skip the rest of the line (language) */
 			pline = NULL;
 		}
 		else if (!ANY(state, ST_PRE | ST_TAG | ST_YAML))
 		{
 			if (!ANY(state,
 				    ST_INLINE_FOOTNOTE | ST_HEADING
 					    | ST_FOOTNOTE_TEXT | ST_LINK))
 			{
 				/* 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_CODE;
 
 			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++;
 		}
 		else if (!IN(state, ST_ENT) && *(pline + 1)
 			&& isalpha(*(pline + 1)) && isascii(*(pline + 1)))
 		{
 			state |= ST_ENT;
 			pline++;
 			colno++;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case ';':
 		if (IN(state, ST_ENT))
 		{
 			state &= ~ST_ENT;
 			*ptoken = 0;
 			if (!read_yaml_macros_and_links)
 			{
 				/* TODO: Use map */
 				if (endswith((char*)token, "amp"))
 				{
 					token[strlen((char*)token)
 						- strlen("amp")]
 						= 0;
 					strcat((char*)token, "&");
 				}
 				else if (endswith((char*)token, "lt"))
 				{
 					token[strlen((char*)token) - strlen("lt")]
 						= 0;
 					strcat((char*)token, "<");
 				}
 				else if (endswith((char*)token, "gt"))
 				{
 					token[strlen((char*)token) - strlen("gt")]
 						= 0;
 					strcat((char*)token, ">");
 				}
 				else if (endswith((char*)token, "quot"))
 				{
 					token[strlen((char*)token)
 						- strlen("quot")]
 						= 0;
 					strcat((char*)token, "\"");
 				}
 				else if (endswith((char*)token, "ldquo"))
 				{
 					token[strlen((char*)token)
 						- strlen("ldquo")]
 						= 0;
 					strcat((char*)token, "“");
 				}
 				else if (endswith((char*)token, "rdquo"))
 				{
 					token[strlen((char*)token)
 						- strlen("rdquo")]
 						= 0;
 					strcat((char*)token, "”");
 				}
 			}
 			ptoken = token + strlen((char*)token);
 			pline++;
 			colno++;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	case '#':
 		if (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 			break;
 		}
 		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,
 						link_prefix);
 					process_list_end(output);
 				}
 			}
 
 			if (IN(state, ST_NUMLIST))
 			{
 				state &= ~ST_NUMLIST;
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output,
 						link_prefix);
 					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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			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))
 			{
 				/* 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))
 			{
 				/* 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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			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,
 						link_prefix);
 					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,
 						link_prefix);
 				process_list_item_start(output);
 			}
 
 			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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			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, link_prefix,
 					previous_line_blank,
 					read_yaml_macros_and_links);
 				output_firstcol = 1;
 			}
 			pline = NULL;
 		}
 		else 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,
 						link_prefix);
 					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,
 						link_prefix);
 				process_list_item_start(output);
 			}
 
 			processed_start_of_line = 1;
 			skip_eol		= 0;
 
 			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))
 			{
 				/* 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))
 
 			{
 				/* 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 ' ':
 		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)
 				process_heading_start(output, heading_level);
 			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) == ' ')
 		{
 			*ptoken = 0;
 			if (strlcat((char*)ptoken, "\n",
 				    token_size - (ptoken - token))
 				> token_size - (ptoken - token))
 				warning(1, (u8*)"strlcat:%d: Overflow",
 					__LINE__);
 			ptoken++;
 			output_firstcol = 1;
 			pline += 2;
 			colno++;
 		}
 		else if (IN(state, ST_LINK_MACRO))
 		{
 			*ptoken = 0;
 			if (strlcpy((char*)link_macro, (char*)token, BUFSIZE)
 				>= BUFSIZE)
 				warning(1, (u8*)"strlcpy:%d: Overflow",
 					__LINE__);
 			*(link_macro + strlen((char*)token)) = 0;
 			RESET_TOKEN(token, ptoken, token_size);
 			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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 			break;
 		}
 
 		if (IN(state, ST_MACRO_BODY))
 		{
 			*ptoken		 = 0;
 			size_t 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);
 					}
 					if (strlcat((char*)pmacros->value,
 						    (char*)token,
 						    pmacros->value_size)
 						> pmacros->value_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 				}
 				else
 				{
 					pmacros->value_size = token_len + 1;
 					CALLOC(pmacros->value, u8,
 						pmacros->value_size);
 					if (strlcpy((char*)pmacros->value,
 						    (char*)token,
 						    pmacros->value_size)
 						>= pmacros->value_size)
 						warning(1, (u8*)"strlcpy:%d: Overflow",
 							__LINE__);
 				}
 			}
 		}
 		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, 0, 1);
 			processed_start_of_line = 1;
 		}
 
 		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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			if (pline != line && *(pline - 1) == '<')
 				end_tag = 1;
 			pline++;
 		}
 		else 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, 1, 1);
 			processed_start_of_line = 1;
 
 			state |= ST_SUMMARY;
 
 			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;
 		}
 
 		if (IN(state, ST_TAG))
 		{
 			state &= ~ST_TAG;
 			*ptoken = 0;
 
 			if (!strcmp((char*)token, "made-by"))
 				madeby_present = 1;
 			else
 				process_tag(output, token, source_filename,
 					link_prefix, previous_line_blank,
 					first_line_in_doc,
 					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);
 			end_tag = 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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			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))
 			{
 				/* 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_KBD;
 
 			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);
 				pline = NULL;
 				break;
 
 			case '#':
 				state |= ST_TABLE_HEADER;
 				pline++;
 				colno++;
 				break;
 
 			case '-':
 				state &= ~ST_TABLE_HEADER;
 				if (!read_yaml_macros_and_links)
 					process_table_body_start(output, 0);
 				pline = NULL;
 				break;
 
 			case ' ':
 				state |= ST_TABLE;
 				if (!read_yaml_macros_and_links)
 					process_table_body_row_start(output);
 				break;
 
 			case '/':
 				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))
 			{
 				state &= ~ST_TABLE_HEADER;
 				state |= ST_TABLE_LINE;
 				pline = NULL;
 				break;
 			}
 
 			if (IN(state, ST_TABLE_LINE))
 			{
 				state &= ~ST_TABLE_LINE;
 				state |= ST_TABLE;
 				if (!read_yaml_macros_and_links)
 					process_table_body_start(output, 1);
 			}
 			else if (IN(state, ST_TABLE))
 			{
 				if (!read_yaml_macros_and_links)
 					process_table_body_row_start(output);
 			}
 			else
 			{
 				state |= ST_TABLE_HEADER;
 				if (!read_yaml_macros_and_links)
 					process_table_start(output);
 			}
 
 			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);
 				else
 					process_table_header_end(output);
 			}
 			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);
 				else
 					process_table_body_row_end(output);
 			}
 			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_CODE | ST_DISPLAY_FORMULA | ST_FORMULA
 					| ST_KBD | ST_IMAGE | ST_PRE))
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 			break;
 		}
 
 		state |= ST_HTML_TAG;
 		pline++;
 		colno++;
 		break;
 
 	case '>':
 		if (IN(state, ST_HTML_TAG))
 		{
 			state &= ~ST_HTML_TAG;
 			pline++;
 			colno++;
 			break;
 		}
 
 		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)))
 			{
 				if (IN(state, ST_PARA_OPEN))
 				{
 					print_output(output, "\n");
 					state &= ~ST_PARA_OPEN;
 				}
 				process_blockquote(output, 0);
 				output_firstcol = 0;
 			}
 
 			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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			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, 0, 1);
 			processed_start_of_line = 1;
 
 			RESET_TOKEN(token, ptoken, token_size);
 
 			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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 			break;
 		}
 
 		if (colno != 1 && *(pline - 1) == '[')
 		{
 			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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 			break;
 		}
 
 		if (IN(state, ST_FOOTNOTE_TEXT))
 		{
 			if (!read_yaml_macros_and_links
 				&& (IN(state, ST_PARA_OPEN)))
 			{
 				process_para_end(output, link_prefix,
 					previous_line_blank,
 					read_yaml_macros_and_links);
 				output_firstcol = 1;
 			}
 			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);
 			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);
 		state |= ST_LINK;
 		keep_token  = 1;
 		*link_macro = 0;
 		pline++;
 		colno++;
 
 		if (*pline == '(')
 		{
 			*ptoken = 0;
 			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)))
 		{
 			/*
 			 *                                u8*
 			 * tag = (u8*)"<span>"; size_t tag_len =
 			 * strlen(tag); size_t token_len = 0;
 			 *
 			 *                                *ptoken
 			 * = 0; token_len = strlen(token);
 			 *
 			 *                                if
 			 * (token_len + tag_len < BUFSIZE)
 			 *                                {
 			 *                                        strncat((char*)token,
 			 * tag, BUFSIZE-token_len-1); ptoken +=
 			 * tag_len;
 			 *                                }
 			 */
 
 			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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 			break;
 		}
 
 		pline_len = strlen((char*)pline);
 
 		if (IN(state, ST_LINK_SPAN) && pline_len > 1
 			&& *(pline + 1) == ']')
 		{
 			state &= ~ST_LINK_SPAN;
 			pline++;
 		}
 		else if (ANY(state, ST_LINK_SECOND_ARG | ST_IMAGE_SECOND_ARG))
 		{
 			*ptoken = 0;
 			if (!read_yaml_macros_and_links)
 			{
 				paralinks_count++;
 				if (!paralinks)
 				{
 					CALLOC(paralinks, KeyValue,
 						paralinks_count);
 					pparalinks = paralinks;
 				}
 				else
 				{
 					REALLOCARRAY(paralinks, KeyValue,
 						paralinks_count);
 					pparalinks = paralinks + paralinks_count
 						- 1;
 				}
 				pparalinks->key = (u8*)strdup((char*)token);
 				pparalinks->value_size
 					= strlen((char*)link_text) + 1;
 				pparalinks->value
 					= (u8*)strdup((char*)link_text);
 
 				if (output_firstcol
 					&& ((*(line + line_len - 1) == ']')
 						|| *(line + line_len - 1)
 							== ')'))
 				{
 					skip_eol      = 1;
 					skip_para_end = 1;
 					pline	      = NULL;
 				}
 				else
 				{
 					if (IN(state, ST_LINK_SECOND_ARG))
 						process_inline_link(output,
 							link_text);
 					else
 						process_inline_image(output,
 							link_text);
 					output_firstcol = !*link_text;
 				}
 			}
 			RESET_TOKEN(token, ptoken, token_size);
 			state &= ~(ST_LINK | ST_LINK_SECOND_ARG | ST_IMAGE
 				| ST_IMAGE_SECOND_ARG);
 			/* Difference from slweb: could be NULL */
 			if (pline)
 				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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			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);
 			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);
 			state &= ~ST_FOOTNOTE;
 			footnote_at_line_start = 0;
 			pline++;
 			colno++;
 			if (footnote_definition)
 			{
 				pline++;
 				colno++;
 				while (*pline == ' ' || *pline == '\t')
 				{
 					pline++;
 					colno++;
 				}
 				state |= ST_FOOTNOTE_TEXT;
 			}
 		}
 		else if (IN(state, ST_LINK_SECOND_ARG))
 		{
 			if (!read_yaml_macros_and_links)
 			{
 				u8* url = get_value(links, links_count, token,
 					NULL);
 				if (!url)
 					exit(error(EINVAL,
 						(u8*)"slweb_parse: get_"
 						     "value: "
 						     "Invalid "
 						     "argumen"
 						     "t"));
 				paralinks_count++;
 				if (!paralinks)
 				{
 					CALLOC(paralinks, KeyValue,
 						paralinks_count);
 					pparalinks = paralinks;
 				}
 				else
 				{
 					REALLOCARRAY(paralinks, KeyValue,
 						paralinks_count);
 					pparalinks = paralinks + paralinks_count
 						- 1;
 				}
 				pparalinks->key = (u8*)strdup((char*)url);
 				pparalinks->value_size
 					= strlen((char*)link_text) + 1;
 				pparalinks->value
 					= (u8*)strdup((char*)link_text);
 
 				if (output_firstcol
 					&& ((*(line + line_len - 1) == ']')
 						|| *(line + line_len - 1)
 							== ')'))
 				{
 					skip_eol = 1;
 					pline	 = NULL;
 				}
 				else
 				{
 					process_link(output, link_text);
 					output_firstcol = !*link_text;
 				}
 			}
 			RESET_TOKEN(token, ptoken, token_size);
 			state &= ~(ST_LINK | ST_LINK_SECOND_ARG);
 			/* Difference from slweb: could be NULL */
 			if (pline)
 			{
 				pline++;
 				colno++;
 			}
 		}
 		else if (IN(state, ST_IMAGE_SECOND_ARG))
 		{
 			if (!read_yaml_macros_and_links)
 			{
 				u8* url = get_value(links, links_count, token,
 					NULL);
 				if (!url)
 					exit(error(EINVAL,
 						(u8*)"slweb_parse: get_"
 						     "value: "
 						     "Invalid "
 						     "argumen"
 						     "t"));
 				paralinks_count++;
 				if (!paralinks)
 				{
 					CALLOC(paralinks, KeyValue,
 						paralinks_count);
 					pparalinks = paralinks;
 				}
 				else
 				{
 					REALLOCARRAY(paralinks, KeyValue,
 						paralinks_count);
 					pparalinks = paralinks + paralinks_count
 						- 1;
 				}
 				pparalinks->key = (u8*)strdup((char*)url);
 				pparalinks->value_size
 					= strlen((char*)link_text) + 1;
 				pparalinks->value
 					= (u8*)strdup((char*)link_text);
 
 				if (output_firstcol
 					&& ((*(line + line_len - 1) == ']')
 						|| *(line + line_len - 1)
 							== ')'))
 				{
 					skip_eol = 1;
 					pline	 = NULL;
 				}
 				else
 				{
 					process_image(output, link_text);
 					output_firstcol = !*link_text;
 				}
 			}
 			RESET_TOKEN(token, ptoken, token_size);
 			state &= ~(ST_IMAGE | ST_IMAGE_SECOND_ARG);
 			/* Difference from slweb: could be NULL */
 			if (pline)
 			{
 				pline++;
 				colno++;
 			}
 		}
 		else if (strlen((char*)pline) > 1)
 		{
 			size_t token_len = 0;
 			switch (*(pline + 1))
 			{
 			case ':':
 				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);
 				if (strlcpy((char*)plinks->key, (char*)token,
 					    KEYSIZE)
 					>= KEYSIZE)
 					warning(1, (u8*)"strlcpy:%d: Overflow",
 						__LINE__);
 				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;
 				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);
 				}
 				if (strlcpy((char*)link_text, (char*)token,
 					    link_size)
 					>= link_size)
 					warning(1, (u8*)"strlcpy:%d: Overflow",
 						__LINE__);
 				*(link_text + token_len) = 0;
 				pline += 2;
 				colno += 2;
 				RESET_TOKEN(token, ptoken, token_size);
 				keep_token = 0;
 				if (IN(state, ST_LINK))
 					state |= ST_LINK_SECOND_ARG;
 				else
 					state |= ST_IMAGE_SECOND_ARG;
 				break;
 			default:
 				CHECKCOPY(token, ptoken, token_size, pline);
 				colno++;
 				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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			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);
 			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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			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;
 		}
 		else if (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 			break;
 		}
 
 		if (strlen((char*)pline) > 1 && *(pline + 1) == '$')
 		{
 			if (IN(state, ST_FORMULA))
 				exit(error(1,
 					(u8*)"slweb_parse: 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;
 
 			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(1,
 					(u8*)"slweb_parse: 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;
 
 			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 (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 			break;
 		}
 		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))
 			{
 				state &= ~ST_LIST;
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output,
 						link_prefix);
 					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,
 						link_prefix);
 				process_list_item_start(output);
 			}
 
 			processed_start_of_line = 1;
 			skip_eol		= 0;
 
 			state |= ST_NUMLIST;
 
 			pline += 2;
 			colno += 2;
 		}
 		else
 		{
 			CHECKCOPY(token, ptoken, token_size, pline);
 			colno++;
 		}
 		break;
 
 	default:
 		if (IN(state, ST_HTML_TAG))
 		{
 			pline++;
 			colno++;
 		}
 		else
 		{
 			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);
 		if (strlcpy((char*)pvars->value, (char*)token, pvars->value_size)
 			>= pvars->value_size)
 			warning(1, (u8*)"strlcpy:%d: Overflow", __LINE__);
 	}
 	else if (keep_token)
 	{
 		if (ptoken + 2 > token + token_size)
 		{
 			size_t old_size = token_size;
 			token_size += BUFSIZE;
 			REALLOC(token, u8, token_size);
 			ptoken = token + old_size - 1;
 		}
 		if (strlcat((char*)token,
 			    ANY(state, ST_IMAGE | ST_LINK) ? " " : "\n",
 			    token_size)
 			> token_size)
 			warning(1, (u8*)"strlcat:%d: Overflow", __LINE__);
 		ptoken++;
 		*ptoken = 0;
 	}
 	else
 	{
 		if (*token)
 		{
 			*ptoken		 = 0;
 			size_t 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);
 					}
 					if (strlcat((char*)pmacros->value,
 						    (char*)token,
 						    pmacros->value_size)
 						> pmacros->value_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 					if (strlcat((char*)pmacros->value, " ",
 						    pmacros->value_size)
 						> pmacros->value_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 				}
 				else
 				{
 					pmacros->value_size = BUFSIZE;
 					CALLOC(pmacros->value, u8,
 						pmacros->value_size);
 					if (strlcpy((char*)pmacros->value,
 						    (char*)token,
 						    pmacros->value_size)
 						>= pmacros->value_size)
 						warning(1, (u8*)"strlcpy:%d: Overflow",
 							__LINE__);
 					if (strlcat((char*)pmacros->value, " ",
 						    pmacros->value_size)
 						> pmacros->value_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 				}
 			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);
 					}
 					if (strlcat((char*)pfootnotes->value,
 						    (char*)token,
 						    pfootnotes->value_size)
 						> pfootnotes->value_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 					if (strlcat((char*)pfootnotes->value,
 						    " ", pfootnotes->value_size)
 						> pfootnotes->value_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 				}
 				else
 				{
 					pfootnotes->value_size = BUFSIZE;
 					CALLOC(pfootnotes->value, u8,
 						pfootnotes->value_size);
 					if (strlcpy((char*)pfootnotes->value,
 						    (char*)token,
 						    pfootnotes->value_size)
 						>= pfootnotes->value_size)
 						warning(1, (u8*)"strlcpy:%d: Overflow",
 							__LINE__);
 					if (strlcat((char*)pfootnotes->value,
 						    " ", pfootnotes->value_size)
 						> pfootnotes->value_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 				}
 				*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);
 					if (strlcpy((char*)plinks->value,
 						    (char*)token,
 						    plinks->value_size)
 						>= plinks->value_size)
 						warning(1, (u8*)"strlcpy:%d: Overflow",
 							__LINE__);
 				}
 			}
 			else if (IN(state, ST_HEADING))
 			{
 				state &= ~(ST_HEADING | ST_HEADING_TEXT);
 				if (!read_yaml_macros_and_links)
 					process_heading(output, token);
 				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 (!read_yaml_macros_and_links)
 				{
 					print_output(output, "\n;");
 					output_firstcol = 1;
 				}*/
 				if (IN(state, ST_LIST))
 					skip_eol = 1;
 				state &= ~ST_PARA_OPEN;
 			}
 
 			if (!*pbuffer && (IN(state, ST_LIST)))
 			{
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output,
 						link_prefix);
 					process_list_end(output);
 				}
 				state &= ~ST_LIST;
 			}
 
 			if (!*pbuffer && (IN(state, ST_NUMLIST)))
 			{
 				if (!read_yaml_macros_and_links)
 				{
 					process_list_item_end(output,
 						link_prefix);
 					process_numlist_end(output);
 				}
 				state &= ~ST_NUMLIST;
 			}
 
 			if (IN(state, ST_PARA_OPEN))
 			{
 				if (!read_yaml_macros_and_links)
 				{
 					process_para_end(output, link_prefix,
 						previous_line_blank,
 						read_yaml_macros_and_links);
 					output_firstcol = 1;
 				}
 
 				if (IN(state, ST_LIST))
 					skip_eol = 1;
 
 				state &= ~ST_PARA_OPEN;
 			}
 
 			if (!*pbuffer && (IN(state, ST_FOOTNOTE_TEXT)))
 			{
 				state &= ~ST_FOOTNOTE_TEXT;
 
 				*ptoken		 = 0;
 				size_t 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);
 					}
 					if (strlcat((char*)pfootnotes->value,
 						    (char*)token,
 						    pfootnotes->value_size)
 						> pfootnotes->value_size)
 						warning(1, (u8*)"strlcat:%d: Overflow",
 							__LINE__);
 				}
 				else
 				{
 					pfootnotes->value_size = token_len + 1;
 					CALLOC(pfootnotes->value, u8,
 						pfootnotes->value_size);
 					if (strlcpy((char*)pfootnotes->value,
 						    (char*)token,
 						    pfootnotes->value_size)
 						>= pfootnotes->value_size)
 						warning(1, (u8*)"strlcpy:%d: Overflow",
 							__LINE__);
 				}
 				*token = 0;
 				ptoken = token;
 			skip_footnote_text_read:;
 			}
 		}
 
 		if (IN(state, ST_BLOCKQUOTE) && (!*pbuffer || *pbuffer != '>'))
 		{
 			state &= ~ST_BLOCKQUOTE;
 			if (!read_yaml_macros_and_links)
 			{
 				process_blockquote(output, 1);
 				previous_line_block = 1;
 				output_firstcol	    = 1;
 			}
 		}
 
 		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;
 			}
 			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;
 			}
 			state &= ~ST_TABLE;
 		}
 	}
 
 	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, "%s",
 			IN(state, ST_PRE) ? "\n" : (output_firstcol ? "" : " "));
 		output_firstcol = (IN(state, ST_PRE)) || output_firstcol;
 	}
 
 	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)
 	{
 		if (!previous_line_blank)
 		{
 			if (!read_yaml_macros_and_links
 				&& IN(state, ST_PARA_OPEN))
 			{
 				if (IN(state, ST_LIST))
 					process_list_item_end(output,
 						link_prefix);
 				else
 				{
 					process_para_end(output, link_prefix,
 						previous_line_blank,
 						read_yaml_macros_and_links);
 					output_firstcol = 1;
 				}
 			}
 			else
 			{
 				process_para_end(output, link_prefix,
 					previous_line_blank,
 					read_yaml_macros_and_links);
 				output_firstcol = 1;
 			}
 		}
 		else
 		{
 			process_para_end(output, link_prefix,
 				previous_line_blank,
 				read_yaml_macros_and_links);
 			output_firstcol = 1;
 		}
 		previous_line_blank = 1;
 	}
 	else
 		previous_line_blank = 0;
 
 	/* Lasts until the end of line */
 	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, link_prefix, add_footnote_div,
 				previous_line_blank,
 				read_yaml_macros_and_links);
 
 		if (paralinks_count > 0)
 			process_paralinks(output, link_prefix);
 
 		if (madeby_present)
 		{
 			process_madeby(output);
 			output_firstcol = 1;
 		}
 	}
 
 	free(link_text);
 	free(link_macro);
 	free(token);
 	free(line);
 
 	return 0;
 }
 
 int
 main(const int argc, const char** argv)
 {
 	const char* arg;
 	Command cmd	   = CMD_NONE;
 	int result	   = 0;
 	FILE* input	   = NULL;
 	FILE* output	   = stdout;
 	u8* buffer	   = NULL;
 	size_t buffer_size = 0;
 
 	basedir_size = 2;
 	CALLOC(basedir, char, basedir_size);
 	*basedir = '.';
 
 	while ((arg = *++argv))
 	{
 		if (*arg == '-')
 		{
 			arg++;
 			char c = *arg++;
 			int result;
 
 			if (c == '-')
 			{
 				if (!strcmp(arg, "full-version"))
 					cmd = CMD_FULL_VERSION;
 				else if (!strcmp(arg, "version"))
 					cmd = CMD_VERSION;
 				else if (startswith(arg, "basedir"))
 				{
 					arg += strlen("basedir");
 					result = set_basedir(&basedir,
 						&basedir_size, arg);
 					if (result)
 						return 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)
 						return result;
 				}
 				else if (!strcmp(arg, "help"))
 					return usage();
 				else
 				{
 					error(EINVAL,
 						(u8*)"main: Invalid "
 						     "argument: --%s",
 						arg);
 					return usage();
 				}
 			}
 			else
 			{
 				switch (c)
 				{
 				case 'd':
 					cmd = CMD_BASEDIR;
 					break;
 				case 'h':
 					return usage();
 					break;
 				case 'p':
 					cmd = CMD_LINK_PREFIX;
 					break;
 				case 'V':
 					cmd = CMD_FULL_VERSION;
 					break;
 				case 'v':
 					cmd = CMD_VERSION;
 					break;
 				default:
 					error(EINVAL,
 						(u8*)"main: Invalid "
 						     "argument: -%c",
 						c);
 					return usage();
 				}
 			}
 		}
 		else
 		{
 			int result;
 
 			if (cmd == CMD_BASEDIR)
 			{
 				result = set_basedir(&basedir, &basedir_size,
 					arg);
 				if (result)
 					return result;
 			}
 			else if (cmd == CMD_LINK_PREFIX)
 			{
 				result = set_global_link_prefix(&global_link_prefix,
 					&global_link_prefix_size, arg);
 				if (result)
 					return result;
 			}
 			else
 				input_filename = arg;
 			cmd = CMD_NONE;
 		}
 	}
 
 	if (cmd == CMD_BASEDIR)
 		return error(1, (u8*)"main: set_basedir: Argument required");
 
 	if (cmd == CMD_FULL_VERSION)
 		return version(1);
 	else if (cmd == CMD_VERSION)
 		return version(0);
 
 	if (input_filename)
 	{
 		int result = read_file_into_buffer(&input, &buffer,
 			&buffer_size, input_filename, &input_dirname);
 		if (result)
 			exit(result);
 	}
 	else
 	{
 		u8* bufline	   = NULL;
 		size_t buffer_len  = 0;
 		size_t buffer_size = 0;
 		size_t bufline_len = 0;
 
 		input = stdin;
 
 		CALLOC(input_dirname, char, 2);
 		*input_dirname = '.';
 
 		CALLOC(bufline, u8, BUFSIZE);
 		buffer_size = BUFSIZE;
 		CALLOC(buffer, u8, buffer_size);
 
 		while (!feof(input))
 		{
 			u8* eol = NULL;
 			if (!fgets((char*)bufline, BUFSIZE - 1, input))
 				break;
 			eol = (u8*)strchr((char*)bufline, '\n');
 			if (eol)
 				*(eol + 1) = 0;
 			bufline_len = strlen((char*)bufline);
 			if (buffer_len + bufline_len + 1 > buffer_size)
 			{
 				buffer_size += BUFSIZE;
 				REALLOC(buffer, u8, buffer_size);
 			}
 			if (strlcat((char*)buffer, (char*)bufline, buffer_size)
 				> buffer_size)
 				warning(1, (u8*)"strlcat:%d: Overflow",
 					__LINE__);
 			buffer_len += bufline_len;
 		}
 		free(bufline);
 	}
 
 	vars		      = NULL;
 	vars_count	      = 0;
 	macros		      = NULL;
 	macros_count	      = 0;
 	links		      = NULL;
 	links_count	      = 0;
 	paralinks	      = NULL;
 	paralinks_count	      = 0;
 	footnotes	      = NULL;
 	footnote_count	      = 0;
 	inline_footnotes      = NULL;
 	inline_footnote_count = 0;
 
 	/* First pass: read YAML, macros and links */
 	result = slweb_parse(output, input_filename, buffer, 1);
 
 	if (result)
 	{
 		slweb_cleanup();
 		free(buffer);
 		return result;
 	}
 
 	state			= ST_NONE;
 	current_footnote	= 0;
 	current_inline_footnote = 0;
 
 	/* Second pass: parse and output */
 	result = slweb_parse(output, input_filename, buffer, 0);
 
 	slweb_cleanup();
 	free(buffer);
 
 	return result;
 }