smu

smu.c (17096B)

#include <ctype.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef __OpenBSD__
#include <unistd.h>
#else
#define pledge(p1,p2) 0
#endif

#define LENGTH(x)  sizeof(x)/sizeof(x[0])
#define ADDC(b,i)  if (i % BUFSIZ == 0) { b = realloc(b, (i + BUFSIZ)); if (!b) eprint("realloc"); } b[i]

typedef int (*Parser)(const char *, const char *, int);
typedef struct {
	char *search;
	int process;
	char *before, *after;
} Tag;

static int doamp(const char *begin, const char *end, int newblock);       /* Parser for & */
static int docomment(const char *begin, const char *end, int newblock);   /* Parser for html-comments */
static int dogtlt(const char *begin, const char *end, int newblock);      /* Parser for < and > */
static int dohtml(const char *begin, const char *end, int newblock);      /* Parser for html */
static int dolineprefix(const char *begin, const char *end, int newblock);/* Parser for line prefix tags */
static int dolink(const char *begin, const char *end, int newblock);      /* Parser for links and images */
static int dolist(const char *begin, const char *end, int newblock);      /* Parser for lists */
static int doparagraph(const char *begin, const char *end, int newblock); /* Parser for paragraphs */
static int doreplace(const char *begin, const char *end, int newblock);   /* Parser for simple replaces */
static int doshortlink(const char *begin, const char *end, int newblock); /* Parser for links and images */
static int dosurround(const char *begin, const char *end, int newblock);  /* Parser for surrounding tags */
static int dounderline(const char *begin, const char *end, int newblock); /* Parser for underline tags */
static void *ereallocz(void *p, size_t size);
static void hprint(const char *begin, const char *end);                   /* Escapes HTML and prints it to output */
static void hprintattr(const char *begin, const char *end);               /* Escapes HTML for attributes and prints it to output */
static void process(const char *begin, const char *end, int isblock);     /* Processes range between begin and end. */

/* list of parsers */
static Parser parsers[] = { dounderline, docomment, dolineprefix,
                            dolist, doparagraph, dogtlt, dosurround, dolink,
                            doshortlink, dohtml, doamp, doreplace };
static int lazyimg = 0, nohtml = 0;

static Tag lineprefix[] = {
	{ "    ",	0,	"<pre><code>", "\n</code></pre>" },
	{ "\t",		0,	"<pre><code>", "\n</code></pre>" },
	{ ">",		2,	"<blockquote>",	"</blockquote>" },
	{ "###### ",	1,	"<h6>",		"</h6>" },
	{ "##### ",	1,	"<h5>",		"</h5>" },
	{ "#### ",	1,	"<h4>",		"</h4>" },
	{ "### ",	1,	"<h3>",		"</h3>" },
	{ "## ",	1,	"<h2>",		"</h2>" },
	{ "# ",		1,	"<h1>",		"</h1>" },
	{ "- - -\n",	1,	"<hr />",	""},
	{ "---\n",	1,	"<hr />",	""},
};

static Tag underline[] = {
	{ "=",		1,	"<h1>",		"</h1>\n" },
	{ "-",		1,	"<h2>",		"</h2>\n" },
};

static Tag surround[] = {
	{ "``",		0,	"<code>",	"</code>" },
	{ "`",		0,	"<code>",	"</code>" },
	{ "___",	1,	"<strong><em>",	"</em></strong>" },
	{ "***",	1,	"<strong><em>",	"</em></strong>" },
	{ "__",		1,	"<strong>",	"</strong>" },
	{ "**",		1,	"<strong>",	"</strong>" },
	{ "_",		1,	"<em>",		"</em>" },
	{ "*",		1,	"<em>",		"</em>" },
};

static const char *replace[][2] = {
	{ "\\\\",	"\\" },
	{ "\\`",	"`" },
	{ "\\*",	"*" },
	{ "\\_",	"_" },
	{ "\\{",	"{" },
	{ "\\}",	"}" },
	{ "\\[",	"[" },
	{ "\\]",	"]" },
	{ "\\(",	"(" },
	{ "\\)",	")" },
	{ "\\#",	"#" },
	{ "\\+",	"+" },
	{ "\\-",	"-" },
	{ "\\.",	"." },
	{ "\\!",	"!" },
};

static const char *insert[][2] = {
	{ "  \n",	"<br />" },
};

void
eprint(const char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	vfprintf(stderr, format, ap);
	va_end(ap);
	exit(1);
}

int
doamp(const char *begin, const char *end, int newblock)
{
	const char *p;

	if (*begin != '&')
		return 0;
	if (!nohtml) {
		for (p = begin + 1; p != end && !strchr("; \\\n\t", *p); p++)
			;
		if (p == end || *p == ';')
			return 0;
	}
	fputs("&amp;", stdout);
	return 1;
}

int
dogtlt(const char *begin, const char *end, int newblock)
{
	int brpos;
	char c;

	if (nohtml || begin + 1 >= end)
		return 0;
	brpos = begin[1] == '>';
	if (!brpos && *begin != '<')
		return 0;
	c = begin[brpos ? 0 : 1];
	if (!brpos && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z')) {
		fputs("&lt;", stdout);
		return 1;
	} else if (brpos && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && !strchr("/\"'", c)) {
		fprintf(stdout, "%c&gt;",c);
		return 2;
	}
	return 0;
}

int
docomment(const char *begin, const char *end, int newblock)
{
	char *p;

	if (nohtml || strncmp("<!--", begin, 4))
		return 0;
	p = strstr(begin, "-->");
	if (!p || p + 3 >= end)
		return 0;
	fprintf(stdout, "%.*s\n", (int)(p + 3 - begin), begin);
	return (p + 3 - begin) * (newblock ? -1 : 1);
}

int
dohtml(const char *begin, const char *end, int newblock)
{
	const char *p, *tag, *tagend;

	if (nohtml || begin + 2 >= end)
		return 0;
	p = begin;
	if (p[0] != '<' || !isalpha((unsigned char)p[1]))
		return 0;
	p++;
	tag = p;
	for (; isalnum((unsigned char)*p) && p < end; p++)
		;
	tagend = p;
	if (p > end || tag == tagend)
		return 0;
	while ((p = strstr(p, "</")) && p < end) {
		p += 2;
		if (strncmp(p, tag, tagend - tag) == 0 && p[tagend - tag] == '>') {
			p++;
			fwrite(begin, 1, p - begin + tagend - tag + 1, stdout);
			return p - begin + tagend - tag + 1;
		}
	}
	if ((p = strchr(tagend, '>'))) {
		fwrite(begin, 1, p - begin + 2, stdout);
		return p - begin + 2;
	} else {
		return 0;
	}
}

int
dolineprefix(const char *begin, const char *end, int newblock)
{
	unsigned int i, j, l;
	char *buffer;
	const char *p;

	if (newblock)
		p = begin;
	else if (*begin == '\n')
		p = begin + 1;
	else
		return 0;
	for (i = 0; i < LENGTH(lineprefix); i++) {
		l = strlen(lineprefix[i].search);
		if (end - p < l)
			continue;
		if (strncmp(lineprefix[i].search, p, l))
			continue;
		if (*begin == '\n')
			putc('\n', stdout);
		fputs(lineprefix[i].before, stdout);
		if (lineprefix[i].search[l-1] == '\n') {
			putc('\n', stdout);
			return l - 1;
		}
		if (!(buffer = malloc(BUFSIZ)))
			eprint("malloc");
		buffer[0] = '\0';

		/* Collect lines into buffer while they start with the prefix */
		j = 0;
		while ((strncmp(lineprefix[i].search, p, l) == 0) && p + l < end) {
			p += l;

			/* Special case for blockquotes: optional space after > */
			if (lineprefix[i].search[0] == '>' && *p == ' ') {
				p++;
			}

			while (p < end) {
				ADDC(buffer, j) = *p;
				j++;
				if (*(p++) == '\n')
					break;
			}
		}

		/* Skip empty lines in block */
		while (*(buffer + j - 1) == '\n')
			j--;

		ADDC(buffer, j) = '\0';
		if (lineprefix[i].process)
			process(buffer, buffer + strlen(buffer), lineprefix[i].process >= 2);
		else
			hprint(buffer, buffer + strlen(buffer));
		puts(lineprefix[i].after);
		free(buffer);
		return -(p - begin);
	}
	return 0;
}

int
dolink(const char *begin, const char *end, int newblock)
{
	long width = 0, height = 0;
	int img, len, parens_depth = 1;
	char *numend;
	const char *desc, *link, *p, *q, *descend, *linkend;
	const char *title = NULL, *titleend = NULL;

	if (*begin == '[')
		img = 0;
	else if (strncmp(begin, "![", 2) == 0)
		img = 1;
	else
		return 0;
	p = desc = begin + 1 + img;
	if (!(p = strstr(desc, "](")) || p > end)
		return 0;
	for (q = strstr(desc, "!["); q && q < end && q < p; q = strstr(q + 1, "!["))
		if (!(p = strstr(p + 1, "](")) || p > end)
			return 0;
	descend = p;
	link = p + 2;

	/* find end of link while handling nested parens */
	q = link;
	while (parens_depth) {
		if (!(q = strpbrk(q, "()")) || q > end)
			return 0;
		if (*q == '(')
			parens_depth++;
		else
			parens_depth--;
		if (parens_depth && q < end)
			q++;
	}

	linkend = q;
	if (*link == '<' && *(linkend - 1) == '>') {
		link++;
		linkend--;
	} else {
		/* trim leading spaces */
		for (p = link; p < q && isspace((unsigned char)*p); p++)
			;

		for (link = p; p < q; p++) {
			if (*p == '=' && img && p != link &&
			    isspace((unsigned char)p[-1])) {
				/* image dimensions */
				linkend = p;
				width = strtol(++p, &numend, 10);
				p = numend;
				if (*numend == 'x')
					height = strtol(++p, &numend, 10);
			} else if ((*p == '\'' || *p == '"') && p != link &&
			           isspace((unsigned char)p[-1])) {
				/* title attribute: for links and images */
				linkend = p;
				title = ++p;
				if ((titleend = strchr(title, *(p - 1)))) {
					if (titleend >= q)
						titleend = q;
					else
						p = titleend;
				}
			}
		}

		/* trim trailing spaces from link */
		for (; linkend > link && isspace((unsigned char)linkend[-1]); linkend--)
			;
	}

	len = q + 1 - begin;
	if (img) {
		fputs("<img src=\"", stdout);
		hprintattr(link, linkend);
		fputs("\" alt=\"", stdout);
		hprintattr(desc, descend);
		fputs("\" ", stdout);
		if (title && titleend && title != titleend) {
			fputs("title=\"", stdout);
			hprintattr(title, titleend);
			fputs("\" ", stdout);
		}
		if (width > 0)
			printf("width=\"%ld\" ", width);
		if (height > 0)
			printf("height=\"%ld\" ", height);
		if (width > 0 && height > 0 && lazyimg)
			fputs("loading=\"lazy\" ", stdout);
		fputs("/>", stdout);
	} else {
		fputs("<a href=\"", stdout);
		hprintattr(link, linkend);
		fputs("\"", stdout);
		if (title && titleend && title != titleend) {
			fputs(" title=\"", stdout);
			hprintattr(title, titleend);
			fputs("\"", stdout);
		}
		fputs(">", stdout);
		process(desc, descend, 0);
		fputs("</a>", stdout);
	}
	return len;
}

int
dolist(const char *begin, const char *end, int newblock)
{
	unsigned int i, j, indent, run, ul, isblock;
	const char *p, *q;
	char *buffer = NULL;
	char marker;

	isblock = 0;
	if (newblock)
		p = begin;
	else if (*begin == '\n')
		p = begin + 1;
	else
		return 0;
	q = p;
	if (*p == '-' || *p == '*' || *p == '+') {
		ul = 1;
		marker = *p;
	} else {
		ul = 0;
		for (; p < end && *p >= '0' && *p <= '9'; p++)
			;
		if (p >= end || *p != '.')
			return 0;
	}
	p++;
	if (p >= end || !(*p == ' ' || *p == '\t'))
		return 0;
	for (p++; p != end && (*p == ' ' || *p == '\t'); p++)
		;
	indent = p - q;
	buffer = ereallocz(buffer, BUFSIZ);
	if (!newblock)
		putc('\n', stdout);
	fputs(ul ? "<ul>\n" : "<ol>\n", stdout);
	run = 1;
	for (; p < end && run; p++) {
		for (i = 0; p < end && run; p++, i++) {
			if (*p == '\n') {
				if (p + 1 == end) {
					break;
				} else {
					/* Handle empty lines */
					for (q = p + 1; (*q == ' ' || *q == '\t') && q < end; q++)
						;
					if (*q == '\n') {
						ADDC(buffer, i) = '\n';
						i++;
						run = 0;
						isblock++;
						p = q;
					}
				}
				q = p + 1;
				j = 0;
				if (ul && *q == marker) {
					j = 1;
				} else if (!ul) {
					for (; q + j != end && q[j] >= '0' && q[j] <= '9' && j < indent; j++)
						;
					if (q + j == end)
						break;
					if (j > 0 && q[j] == '.')
						j++;
					else
						j = 0;
				}
				if (q + indent < end)
					for (; (q[j] == ' ' || q[j] == '\t') && j < indent; j++)
						;
				if (j == indent) {
					ADDC(buffer, i) = '\n';
					i++;
					p += indent;
					run = 1;
					if (*q == ' ' || *q == '\t')
						p++;
					else
						break;
				} else if (j < indent) {
					run = 0;
				}
			}
			ADDC(buffer, i) = *p;
		}
		ADDC(buffer, i) = '\0';
		fputs("<li>", stdout);
		process(buffer, buffer + i, isblock > 1 || (isblock == 1 && run));
		fputs("</li>\n", stdout);
	}
	fputs(ul ? "</ul>\n" : "</ol>\n", stdout);
	free(buffer);
	p--;
	while (*(--p) == '\n')
		;

	return -(p - begin + 1);
}

int
doparagraph(const char *begin, const char *end, int newblock)
{
	const char *p;

	if (!newblock)
		return 0;
	p = strstr(begin, "\n\n");
	if (!p || p > end)
		p = end;
	if (p - begin <= 1)
		return 0;
	fputs("<p>", stdout);
	process(begin, p, 0);
	fputs("</p>\n", stdout);

	return -(p - begin);
}

int
doreplace(const char *begin, const char *end, int newblock)
{
	unsigned int i, l;

	for (i = 0; i < LENGTH(insert); i++)
		if (strncmp(insert[i][0], begin, strlen(insert[i][0])) == 0)
			fputs(insert[i][1], stdout);
	for (i = 0; i < LENGTH(replace); i++) {
		l = strlen(replace[i][0]);
		if (end - begin < l)
			continue;
		if (strncmp(replace[i][0], begin, l) == 0) {
			fputs(replace[i][1], stdout);
			return l;
		}
	}
	return 0;
}

int
doshortlink(const char *begin, const char *end, int newblock)
{
	const char *p, *c;
	int ismail = 0;

	if (*begin != '<')
		return 0;
	for (p = begin + 1; p != end; p++) {
		switch(*p) {
		case ' ':
		case '\t':
		case '\n':
			return 0;
		case '#':
		case ':':
			ismail = -1;
			break;
		case '@':
			if (ismail == 0)
				ismail = 1;
			break;
		case '>':
			if (ismail == 0)
				return 0;
			fputs("<a href=\"", stdout);
			if (ismail == 1) {
				/* mailto: */
				fputs("&#x6D;&#x61;i&#x6C;&#x74;&#x6F;:", stdout);
				for (c = begin + 1; *c != '>'; c++)
					fprintf(stdout, "&#%u;", *c);
				fputs("\">", stdout);
				for (c = begin + 1; *c != '>'; c++)
					fprintf(stdout, "&#%u;", *c);
			} else {
				hprintattr(begin + 1, p);
				fputs("\">", stdout);
				hprint(begin + 1, p);
			}
			fputs("</a>", stdout);
			return p - begin + 1;
		}
	}
	return 0;
}

int
dosurround(const char *begin, const char *end, int newblock)
{
	unsigned int i, l;
	const char *p, *start, *stop;

	for (i = 0; i < LENGTH(surround); i++) {
		l = strlen(surround[i].search);
		if (end - begin < 2*l || strncmp(begin, surround[i].search, l) != 0)
			continue;
		start = begin + l;
		p = start - 1;
		do {
			stop = p;
			p = strstr(p + 1, surround[i].search);
		} while (p && p[-1] == '\\');
		if (p && p[-1] != '\\')
			stop = p;
		if (!stop || stop < start || stop >= end)
			continue;
		fputs(surround[i].before, stdout);

		/* Single space at start and end are ignored */
		if (*start == ' ' && *(stop - 1) == ' ') {
			start++;
			stop--;
			l++;
		}

		if (surround[i].process)
			process(start, stop, 0);
		else
			hprint(start, stop);
		fputs(surround[i].after, stdout);
		return stop - begin + l;
	}
	return 0;
}

int
dounderline(const char *begin, const char *end, int newblock)
{
	unsigned int i, j, l;
	const char *p;

	if (!newblock)
		return 0;
	p = begin;
	for (l = 0; p + l != end && p[l] != '\n'; l++)
		;
	p += l + 1;
	if (l == 0)
		return 0;
	for (i = 0; i < LENGTH(underline); i++) {
		for (j = 0; p + j != end && p[j] != '\n' && p[j] == underline[i].search[0]; j++)
			;
		if (j == l || (p[j] == '\n' && j > 3)) {
			fputs(underline[i].before, stdout);
			if (underline[i].process)
				process(begin, begin + l, 0);
			else
				hprint(begin, begin + l);
			fputs(underline[i].after, stdout);
			return -(j + p - begin);
		}
	}
	return 0;
}

void *
ereallocz(void *p, size_t size)
{
	void *res;

	res = realloc(p, size);
	if (!res)
		eprint("realloc: %zu bytes\n", size);
	return res;
}

void
hprintattr(const char *begin, const char *end)
{
	const char *p;

	for (p = begin; p != end; p++) {
		if (*p == '&')
			fputs("&amp;", stdout);
		else if (*p == '"')
			fputs("&quot;", stdout);
		else if (*p == '>')
			fputs("&gt;", stdout);
		else if (*p == '<')
			fputs("&lt;", stdout);
		else
			putc(*p, stdout);
	}
}

void
hprint(const char *begin, const char *end)
{
	const char *p;

	for (p = begin; p != end; p++) {
		if (*p == '&')
			fputs("&amp;", stdout);
		else if (*p == '>')
			fputs("&gt;", stdout);
		else if (*p == '<')
			fputs("&lt;", stdout);
		else
			putc(*p, stdout);
	}
}

void
process(const char *begin, const char *end, int newblock)
{
	const char *p, *q;
	int affected;
	unsigned int i;

	for (p = begin; p < end;) {
		if (newblock)
			while (*p == '\n')
				if (++p == end)
					return;
		affected = 0;
		for (i = 0; i < LENGTH(parsers) && !affected; i++)
			affected = parsers[i](p, end, newblock);
		p += abs(affected);
		if (!affected) {
			if (nohtml)
				hprint(p, p + 1);
			else
				putc(*p, stdout);
			p++;
		}
		for (q = p; q != end && *q == '\n'; q++)
			;
		if (q == end)
			return;
		else if (p[0] == '\n' && p + 1 != end && p[1] == '\n')
			newblock = 1;
		else
			newblock = affected < 0;
	}
}

void
usage(char **argv)
{
	eprint("usage: %s [-l] [-n] [file]\n", argv[0]);
}

int
main(int argc, char *argv[])
{
	FILE *source = stdin;
	char *buffer = NULL;
	int s, i;
	unsigned long len, bsize;

	for (i = 1; i < argc; i++) {
		if (!strcmp("-v", argv[i])) {
			eprint("smu v%s\n", VERSION);
		} else if (!strcmp("-n", argv[i])) {
			nohtml = 1;
		} else if (!strcmp("-l", argv[i])) {
			lazyimg = 1;
		} else if (argv[i][0] != '-') {
			break; /* file specified */
		} else if (!strcmp("--", argv[i])) {
			i++;
			break;
		} else {
			usage(argv);
		}
	}
	if (i < argc && !(source = fopen(argv[i], "r")))
		eprint("fopen: %s: %s\n", argv[i], strerror(errno));

	if (pledge("stdio", NULL) == -1)
		eprint("pledge");

	bsize = 2 * BUFSIZ;
	buffer = ereallocz(buffer, bsize);
	len = 0;
	while ((s = fread(buffer + len, 1, BUFSIZ, source))) {
		len += s;
		if (BUFSIZ + len + 1 > bsize) {
			bsize += BUFSIZ;
			if (!(buffer = realloc(buffer, bsize)))
				eprint("realloc");
		}
	}
	buffer[len] = '\0';
	process(buffer, buffer + len, 1);
	free(buffer);
	if (source != stdin)
		fclose(source);

	return 0;
}