===================================================================
RCS file: /cvs/texi2mdoc/util.c,v
retrieving revision 1.8
retrieving revision 1.34
diff -u -p -r1.8 -r1.34
--- texi2mdoc/util.c	2015/02/23 11:56:39	1.8
+++ texi2mdoc/util.c	2015/03/19 09:53:36	1.34
@@ -1,4 +1,4 @@
-/*	$Id: util.c,v 1.8 2015/02/23 11:56:39 kristaps Exp $ */
+/*	$Id: util.c,v 1.34 2015/03/19 09:53:36 schwarze Exp $ */
 /*
  * Copyright (c) 2015 Kristaps Dzonsons <kristaps@bsd.lv>
  *
@@ -20,8 +20,6 @@
 #include <assert.h>
 #include <ctype.h>
 #include <fcntl.h>
-#include <getopt.h>
-#include <libgen.h>
 #include <limits.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -33,6 +31,44 @@
 #include "extern.h"
 
 /*
+ * Table of macros.
+ * These ABSOLUTELY MUST BE 2 or three characters long.
+ */
+static	const char *const mdocs[] = {
+	"Ap",		"Dd",		"Dt",		"Os",
+	"Sh",		"Ss",		"Pp",		"D1",
+	"Dl",		"Bd",		"Ed",		"Bl",
+	"El",		"It",		"Ad",		"An",
+	"Ar",		"Cd",		"Cm",		"Dv",
+	"Er",		"Ev",		"Ex",		"Fa",
+	"Fd",		"Fl",		"Fn",		"Ft",
+	"Ic",		"In",		"Li",		"Nd",
+	"Nm",		"Op",		"Ot",		"Pa",
+	"Rv",		"St",		"Va",		"Vt",
+	"Xr",		"%A",		"%B",		"%D",
+	"%I",		"%J",		"%N",		"%O",
+	"%P",		"%R",		"%T",		"%V",
+	"Ac",		"Ao",		"Aq",		"At",
+	"Bc",		"Bf",		"Bo",		"Bq",
+	"Bsx",		"Bx",		"Db",		"Dc",
+	"Do",		"Dq",		"Ec",		"Ef",
+	"Em",		"Eo",		"Fx",		"Ms",
+	"No",		"Ns",		"Nx",		"Ox",
+	"Pc",		"Pf",		"Po",		"Pq",
+	"Qc",		"Ql",		"Qo",		"Qq",
+	"Re",		"Rs",		"Sc",		"So",
+	"Sq",		"Sm",		"Sx",		"Sy",
+	"Tn",		"Ux",		"Xc",		"Xo",
+	"Fo",		"Fc",		"Oo",		"Oc",
+	"Bk",		"Ek",		"Bt",		"Hf",
+	"Fr",		"Ud",		"Lb",		"Lp",
+	"Lk",		"Mt",		"Brq",		"Bro",
+	"Brc",		"%C",		"Es",		"En",
+	"Dx",		"%Q",		"br",		"sp",
+	"%U",		"Ta",		"ll",		NULL,
+	};
+
+/*
  * Unmap the top-most file in the stack of files currently opened (that
  * is, nested calls to parsefile()).
  */
@@ -43,7 +79,7 @@ texifilepop(struct texi *p)
 
 	assert(p->filepos > 0);
 	f = &p->files[--p->filepos];
-	munmap(f->map, f->mapsz);
+	free(f->map);
 }
 
 static void
@@ -67,7 +103,119 @@ texivaluefree(struct texivalue *p)
 	free(p->value);
 }
 
+static void
+texidex_free(struct texidex *p)
+{
+	size_t	 i;
+
+	for (i = 0; i < p->indexsz; i++)
+		free(p->index[i].term);
+
+	free(p->index);
+	free(p->name);
+	p->index = NULL;
+	p->indexsz = 0;
+}
+
 /*
+ * Add the text beginning at "index" and of "sz" bytes to the index
+ * named "tok" with name size "toksz".
+ * This will also output the necessary mdoc(7) to construct the index.
+ */
+void
+texindex(struct texi *p, const char *tok,
+	size_t toksz, const char *index, size_t sz)
+{
+	size_t	 i, isz;
+#ifdef HAVE_INDEX
+	char	*cp;
+#endif
+
+	if (0 == sz) {
+		texiwarn(p, "zero-length index entry");
+		return;
+	}
+
+	/* Look for the index.  (Must be found.) */
+	for (i = 0; i < p->indexsz; i++) {
+		if (strlen(p->indexs[i].name) != toksz)
+			continue;
+		if (strncmp(p->indexs[i].name, tok, toksz))
+			continue;
+		break;
+	}
+
+	assert(i < p->indexsz);
+	isz = p->indexs[i].indexsz;
+	/* Reallocate index's terms. */
+	p->indexs[i].index = realloc
+		(p->indexs[i].index,
+		 (isz + 1) * sizeof(struct texiterm));
+	if (NULL == p->indexs[i].index)
+		texiabort(p, NULL);
+
+	/* Add term to term array. */
+	p->indexs[i].index[isz].chapter = p->nodecur;
+	p->indexs[i].index[isz].term = malloc(sz + 1);
+	if (NULL == p->indexs[i].index[isz].term)
+		texiabort(p, NULL);
+	memcpy(p->indexs[i].index[isz].term, index, sz);
+	p->indexs[i].index[isz].term[sz] = '\0';
+
+	/* Output mdoc(7) for index. */
+#ifdef HAVE_INDEX
+	p->seenvs = -1;
+	teximacroopen(p, "Ix");
+	texiputchars(p, "idx");
+	texiputchars(p, p->indexs[i].name);
+	cp = p->indexs[i].index[isz].term;
+	while ('\n' != *cp)
+		texiputchar(p, *cp++);
+	teximacroclose(p);
+#endif
+	p->indexs[i].indexsz++;
+}
+
+/*
+ * Add an index entry named "tok" of length "sz".
+ * This usually consists of two letters, e.g., "cp" or "vr".
+ * This does nothing if the index exists or is zero-sized.
+ */
+void
+texindex_add(struct texi *p, const char *tok, size_t sz)
+{
+	size_t	 i;
+	char	*cp;
+
+	if (0 == sz)
+		return;
+
+	/* Make sure we don't have a duplicate. */
+	for (i = 0; i < p->indexsz; i++) {
+		if (strlen(p->indexs[i].name) != sz)
+			continue;
+		if (strncmp(p->indexs[i].name, tok, sz))
+			continue;
+		return;
+	}
+
+	/* Reallocate indices. */
+	p->indexs = realloc(p->indexs,
+		sizeof(struct texidex) *
+		(p->indexsz + 1));
+	if (NULL == p->indexs)
+		texiabort(p, NULL);
+	if (NULL == (cp = malloc(sz + 1)))
+		texiabort(p, NULL);
+	memcpy(cp, tok, sz);
+	cp[sz] = '\0';
+	p->indexs[p->indexsz].name = cp;
+	p->indexs[p->indexsz].index = NULL;
+	p->indexs[p->indexsz].indexsz = 0;
+	p->indexsz++;
+}
+
+/*
  * Unmap all files that we're currently using and free all resources
  * that we've allocated during the parse.
  * The utility should exit(...) after this is called.
@@ -79,7 +227,9 @@ texiexit(struct texi *p)
 
 	/* Make sure we're newline-terminated. */
 	if (p->outcol)
-		putchar('\n');
+		fputc('\n', p->outfile);
+	if (NULL != p->chapters)
+		teximdocclose(p, 1);
 
 	/* Unmap all files. */
 	while (p->filepos > 0)
@@ -90,16 +240,18 @@ texiexit(struct texi *p)
 	for (i = 0; i < p->dirsz; i++)
 		free(p->dirs[i]);
 	for (i = 0; i < p->indexsz; i++)
-		free(p->indexs[i]);
-	for (i = 0; i < p->valsz; i++) 
+		texidex_free(&p->indexs[i]);
+	for (i = 0; i < p->valsz; i++)
 		texivaluefree(&p->vals[i]);
 
+	free(p->nodecache);
 	free(p->macros);
 	free(p->vals);
 	free(p->indexs);
 	free(p->dirs);
 	free(p->subtitle);
 	free(p->title);
+	free(p->copying);
 }
 
 /*
@@ -122,12 +274,19 @@ texiabort(struct texi *p, const char *errstring)
 void
 texiwarn(const struct texi *p, const char *fmt, ...)
 {
-	va_list	 ap;
+	va_list			 ap;
+	const struct texifile	*f;
 
-	fprintf(stderr, "%s:%zu:%zu: warning: ",
-		p->files[p->filepos - 1].name,
-		p->files[p->filepos - 1].line + 1,
-		p->files[p->filepos - 1].col + 1);
+	f = &p->files[p->filepos - 1];
+
+	if (f->insplice)
+		fprintf(stderr, "%s:%zu:%zu (%zuB left in splice): "
+			"warning: ", f->name, f->line + 1,
+			f->col + 1, f->insplice);
+	else
+		fprintf(stderr, "%s:%zu:%zu: warning: ",
+			f->name, f->line + 1, f->col + 1);
+
 	va_start(ap, fmt);
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
@@ -141,12 +300,19 @@ texiwarn(const struct texi *p, const char *fmt, ...)
 void
 texierr(struct texi *p, const char *fmt, ...)
 {
-	va_list	 ap;
+	va_list		 ap;
+	struct texifile	*f;
 
-	fprintf(stderr, "%s:%zu:%zu: error: ",
-		p->files[p->filepos - 1].name,
-		p->files[p->filepos - 1].line + 1,
-		p->files[p->filepos - 1].col + 1);
+	f = &p->files[p->filepos - 1];
+
+	if (f->insplice)
+		fprintf(stderr, "%s:%zu:%zu: (%zuB left in splice): "
+			"error: ", f->name, f->line + 1,
+			f->col + 1, f->insplice);
+	else
+		fprintf(stderr, "%s:%zu:%zu: error: ",
+			f->name, f->line + 1, f->col + 1);
+
 	va_start(ap, fmt);
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
@@ -157,9 +323,7 @@ texierr(struct texi *p, const char *fmt, ...)
 
 /*
  * Put a single data character to the output if we're not ignoring.
- * Makes sure we don't spurriously start a macro.
- * Adjusts our output status.
- * This shouldn't be called for macros: just for ordinary text.
+ * Escape starting a line with a control character and slashes.
  */
 void
 texiputchar(struct texi *p, char c)
@@ -167,12 +331,17 @@ texiputchar(struct texi *p, char c)
 
 	if (p->ign)
 		return;
-
 	if ('.' == c && 0 == p->outcol)
-		fputs("\\&", stdout);
+		fputs("\\&", p->outfile);
+	if ('\'' == c && 0 == p->outcol)
+		fputs("\\&", p->outfile);
 
-	putchar(c);
-	p->seenvs = 0;
+	if (p->uppercase)
+		fputc(toupper((unsigned int)c), p->outfile);
+	else
+		fputc(c, p->outfile);
+	if ('\\' == c)
+		fputc('e', p->outfile);
 	if ('\n' == c) {
 		p->outcol = 0;
 		p->seenws = 0;
@@ -181,18 +350,42 @@ texiputchar(struct texi *p, char c)
 }
 
 /*
- * Put multiple characters (see texiputchar()).
- * This shouldn't be called for macros: just for ordinary text.
+ * Put an opaque series of characters.
+ * Characters starting a line with a control character are escaped, but
+ * that's it, so don't use this for non-controlled sequences of text.
  */
 void
 texiputchars(struct texi *p, const char *s)
 {
 
-	while ('\0' != *s)
-		texiputchar(p, *s++);
+	if (p->ign)
+		return;
+	if ('.' == *s && 0 == p->outcol)
+		fputs("\\&", p->outfile);
+	if ('\'' == *s && 0 == p->outcol)
+		fputs("\\&", p->outfile);
+	if (p->uppercase)
+		for ( ; '\0' != *s; s++)
+			p->outcol += fputc(toupper
+				((unsigned int)*s), p->outfile);
+	else
+		p->outcol += fputs(s, p->outfile);
 }
 
 /*
+ * This puts all characters onto the output stream but makes sure to
+ * escape mdoc(7) slashes.
+ * FIXME: useless.
+ */
+void
+texiputbuf(struct texi *p, size_t start, size_t end)
+{
+
+	for ( ; start < end; start++)
+		texiputchar(p, BUF(p)[start]);
+}
+
+/*
  * Close an mdoc(7) macro opened with teximacroopen().
  * If there are no more macros on the line, prints a newline.
  */
@@ -200,11 +393,11 @@ void
 teximacroclose(struct texi *p)
 {
 
-	if (p->ign)
+	if (p->ign || p->literal|| TEXILIST_TABLE == p->list)
 		return;
 
 	if (0 == --p->outmacro) {
-		putchar('\n');
+		fputc('\n', p->outfile);
 		p->outcol = p->seenws = 0;
 	}
 }
@@ -220,26 +413,29 @@ teximacroopen(struct texi *p, const char *s)
 {
 	int	 rc;
 
-	if (p->ign)
+	if (p->ign || p->literal|| TEXILIST_TABLE == p->list)
 		return;
 
 	if (p->outcol && 0 == p->outmacro) {
-		putchar('\n');
+		fputc('\n', p->outfile);
 		p->outcol = 0;
 	}
 
+	if (p->seenvs > 0 && 0 == p->outmacro)
+		fputs(".Pp\n", p->outfile);
+
 	if (0 == p->outmacro)
-		putchar('.');
+		fputc('.', p->outfile);
 	else
-		putchar(' ');
+		fputc(' ', p->outfile);
 
-	if (EOF != (rc = fputs(s, stdout)))
+	if (EOF != (rc = fputs(s, p->outfile)))
 		p->outcol += rc;
 
-	putchar(' ');
+	fputc(' ', p->outfile);
 	p->outcol++;
 	p->outmacro++;
-	p->seenws = 0;
+	p->seenws = p->seenvs = 0;
 }
 
 /*
@@ -256,12 +452,14 @@ teximacro(struct texi *p, const char *s)
 		texierr(p, "\"%s\" in open line scope!?", s);
 	if (p->literal)
 		texierr(p, "\"%s\" in a literal scope!?", s);
-
 	if (p->outcol)
-		putchar('\n');
+		fputc('\n', p->outfile);
+	if (p->seenvs > 0)
+		fputs(".Pp\n", p->outfile);
 
-	putchar('.');
-	puts(s);
+	fputc('.', p->outfile);
+	fputs(s, p->outfile);
+	fputc('\n', p->outfile);
 	p->outcol = p->seenws = 0;
 }
 
@@ -272,10 +470,8 @@ void
 texivspace(struct texi *p)
 {
 
-	if (p->seenvs || TEXILIST_TABLE == p->list)
-		return;
-	teximacro(p, "Pp");
-	p->seenvs = 1;
+	if (TEXILIST_TABLE != p->list && p->seenvs >= 0)
+		p->seenvs = 1;
 }
 
 /*
@@ -283,15 +479,24 @@ texivspace(struct texi *p)
  * in the current input file.
  */
 void
-advance(struct texi *p, const char *buf, size_t *pos)
+advance(struct texi *p, size_t *pos)
 {
+	struct texifile	*f;
 
-	if ('\n' == buf[*pos]) {
-		p->files[p->filepos - 1].line++;
-		p->files[p->filepos - 1].col = 0;
-	} else
-		p->files[p->filepos - 1].col++;
+	f = &p->files[p->filepos - 1];
 
+	if (0 == f->insplice) {
+		if ('\n' == BUF(p)[*pos]) {
+			f->line++;
+			f->col = 0;
+		} else
+			f->col++;
+	} else {
+		--f->insplice;
+		if (0 == f->insplice)
+			f->depth = 0;
+	}
+
 	(*pos)++;
 }
 
@@ -303,20 +508,21 @@ advance(struct texi *p, const char *buf, size_t *pos)
  * appropriately flush-left punctuation alongside the macro.
  */
 void
-texipunctuate(struct texi *p, const char *buf, size_t sz, size_t *pos)
+texipunctuate(struct texi *p, size_t *pos)
 {
 	size_t	 start, end;
 
 	if (1 != p->outmacro)
 		return;
 
-	for (start = end = *pos; end < sz; end++) {
-		switch (buf[end]) {
+	for (start = end = *pos; end < BUFSZ(p); end++) {
+		switch (BUF(p)[end]) {
 		case (','):
 		case (')'):
 		case ('.'):
 		case ('"'):
 		case (':'):
+		case (';'):
 		case ('!'):
 		case ('?'):
 			continue;
@@ -327,11 +533,12 @@ texipunctuate(struct texi *p, const char *buf, size_t 
 	}
 	if (end == *pos)
 		return;
-	if (end + 1 == sz || ' ' == buf[end] || '\n' == buf[end]) {
+	if (end + 1 == BUFSZ(p) || ' ' == BUF(p)[end] ||
+		'@' == BUF(p)[end] || '\n' == BUF(p)[end]) {
 		for ( ; start < end; start++) {
 			texiputchar(p, ' ');
-			texiputchar(p, buf[start]);
-			advance(p, buf, pos);
+			texiputchar(p, BUF(p)[start]);
+			advance(p, pos);
 		}
 	}
 }
@@ -342,48 +549,44 @@ texipunctuate(struct texi *p, const char *buf, size_t 
  * doing so.
  */
 static size_t
-advancenext(struct texi *p, const char *buf, size_t sz, size_t *pos)
+advancenext(struct texi *p, size_t *pos)
 {
-	
+
 	if (p->literal) {
-		while (*pos < sz && ismspace(buf[*pos])) {
-			if (*pos && '\n' == buf[*pos] && 
-				'\\' == buf[*pos - 1])
-				texiputchar(p, 'e');
-			texiputchar(p, buf[*pos]);
-			advance(p, buf, pos);
+		while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos])) {
+			texiputchar(p, BUF(p)[*pos]);
+			advance(p, pos);
 		}
 		return(*pos);
-	} 
+	}
 
-	while (*pos < sz && ismspace(buf[*pos])) {
+	while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos])) {
 		p->seenws = 1;
-		/* 
-		 * If it looks like we've printed a double-line, then
-		 * output a paragraph.
-		 * FIXME: this is stupid.
-		 */
-		if (*pos && '\n' == buf[*pos] && '\n' == buf[*pos - 1])
-			texivspace(p);
-		advance(p, buf, pos);
+		if (0 == p->seenvs && '\n' == BUF(p)[*pos])
+			if (*pos + 1 < BUFSZ(p) && '\n' == BUF(p)[*pos + 1])
+				p->seenvs = 1;
+		advance(p, pos);
 	}
 	return(*pos);
 }
 
 /*
  * Advance to the EOLN in the input stream.
- * NOTE: THIS SHOULD NOT BE CALLED ON BLANK TEXT, as it will read up to
- * the @\n.
+ * This will skip over '@' markers in an effort to ignore escaped
+ * newlines.
  */
 size_t
-advanceeoln(struct texi *p, const char *buf, 
-	size_t sz, size_t *pos, int consumenl)
+advanceeoln(struct texi *p, size_t *pos, int consumenl)
 {
 
-	while (*pos < sz && '\n' != buf[*pos])
-		advance(p, buf, pos);
-	if (*pos < sz && consumenl)
-		advance(p, buf, pos);
+	while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
+		if ('@' == BUF(p)[*pos])
+			advance(p, pos);
+		if (*pos < BUFSZ(p))
+			advance(p, pos);
+	}
+	if (*pos < BUFSZ(p) && consumenl)
+		advance(p, pos);
 	return(*pos);
 }
 
@@ -392,34 +595,53 @@ advanceeoln(struct texi *p, const char *buf, 
  * current buffer greater than or equal to the current position.
  */
 void
-advanceto(struct texi *p, const char *buf, size_t *pos, size_t end)
+advanceto(struct texi *p, size_t *pos, size_t end)
 {
 
 	assert(*pos <= end);
-	while (*pos < end) 
-		advance(p, buf, pos);
+	while (*pos < end)
+		advance(p, pos);
 }
 
 static void
-texiexecmacro(struct texi *p, struct teximacro *m,
-	const char *buf, size_t sz, size_t *pos)
+texiexecmacro(struct texi *p, struct teximacro *m, size_t sv, size_t *pos)
 {
-	size_t	  valsz, realsz, aasz, asz, 
-		  ssz, i, j, k, start, end;
-	char	 *val;
-	char	**args;
+	size_t		  valsz, realsz, aasz, asz,
+			   ssz, i, j, k, start, end;
+	char		 *val;
+	char		**args;
+	const char	 *cp;
 
-	args = argparse(p, buf, sz, pos, &asz, m->argsz);
+	/* Disregard empty macros. */
+	if (0 == (valsz = realsz = strlen(m->value))) {
+		args = argparse(p, pos, &asz, m->argsz);
+		for (i = 0; i < asz; i++)
+			free(args[i]);
+		free(args);
+		return;
+	}
+
+	/*
+	 * This is important: it protect us from macros that invoke more
+	 * macros, possibly going on infinitely.
+	 * We use "sv" instead of the current position because we might
+	 * be invoked at the end of the macro (i.e., insplice == 0).
+	 * The "sv" value was initialised at the start of the macro.
+	 */
+	if (sv > 0)
+		if (++p->files[p->filepos - 1].depth > 64)
+			texierr(p, "maximium recursive depth");
+
+	args = argparse(p, pos, &asz, m->argsz);
 	if (asz != m->argsz)
 		texiwarn(p, "invalid macro argument length");
 	aasz = asz < m->argsz ? asz : m->argsz;
 
 	if (0 == aasz) {
-		parsemembuf(p, m->value, strlen(m->value));
+		texisplice(p, m->value, valsz, *pos);
 		return;
 	}
 
-	valsz = realsz = strlen(m->value);
 	val = strdup(m->value);
 
 	for (i = j = 0; i < realsz; i++) {
@@ -442,7 +664,7 @@ texiexecmacro(struct texi *p, struct teximacro *m,
 
 		/* Parse to terminating delimiter. */
 		/* FIXME: embedded, escaped delimiters? */
-		for (start = end = i + 1; end < realsz; end++) 
+		for (start = end = i + 1; end < realsz; end++)
 			if ('\\' == m->value[end])
 				break;
 		if (end == realsz)
@@ -456,17 +678,12 @@ texiexecmacro(struct texi *p, struct teximacro *m,
 			break;
 		}
 
-		/* 
-		 * Argument didn't exist in argument table. 
-		 * No need to reallocate here: we just copy the text
-		 * directly from the macro value into the buffer.
+		/*
+		 * Argument didn't exist in argument table.
+		 * Just ignore it.
 		 */
 		if (k == aasz) {
-			for ( ; i < end; i++)
-				val[j++] = m->value[i];
-			assert('\\' == m->value[i]);
-			val[j++] = m->value[i];
-			val[j] = '\0';
+			i = end;
 			continue;
 		}
 
@@ -477,17 +694,20 @@ texiexecmacro(struct texi *p, struct teximacro *m,
 				texiabort(p, NULL);
 		}
 
-		j = strlcat(val, args[k], valsz + 1);
+		for (cp = args[k]; '\0' != *cp; cp++)
+			val[j++] = *cp;
+
+		val[j] = '\0';
 		i = end;
 	}
 
-	parsemembuf(p, val, strlen(val));
+	texisplice(p, val, strlen(val), *pos);
 
 	for (i = 0; i < asz; i++)
 		free(args[i]);
 	free(args);
 	free(val);
-} 
+}
 
 /*
  * Output a free-form word in the input stream, progressing to the next
@@ -495,42 +715,142 @@ texiexecmacro(struct texi *p, struct teximacro *m,
  * This also will advance the input stream.
  */
 static void
-texiword(struct texi *p, const char *buf, 
-	size_t sz, size_t *pos, char extra)
+parseword(struct texi *p, size_t *pos, char extra)
 {
+	size_t		 i, end, len;
+	int		 c;
 
-	if (p->seenws && 0 == p->outmacro && 
+	/*
+	 * If a prior word had a terminating double-newline, then begin
+	 * this text block with a `Pp'.
+	 * We don't do this if we're in a literal context (we'll print
+	 * out the newlines themselves) nor in a `TS' table.
+	 */
+	if (p->seenvs > 0 && 0 == p->literal && TEXILIST_TABLE != p->list) {
+		if (p->outcol > 0)
+			fputc('\n', p->outfile);
+		fputs(".Pp\n", p->outfile);
+		p->outcol = 0;
+	}
+
+	/*
+	 * Some line control: if we (non-macro, non-literal) already
+	 * have more than 72 characters written to the screen, then
+	 * output a newline before getting started.
+	 */
+	if (p->seenws && 0 == p->outmacro &&
 		 p->outcol > 72 && 0 == p->literal)
 		texiputchar(p, '\n');
-	/* FIXME: abstract this: we use it elsewhere. */
+
+	/* Usual padding in the case of seen whitespace. */
 	if (p->seenws && p->outcol && 0 == p->literal)
 		texiputchar(p, ' ');
 
 	p->seenws = 0;
 
-	while (*pos < sz && ! ismspace(buf[*pos])) {
-		switch (buf[*pos]) {
+	/*
+	 * If we're in a macro line, we might want to print text that
+	 * happens to be the same as an mdoc(7) macro.
+	 * Obviously, we need to escape these words.
+	 */
+	if (p->outmacro) {
+		end = *pos;
+		/* Read ahead to get the word length. */
+		while (end < BUFSZ(p) && ! ismspace(BUF(p)[end])) {
+			switch ((c = BUF(p)[end])) {
+			case ('@'):
+			case ('}'):
+			case ('{'):
+				break;
+			default:
+				if ('\0' != extra && extra == c)
+					break;
+				end++;
+				continue;
+			}
+			break;
+		}
+		len = end - *pos;
+		/* See if we have a match. */
+		for (i = 0; NULL != mdocs[i]; i++) {
+			/* All macros are 2 or three letters. */
+			if (len < 2 || len > 3)
+				continue;
+			/* Check the macro word length. */
+			if ('\0' == mdocs[i][2] && 2 != len)
+				continue;
+			else if ('\0' == mdocs[i][3] && 3 != len)
+				continue;
+			if (strncmp(mdocs[i], &BUF(p)[*pos], len))
+				continue;
+			texiputchars(p, "\\&");
+			break;
+		}
+	}
+
+	while (*pos < BUFSZ(p) && ! ismspace(BUF(p)[*pos])) {
+		switch (BUF(p)[*pos]) {
 		case ('@'):
 		case ('}'):
 		case ('{'):
 			return;
 		}
-		if ('\0' != extra && buf[*pos] == extra)
+		if ('\0' != extra && BUF(p)[*pos] == extra)
 			return;
-		if (*pos < sz - 1 && 
-			 '`' == buf[*pos] && 
-			 '`' == buf[*pos + 1]) {
+
+		if (p->literal) {
+			texiputchar(p, BUF(p)[*pos]);
+			advance(p, pos);
+			continue;
+		}
+
+		if ('"' == BUF(p)[*pos]) {
+			texiputchars(p, "\\(dq");
+		} else if (*pos < BUFSZ(p) - 2 &&
+			 '-' == BUF(p)[*pos] &&
+			 '-' == BUF(p)[*pos + 1] &&
+			 '-' == BUF(p)[*pos + 2]) {
+			texiputchars(p, "\\(em");
+			advance(p, pos);
+			advance(p, pos);
+		} else if (*pos < BUFSZ(p) - 1 &&
+			 '-' == BUF(p)[*pos] &&
+			 '-' == BUF(p)[*pos + 1]) {
+			texiputchars(p, "\\(en");
+			advance(p, pos);
+		} else if (*pos < BUFSZ(p) - 1 &&
+			 '`' == BUF(p)[*pos] &&
+			 '`' == BUF(p)[*pos + 1]) {
 			texiputchars(p, "\\(lq");
-			advance(p, buf, pos);
-		} else if (*pos < sz - 1 && 
-			 '\'' == buf[*pos] && 
-			 '\'' == buf[*pos + 1]) {
+			advance(p, pos);
+		} else if (*pos < BUFSZ(p) - 1 &&
+			 '\'' == BUF(p)[*pos] &&
+			 '\'' == BUF(p)[*pos + 1]) {
 			texiputchars(p, "\\(rq");
-			advance(p, buf, pos);
+			advance(p, pos);
 		} else
-			texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+			texiputchar(p, BUF(p)[*pos]);
+
+		advance(p, pos);
 	}
+
+	/*
+	 * New sentence, new line:if we (non-macro, non-literal) see a
+	 * period at the end of the last printed word, then open a
+	 * newline.
+	 */
+	if (0 == p->literal && 0 == p->outmacro && *pos < BUFSZ(p))
+		switch (BUF(p)[*pos - 1]) {
+		case ('.'):
+		case ('!'):
+		case ('?'):
+			texiputchar(p, '\n');
+			break;
+		default:
+			break;
+		}
+
+	p->seenvs = 0;
 }
 
 /*
@@ -539,39 +859,38 @@ texiword(struct texi *p, const char *buf, 
  * index after the command name.
  */
 enum texicmd
-texicmd(struct texi *p, const char *buf, size_t pos, 
-	size_t sz, size_t *end, struct teximacro **macro)
+texicmd(const struct texi *p, size_t pos, size_t *end, struct teximacro **macro)
 {
 	size_t	 i, len, toksz;
 
-	assert('@' == buf[pos]);
+	assert('@' == BUF(p)[pos]);
 
 	if (NULL != macro)
 		*macro = NULL;
 
-	if ((*end = pos) == sz)
+	if ((*end = pos) == BUFSZ(p))
 		return(TEXICMD__MAX);
-	else if ((*end = ++pos) == sz)
+	else if ((*end = ++pos) == BUFSZ(p))
 		return(TEXICMD__MAX);
 
 	/* Alphabetic commands are special. */
-	if ( ! isalpha(buf[pos])) {
-		if ((*end = pos + 1) == sz)
+	if ( ! isalpha((unsigned int)BUF(p)[pos])) {
+		if ((*end = pos + 1) == BUFSZ(p))
 			return(TEXICMD__MAX);
 		for (i = 0; i < TEXICMD__MAX; i++) {
 			if (1 != texitoks[i].len)
 				continue;
-			if (0 == strncmp(texitoks[i].tok, &buf[pos], 1))
+			if (0 == strncmp(texitoks[i].tok, &BUF(p)[pos], 1))
 				return(i);
 		}
-		texiwarn(p, "bad command: @%c", buf[pos]);
+		texiwarn(p, "bad command: @%c", BUF(p)[pos]);
 		return(TEXICMD__MAX);
 	}
 
 	/* Scan to the end of the possible command name. */
-	for (*end = pos; *end < sz && ! ismspace(buf[*end]); (*end)++)
-		if ((*end > pos && ('@' == buf[*end] || 
-			  '{' == buf[*end] || '}' == buf[*end])))
+	for (*end = pos; *end < BUFSZ(p) && ! ismspace(BUF(p)[*end]); (*end)++)
+		if ((*end > pos && ('@' == BUF(p)[*end] ||
+			  '{' == BUF(p)[*end] || '}' == BUF(p)[*end])))
 			break;
 
 	/* Look for the command. */
@@ -579,32 +898,32 @@ texicmd(struct texi *p, const char *buf, size_t pos, 
 	for (i = 0; i < TEXICMD__MAX; i++) {
 		if (len != texitoks[i].len)
 			continue;
-		if (0 == strncmp(texitoks[i].tok, &buf[pos], len))
+		if (0 == strncmp(texitoks[i].tok, &BUF(p)[pos], len))
 			return(i);
 	}
 
 	/* Look for it in our indices. */
 	for (i = 0; i < p->indexsz; i++) {
-		toksz = strlen(p->indexs[i]);
+		toksz = strlen(p->indexs[i].name);
 		if (len != 5 + toksz)
 			continue;
-		if (strncmp(&buf[pos], p->indexs[i], toksz))
+		if (strncmp(&BUF(p)[pos], p->indexs[i].name, toksz))
 			continue;
-		if (0 == strncmp(&buf[pos + toksz], "index", 5))
+		if (0 == strncmp(&BUF(p)[pos + toksz], "index", 5))
 			return(TEXICMD_USER_INDEX);
 	}
 
 	for (i = 0; i < p->macrosz; i++) {
 		if (len != strlen(p->macros[i].key))
 			continue;
-		if (strncmp(&buf[pos], p->macros[i].key, len))
+		if (strncmp(&BUF(p)[pos], p->macros[i].key, len))
 			continue;
 		if (NULL != macro)
 			*macro = &p->macros[i];
 		return(TEXICMD__MAX);
 	}
 
-	texiwarn(p, "bad command: @%.*s", (int)len, &buf[pos]);
+	texiwarn(p, "bad command: @%.*s", (int)len, &BUF(p)[pos]);
 	return(TEXICMD__MAX);
 }
 
@@ -617,48 +936,48 @@ texicmd(struct texi *p, const char *buf, size_t pos, 
  * bracket for the zeroth parse.
  */
 int
-parsearg(struct texi *p, const char *buf, 
-	size_t sz, size_t *pos, size_t num)
+parsearg(struct texi *p, size_t *pos, size_t num)
 {
-	size_t		  end;
+	size_t		  end, sv;
 	enum texicmd	  cmd;
 	struct teximacro *macro;
 
-	while (*pos < sz && ismspace(buf[*pos]))
-		advance(p, buf, pos);
-	if (*pos == sz || (0 == num && '{' != buf[*pos]))
+	while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos]))
+		advance(p, pos);
+	if (*pos == BUFSZ(p) || (0 == num && '{' != BUF(p)[*pos]))
 		return(0);
 	if (0 == num)
-		advance(p, buf, pos);
+		advance(p, pos);
 
-	while ((*pos = advancenext(p, buf, sz, pos)) < sz) {
-		switch (buf[*pos]) {
+	while ((*pos = advancenext(p, pos)) < BUFSZ(p)) {
+		switch (BUF(p)[*pos]) {
 		case (','):
-			advance(p, buf, pos);
+			advance(p, pos);
 			return(1);
 		case ('}'):
-			advance(p, buf, pos);
+			advance(p, pos);
 			return(0);
 		case ('{'):
 			if (0 == p->ign)
 				texiwarn(p, "unexpected \"{\"");
-			advance(p, buf, pos);
+			advance(p, pos);
 			continue;
 		case ('@'):
 			break;
 		default:
-			texiword(p, buf, sz, pos, ',');
+			parseword(p, pos, ',');
 			continue;
 		}
 
-		cmd = texicmd(p, buf, *pos, sz, &end, &macro);
-		advanceto(p, buf, pos, end);
+		sv = p->files[p->filepos - 1].insplice;
+		cmd = texicmd(p, *pos, &end, &macro);
+		advanceto(p, pos, end);
 		if (NULL != macro)
-			texiexecmacro(p, macro, buf, sz, pos);
-		if (TEXICMD__MAX == cmd) 
+			texiexecmacro(p, macro, sv, pos);
+		if (TEXICMD__MAX == cmd)
 			continue;
 		if (NULL != texitoks[cmd].fp)
-			(*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
+			(*texitoks[cmd].fp)(p, cmd, pos);
 	}
 	return(0);
 }
@@ -668,44 +987,58 @@ parsearg(struct texi *p, const char *buf, 
  * This will stop in the event of EOF or if we're not at a bracket.
  */
 void
-parsebracket(struct texi *p, const char *buf, size_t sz, size_t *pos)
+parsebracket(struct texi *p, size_t *pos, int dostack)
 {
-	size_t		  end;
+	size_t		  end, sv, stack;
 	enum texicmd	  cmd;
 	struct teximacro *macro;
 
-	while (*pos < sz && ismspace(buf[*pos]))
-		advance(p, buf, pos);
+	while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos]))
+		advance(p, pos);
 
-	if (*pos == sz || '{' != buf[*pos])
+	if (*pos == BUFSZ(p) || '{' != BUF(p)[*pos])
 		return;
-	advance(p, buf, pos);
+	advance(p, pos);
 
-	while ((*pos = advancenext(p, buf, sz, pos)) < sz) {
-		switch (buf[*pos]) {
+	stack = 0;
+	while ((*pos = advancenext(p, pos)) < BUFSZ(p)) {
+		switch (BUF(p)[*pos]) {
 		case ('}'):
-			advance(p, buf, pos);
+			if (stack > 0) {
+				stack--;
+				advance(p, pos);
+				texiputchar(p, '}');
+				continue;
+			}
+			advance(p, pos);
 			return;
 		case ('{'):
+			if (dostack) {
+				stack++;
+				advance(p, pos);
+				texiputchar(p, '{');
+				continue;
+			}
 			if (0 == p->ign)
 				texiwarn(p, "unexpected \"{\"");
-			advance(p, buf, pos);
+			advance(p, pos);
 			continue;
 		case ('@'):
 			break;
 		default:
-			texiword(p, buf, sz, pos, '\0');
+			parseword(p, pos, '\0');
 			continue;
 		}
 
-		cmd = texicmd(p, buf, *pos, sz, &end, &macro);
-		advanceto(p, buf, pos, end);
+		sv = p->files[p->filepos - 1].insplice;
+		cmd = texicmd(p, *pos, &end, &macro);
+		advanceto(p, pos, end);
 		if (NULL != macro)
-			texiexecmacro(p, macro, buf, sz, pos);
-		if (TEXICMD__MAX == cmd) 
+			texiexecmacro(p, macro, sv, pos);
+		if (TEXICMD__MAX == cmd)
 			continue;
 		if (NULL != texitoks[cmd].fp)
-			(*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
+			(*texitoks[cmd].fp)(p, cmd, pos);
 	}
 }
 
@@ -715,88 +1048,128 @@ parsebracket(struct texi *p, const char *buf, size_t s
  * the way.
  */
 void
-parseeoln(struct texi *p, const char *buf, size_t sz, size_t *pos)
+parseeoln(struct texi *p, size_t *pos)
 {
-	size_t		  end;
+	size_t		  end, sv;
 	enum texicmd	  cmd;
 	struct teximacro *macro;
 
-	while (*pos < sz && '\n' != buf[*pos]) {
-		while (*pos < sz && isws(buf[*pos])) {
+	while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
+		while (*pos < BUFSZ(p) && isws(BUF(p)[*pos])) {
 			p->seenws = 1;
 			if (p->literal)
-				texiputchar(p, buf[*pos]);
-			advance(p, buf, pos);
+				texiputchar(p, BUF(p)[*pos]);
+			advance(p, pos);
 		}
-		switch (buf[*pos]) {
+		if (*pos == BUFSZ(p)) {
+			texiwarn(p, "unexpected EOF");
+			return;
+		}
+		switch (BUF(p)[*pos]) {
 		case ('}'):
 			if (0 == p->ign)
 				texiwarn(p, "unexpected \"}\"");
-			advance(p, buf, pos);
+			advance(p, pos);
 			continue;
 		case ('{'):
 			if (0 == p->ign)
 				texiwarn(p, "unexpected \"{\"");
-			advance(p, buf, pos);
+			advance(p, pos);
 			continue;
+		case ('\n'):
+			continue;
 		case ('@'):
 			break;
 		default:
-			texiword(p, buf, sz, pos, '\0');
+			parseword(p, pos, '\0');
 			continue;
 		}
 
-		cmd = texicmd(p, buf, *pos, sz, &end, &macro);
-		advanceto(p, buf, pos, end);
+		sv = p->files[p->filepos - 1].insplice;
+		cmd = texicmd(p, *pos, &end, &macro);
+		advanceto(p, pos, end);
 		if (NULL != macro)
-			texiexecmacro(p, macro, buf, sz, pos);
-		if (TEXICMD__MAX == cmd) 
+			texiexecmacro(p, macro, sv, pos);
+		if (TEXICMD__MAX == cmd)
 			continue;
 		if (NULL != texitoks[cmd].fp)
-			(*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
+			(*texitoks[cmd].fp)(p, cmd, pos);
 	}
+
+	if (*pos < BUFSZ(p) && '\n' == BUF(p)[*pos])
+		advance(p, pos);
 }
 
+enum texicmd
+peeklinecmd(const struct texi *p, size_t pos)
+{
+	size_t		end;
+
+	while (pos < BUFSZ(p) && isws(BUF(p)[pos]))
+		pos++;
+	if (pos == BUFSZ(p) || '@' != BUF(p)[pos])
+		return(TEXICMD__MAX);
+	return(texicmd(p, pos, &end, NULL));
+}
+
 /*
+ * Peek to see if there's a command after subsequent whitespace.
+ * If so, return the macro identifier.
+ * This DOES NOT work with user-defined macros.
+ */
+enum texicmd
+peekcmd(const struct texi *p, size_t pos)
+{
+	size_t		end;
+
+	while (pos < BUFSZ(p) && ismspace(BUF(p)[pos]))
+		pos++;
+	if (pos == BUFSZ(p) || '@' != BUF(p)[pos])
+		return(TEXICMD__MAX);
+	return(texicmd(p, pos, &end, NULL));
+}
+
+/*
  * Parse a single word or command.
  * This will return immediately at the EOF.
  */
 void
-parsesingle(struct texi *p, const char *buf, size_t sz, size_t *pos)
+parsesingle(struct texi *p, size_t *pos)
 {
-	size_t		  end;
+	size_t		  end, sv;
 	enum texicmd	  cmd;
 	struct teximacro *macro;
 
-	if ((*pos = advancenext(p, buf, sz, pos)) >= sz)
+	if ((*pos = advancenext(p, pos)) >= BUFSZ(p))
 		return;
 
-	switch (buf[*pos]) {
+	switch (BUF(p)[*pos]) {
 	case ('}'):
 		if (0 == p->ign)
 			texiwarn(p, "unexpected \"}\"");
-		advance(p, buf, pos);
+		advance(p, pos);
 		return;
 	case ('{'):
 		if (0 == p->ign)
 			texiwarn(p, "unexpected \"{\"");
-		advance(p, buf, pos);
+		advance(p, pos);
 		return;
 	case ('@'):
 		break;
 	default:
-		texiword(p, buf, sz, pos, '\0');
+		parseword(p, pos, '\0');
 		return;
 	}
 
-	cmd = texicmd(p, buf, *pos, sz, &end, &macro);
-	advanceto(p, buf, pos, end);
+	sv = p->files[p->filepos - 1].insplice;
+	cmd = texicmd(p, *pos, &end, &macro);
+	advanceto(p, pos, end);
 	if (NULL != macro)
-		texiexecmacro(p, macro, buf, sz, pos);
-	if (TEXICMD__MAX == cmd) 
+		texiexecmacro(p, macro, sv, pos);
+	if (TEXICMD__MAX == cmd)
 		return;
 	if (NULL != texitoks[cmd].fp)
-		(*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
+		(*texitoks[cmd].fp)(p, cmd, pos);
 }
 
 /*
@@ -808,18 +1181,18 @@ parsesingle(struct texi *p, const char *buf, size_t sz
  * line or 1 otherwise.
  */
 int
-parselinearg(struct texi *p, const char *buf, size_t sz, size_t *pos)
+parselinearg(struct texi *p, size_t *pos)
 {
 
-	while (*pos < sz && isws(buf[*pos])) {
+	while (*pos < BUFSZ(p) && isws(BUF(p)[*pos])) {
 		p->seenws = 1;
-		advance(p, buf, pos);
+		advance(p, pos);
 	}
 
-	if (*pos < sz && '{' == buf[*pos])
-		parsebracket(p, buf, sz, pos);
-	else if (*pos < sz && '\n' != buf[*pos])
-		parsesingle(p, buf, sz, pos);
+	if (*pos < BUFSZ(p) && '{' == BUF(p)[*pos])
+		parsebracket(p, pos, 0);
+	else if (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
+		parsesingle(p, pos);
 	else
 		return(0);
 
@@ -829,41 +1202,36 @@ parselinearg(struct texi *p, const char *buf, size_t s
 /*
  * Parse til the end of the buffer.
  */
-void
-parseeof(struct texi *p, const char *buf, size_t sz)
+static void
+parseeof(struct texi *p)
 {
 	size_t	 pos;
 
-	for (pos = 0; pos < sz; ) 
-		parsesingle(p, buf, sz, &pos);
+	for (pos = 0; pos < BUFSZ(p); )
+		parsesingle(p, &pos);
 }
 
-/*
- * This is like parseeof() except that it's to be invoked on memory
- * buffers while parsing a larger scope.
- * This is useful for parsing macro sequences.
- * The line, column, and name of the calling file context are saved, the
- * column and line reset, then all of these restored after parse.
- */
 void
-parsemembuf(struct texi *p, const char *buf, size_t sz)
+texisplice(struct texi *p, const char *buf, size_t sz, size_t pos)
 {
-	size_t	 	 svln, svcol;
-	const char	*svname;
+	char		*cp;
+	struct texifile	*f;
 
-	svln = p->files[p->filepos - 1].line;
-	svcol = p->files[p->filepos - 1].col;
-	svname = p->files[p->filepos - 1].name;
+	assert(p->filepos > 0);
+	f = &p->files[p->filepos - 1];
 
-	p->files[p->filepos - 1].line = 0;
-	p->files[p->filepos - 1].col = 0;
-	p->files[p->filepos - 1].name = "<macro buffer>";
+	if (f->mapsz + sz > f->mapmaxsz) {
+		f->mapmaxsz = f->mapsz + sz + 1024;
+		cp = realloc(f->map, f->mapmaxsz);
+		if (NULL == cp)
+			texiabort(p, NULL);
+		f->map = cp;
+	}
 
-	parseeof(p, buf, sz);
-
-	p->files[p->filepos - 1].line = svln;
-	p->files[p->filepos - 1].col = svcol;
-	p->files[p->filepos - 1].name = svname;
+	f->insplice += sz;
+	memmove(f->map + pos + sz, f->map + pos, f->mapsz - pos);
+	memcpy(f->map + pos, buf, sz);
+	f->mapsz += sz;
 }
 
 /*
@@ -872,65 +1240,108 @@ parsemembuf(struct texi *p, const char *buf, size_t sz
  * This will return immediately at EOF.
  */
 void
-parseto(struct texi *p, const char *buf, 
-	size_t sz, size_t *pos, const char *endtoken)
+parseto(struct texi *p, size_t *pos, const char *endtoken)
 {
-	size_t		  end;
+	size_t		  end, sv;
 	enum texicmd	  cmd;
 	size_t		  endtoksz;
 	struct teximacro *macro;
 
 	endtoksz = strlen(endtoken);
 	assert(endtoksz > 0);
-	
-	while ((*pos = advancenext(p, buf, sz, pos)) < sz) {
-		switch (buf[*pos]) {
+
+	while ((*pos = advancenext(p, pos)) < BUFSZ(p)) {
+		switch (BUF(p)[*pos]) {
 		case ('}'):
 			if (0 == p->ign)
 				texiwarn(p, "unexpected \"}\"");
-			advance(p, buf, pos);
+			advance(p, pos);
 			continue;
 		case ('{'):
 			if (0 == p->ign)
 				texiwarn(p, "unexpected \"{\"");
-			advance(p, buf, pos);
+			advance(p, pos);
 			continue;
 		case ('@'):
 			break;
 		default:
-			texiword(p, buf, sz, pos, '\0');
+			parseword(p, pos, '\0');
 			continue;
 		}
 
-		cmd = texicmd(p, buf, *pos, sz, &end, &macro);
-		advanceto(p, buf, pos, end);
+		sv = p->files[p->filepos - 1].insplice;
+		cmd = texicmd(p, *pos, &end, &macro);
+		advanceto(p, pos, end);
 		if (TEXICMD_END == cmd) {
-			while (*pos < sz && isws(buf[*pos]))
-				advance(p, buf, pos);
-			/* 
+			while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+				advance(p, pos);
+			/*
 			 * FIXME: check the full word, not just its
 			 * initial substring!
 			 */
-			if (sz - *pos >= endtoksz && 0 == strncmp
-				 (&buf[*pos], endtoken, endtoksz)) {
-				advanceeoln(p, buf, sz, pos, 0);
+			if (BUFSZ(p) - *pos >= endtoksz && 0 == strncmp
+				 (&BUF(p)[*pos], endtoken, endtoksz)) {
+				advanceeoln(p, pos, 0);
 				break;
 			}
 			if (0 == p->ign)
 				texiwarn(p, "unexpected \"end\"");
-			advanceeoln(p, buf, sz, pos, 0);
+			advanceeoln(p, pos, 0);
 			continue;
-		} 
+		}
 		if (NULL != macro)
-			texiexecmacro(p, macro, buf, sz, pos);
-		if (TEXICMD__MAX == cmd) 
+			texiexecmacro(p, macro, sv, pos);
+		if (TEXICMD__MAX == cmd)
 			continue;
-		if (NULL != texitoks[cmd].fp) 
-			(*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
+		if (NULL != texitoks[cmd].fp)
+			(*texitoks[cmd].fp)(p, cmd, pos);
 	}
+
+	if (*pos == BUFSZ(p))
+		texiwarn(p, "EOF expecting \"%s\" end\n", endtoken);
 }
 
 /*
+ * Like parsefile() but used for reading from stdandard input.
+ * This can only be called for the first file!
+ */
+void
+parsestdin(struct texi *p)
+{
+	struct texifile	*f;
+	ssize_t		 ssz;
+
+	assert(0 == p->filepos);
+	f = &p->files[p->filepos];
+	memset(f, 0, sizeof(struct texifile));
+
+	f->type = TEXISRC_STDIN;
+	f->name = "<stdin>";
+
+	for (f->mapsz = 0; ; f->mapsz += (size_t)ssz) {
+		if (f->mapsz == f->mapmaxsz) {
+			if (f->mapmaxsz == (1U << 31))
+				texierr(p, "stdin buffer too long");
+			f->mapmaxsz = f->mapmaxsz > 65536 / 2 ?
+				2 * f->mapmaxsz : 65536;
+			f->map = realloc(f->map, f->mapmaxsz);
+			if (NULL == f->map)
+				texiabort(p, NULL);
+		}
+		ssz = read(STDIN_FILENO, f->map +
+			(int)f->mapsz, f->mapmaxsz - f->mapsz);
+		if (0 == ssz)
+			break;
+		else if (-1 == ssz)
+			texiabort(p, NULL);
+	}
+
+	p->filepos++;
+	parseeof(p);
+	texifilepop(p);
+}
+
+/*
  * Memory-map the file "fname" and begin parsing it unless "parse" is
  * zero, in which case we just dump the file to stdout (making sure it
  * doesn't trip up mdoc(7) along the way).
@@ -943,46 +1354,44 @@ parsefile(struct texi *p, const char *fname, int parse
 	int		 fd;
 	struct stat	 st;
 	size_t		 i;
+	char		*map;
 
-	if (64 == p->filepos) 
+	if (64 == p->filepos)
 		texierr(p, "too many open files");
 	f = &p->files[p->filepos];
 	memset(f, 0, sizeof(struct texifile));
 
+	f->type = TEXISRC_FILE;
 	f->name = fname;
 	if (-1 == (fd = open(fname, O_RDONLY, 0))) {
 		texiabort(p, fname);
 	} else if (-1 == fstat(fd, &st)) {
 		close(fd);
 		texiabort(p, fname);
-	} 
+	}
 
-	f->mapsz = st.st_size;
-	f->map = mmap(NULL, f->mapsz,
+	f->mapsz = f->mapmaxsz = st.st_size;
+	map = mmap(NULL, f->mapsz,
 		PROT_READ, MAP_SHARED, fd, 0);
 	close(fd);
 
-	if (MAP_FAILED == f->map)
+	if (MAP_FAILED == map)
 		texiabort(p, fname);
 
-	p->filepos++;
 	if ( ! parse) {
-		/*
-		 * We're printing verbatim output.
-		 * Make sure it doesn't get interpreted as mdoc by
-		 * escaping escapes and making sure leading dots don't
-		 * trigger mdoc(7) expansion.
-		 */
-		for (i = 0; i < f->mapsz; i++) {
-			if (i > 0 && '.' == f->map[i])
-				if ('\n' == f->map[i - 1])
-					fputs("\\&", stdout);
-			putchar(f->map[i]);
-			if ('\\' == f->map[i])
-				putchar('e');
-		}
-	} else
-		parseeof(p, f->map, f->mapsz);
+		for (i = 0; i < f->mapsz; i++)
+			texiputchar(p, map[i]);
+		if (p->outcol)
+			texiputchar(p, '\n');
+		munmap(map, f->mapsz);
+		return;
+	}
+
+	p->filepos++;
+	f->map = malloc(f->mapsz);
+	memcpy(f->map, map, f->mapsz);
+	munmap(map, f->mapsz);
+	parseeof(p);
 	texifilepop(p);
 }
 
@@ -994,8 +1403,7 @@ parsefile(struct texi *p, const char *fname, int parse
  * The pointer can point to NULL if the value has been unset.
  */
 static char **
-valuequery(const struct texi *p, 
-	const char *buf, size_t start, size_t end)
+valuequery(const struct texi *p, size_t start, size_t end)
 {
 	size_t	 i, sz, len;
 
@@ -1007,7 +1415,7 @@ valuequery(const struct texi *p, 
 		sz = strlen(p->vals[i].key);
 		if (sz != len)
 			continue;
-		if (0 == strncmp(p->vals[i].key, &buf[start], len))
+		if (0 == strncmp(p->vals[i].key, &BUF(p)[start], len))
 			return(&p->vals[i].value);
 	}
 	return(NULL);
@@ -1018,45 +1426,45 @@ valuequery(const struct texi *p, 
  * pointer to its value via valuequery().
  */
 static char **
-valuelquery(struct texi *p, const char *buf, size_t sz, size_t *pos)
+valuelquery(struct texi *p, size_t *pos)
 {
 	size_t	  start, end;
 	char	**ret;
 
-	while (*pos < sz && isws(buf[*pos]))
-		advance(p, buf, pos);
-	if (*pos == sz)
+	while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+		advance(p, pos);
+	if (*pos == BUFSZ(p))
 		return(NULL);
-	for (start = end = *pos; end < sz; end++)
-		if ('\n' == buf[end])
+	for (start = end = *pos; end < BUFSZ(p); end++)
+		if ('\n' == BUF(p)[end])
 			break;
-	advanceto(p, buf, pos, end);
-	if (*pos < sz) {
-		assert('\n' == buf[*pos]);
-		advance(p, buf, pos);
+	advanceto(p, pos, end);
+	if (*pos < BUFSZ(p)) {
+		assert('\n' == BUF(p)[*pos]);
+		advance(p, pos);
 	}
-	if (NULL == (ret = valuequery(p, buf, start, end)))
+	if (NULL == (ret = valuequery(p, start, end)))
 		return(NULL);
 	return(ret);
 }
 
 void
-valuelclear(struct texi *p, const char *buf, size_t sz, size_t *pos)
+valuelclear(struct texi *p, size_t *pos)
 {
 	char	**ret;
 
-	if (NULL == (ret = valuelquery(p, buf, sz, pos)))
+	if (NULL == (ret = valuelquery(p, pos)))
 		return;
 	free(*ret);
 	*ret = NULL;
 }
 
 const char *
-valuellookup(struct texi *p, const char *buf, size_t sz, size_t *pos)
+valuellookup(struct texi *p, size_t *pos)
 {
 	char	**ret;
 
-	if (NULL == (ret = valuelquery(p, buf, sz, pos)))
+	if (NULL == (ret = valuelquery(p, pos)))
 		return(NULL);
 	return(*ret);
 }
@@ -1069,25 +1477,25 @@ valuellookup(struct texi *p, const char *buf, size_t s
  * value had previously been unset.
  */
 const char *
-valueblookup(struct texi *p, const char *buf, size_t sz, size_t *pos)
+valueblookup(struct texi *p, size_t *pos)
 {
 	size_t	  start, end;
 	char	**ret;
 
-	while (*pos < sz && isws(buf[*pos]))
-		advance(p, buf, pos);
-	if (*pos == sz || '{' != buf[*pos])
+	while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+		advance(p, pos);
+	if (*pos == BUFSZ(p) || '{' != BUF(p)[*pos])
 		return(NULL);
-	advance(p, buf, pos);
-	for (start = end = *pos; end < sz; end++)
-		if ('}' == buf[end])
+	advance(p, pos);
+	for (start = end = *pos; end < BUFSZ(p); end++)
+		if ('}' == BUF(p)[end])
 			break;
-	advanceto(p, buf, pos, end);
-	if (*pos < sz) {
-		assert('}' == buf[*pos]);
-		advance(p, buf, pos);
+	advanceto(p, pos, end);
+	if (*pos < BUFSZ(p)) {
+		assert('}' == BUF(p)[*pos]);
+		advance(p, pos);
 	}
-	if (NULL == (ret = valuequery(p, buf, start, end)))
+	if (NULL == (ret = valuequery(p, start, end)))
 		return(NULL);
 	return(*ret);
 }
@@ -1110,7 +1518,7 @@ valueadd(struct texi *p, char *key, char *val)
 		p->vals[i].value = val;
 	} else {
 		/* FIXME: reallocarray() */
-		p->vals = realloc(p->vals, 
+		p->vals = realloc(p->vals,
 			(p->valsz + 1) *
 			 sizeof(struct texivalue));
 		if (NULL == p->vals)
@@ -1131,56 +1539,80 @@ valueadd(struct texi *p, char *key, char *val)
  * Ergo, textual: this doesn't interpret the arguments in any way.
  */
 char **
-argparse(struct texi *p, const char *buf, 
-	size_t sz, size_t *pos, size_t *argsz, size_t hint)
+argparse(struct texi *p, size_t *pos, size_t *argsz, size_t hint)
 {
 	char	**args;
 	size_t	  start, end, stack;
 
-	while (*pos < sz && isws(buf[*pos]))
-		advance(p, buf, pos);
+	while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+		advance(p, pos);
 
 	args = NULL;
 	*argsz = 0;
 
-	/* Check for no arguments. */
-	if ('{' != buf[*pos])
+	if (*pos == BUFSZ(p))
 		return(args);
 
+	if ('{' != BUF(p)[*pos] && hint) {
+		/*
+		 * Special case: if we encounter an unbracketed argument
+		 * and we're being invoked with non-zero arguments
+		 * (versus being set, i.e., hint>0), then parse until
+		 * the end of line.
+		 */
+		*argsz = 1;
+		args = calloc(1, sizeof(char *));
+		if (NULL == args)
+			texiabort(p, NULL);
+		start = *pos;
+		while (*pos < BUFSZ(p)) {
+			if ('\n' == BUF(p)[*pos])
+				break;
+			advance(p, pos);
+		}
+		args[0] = malloc(*pos - start + 1);
+		memcpy(args[0], &BUF(p)[start], *pos - start);
+		args[0][*pos - start] = '\0';
+		if (*pos < BUFSZ(p) && '\n' == BUF(p)[*pos])
+			advance(p, pos);
+		return(args);
+	} else if ('{' != BUF(p)[*pos])
+		return(args);
+
+	assert('{' == BUF(p)[*pos]);
+
 	/* Parse til the closing '}', putting into the array. */
-	advance(p, buf, pos);
-	while (*pos < sz) {
-		while (*pos < sz && isws(buf[*pos]))
-			advance(p, buf, pos);
+	advance(p, pos);
+	while (*pos < BUFSZ(p)) {
+		while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+			advance(p, pos);
 		start = *pos;
 		stack = 0;
-		while (*pos < sz) {
-			/* 
+		while (*pos < BUFSZ(p)) {
+			/*
 			 * According to the manual, commas within
 			 * embedded commands are escaped.
 			 * We keep track of embedded-ness in the "stack"
 			 * state anyway, so this is free.
 			 */
-			if (',' == buf[*pos] && 0 == stack && 1 != hint)
+			if (',' == BUF(p)[*pos] && 0 == stack && 1 != hint)
 				break;
-			else if (0 == stack && '}' == buf[*pos])
+			else if (0 == stack && '}' == BUF(p)[*pos])
 				break;
-			else if (0 != stack && '}' == buf[*pos])
+			else if (0 != stack && '}' == BUF(p)[*pos])
 				stack--;
-			else if ('{' == buf[*pos])
+			else if ('{' == BUF(p)[*pos])
 				stack++;
-			advance(p, buf, pos);
+			advance(p, pos);
 		}
 		if (stack)
 			texiwarn(p, "unterminated macro "
 				"in macro arguments");
-		if ((end = *pos) == sz)
+		if ((end = *pos) == BUFSZ(p))
 			break;
 		/* Test for zero-length '{  }'. */
-		if (start == end && '}' == buf[*pos] && 0 == *argsz)
+		if (start == end && '}' == BUF(p)[*pos] && 0 == *argsz)
 			break;
-		if (start == end)
-			texierr(p, "zero-length argument");
 		/* FIXME: use reallocarray. */
 		args = realloc
 			(args, sizeof(char *) *
@@ -1191,17 +1623,151 @@ argparse(struct texi *p, const char *buf, 
 		if (NULL == args[*argsz])
 			texiabort(p, NULL);
 		memcpy(args[*argsz],
-			&buf[start], end - start);
+			&BUF(p)[start], end - start);
 		args[*argsz][end - start] = '\0';
 		(*argsz)++;
-		if ('}' == buf[*pos])
+		if ('}' == BUF(p)[*pos])
 			break;
-		advance(p, buf, pos);
+		advance(p, pos);
 	}
 
-	if (*pos == sz) 
+	if (*pos == BUFSZ(p))
 		texierr(p, "unterminated arguments");
-	assert('}' == buf[*pos]);
-	advance(p, buf, pos);
+	assert('}' == BUF(p)[*pos]);
+	advance(p, pos);
 	return(args);
 }
+
+/*
+ * If we're printing chapters, then do some naviation here and then
+ * close our outfile.
+ * I want to call this the SEE ALSO section, but that's not really what
+ * it is: we'll refer to the "initial" (top) node and the next and
+ * previous chapters.
+ */
+void
+teximdocclose(struct texi *p, int last)
+{
+	char	 buf[PATH_MAX];
+
+	if (NULL == p->chapters || 1 == p->nodesz)
+		return;
+
+	teximacro(p, "Sh INFO NAVIGATION");
+
+	/* Print a reference to the "top" node. */
+	if (-1 != p->nodecache[p->nodecur].up) {
+		texiputchars(p, "Top node,");
+		snprintf(buf, sizeof(buf), "%s-%zd 7",
+			p->chapters, p->nodecache[p->nodecur].up);
+		p->seenvs = 0;
+		teximacroopen(p, "Xr ");
+		texiputchars(p, buf);
+		texiputchars(p, " ;");
+		teximacroclose(p);
+	}
+
+	if (-1 != p->nodecache[p->nodecur].prev) {
+		texiputchars(p, "previous node,");
+		snprintf(buf, sizeof(buf), "%s-%zd 7",
+			p->chapters, p->nodecache[p->nodecur].prev);
+		p->seenvs = 0;
+		teximacroopen(p, "Xr ");
+		texiputchars(p, buf);
+		if ( ! last)
+			texiputchars(p, " ;");
+		teximacroclose(p);
+	}
+
+	if (-1 != p->nodecache[p->nodecur].next) {
+		texiputchars(p, "next node,");
+		snprintf(buf, sizeof(buf), "%s-%zd 7",
+			p->chapters, p->nodecache[p->nodecur].next);
+		p->seenvs = 0;
+		teximacroopen(p, "Xr ");
+		texiputchars(p, buf);
+		teximacroclose(p);
+	}
+
+	fclose(p->outfile);
+	p->outfile = NULL;
+}
+
+ssize_t
+texicache(struct texi *p, const char *buf, size_t sz)
+{
+	size_t i;
+
+	for (i = 0; i < p->nodecachesz; i++) {
+		if (sz != strlen(p->nodecache[i].name))
+			continue;
+		if (strncmp(buf, p->nodecache[i].name, sz))
+			continue;
+		break;
+	}
+	if (i < p->nodecachesz)
+		return(i);
+	if (NULL == buf)
+		return(-1);
+	p->nodecache = realloc
+		(p->nodecache,
+		 (p->nodecachesz + 1) * sizeof(struct texinode));
+	if (NULL == p->nodecache)
+		texiabort(p, NULL);
+	p->nodecache[p->nodecachesz].name = malloc(sz + 1);
+	if (NULL == p->nodecache[p->nodecachesz].name)
+		texiabort(p, NULL);
+	memcpy(p->nodecache[p->nodecachesz].name, buf, sz);
+	p->nodecache[p->nodecachesz].name[sz] = '\0';
+	p->nodecache[p->nodecachesz].up =
+		p->nodecache[p->nodecachesz].next =
+		p->nodecache[p->nodecachesz].prev = -1;
+	p->nodecachesz++;
+	return(p->nodecachesz - 1);
+}
+
+/*
+ * Here we print our standard mdoc(7) prologue.
+ * We use the title set with @settitle for the `Nd' description
+ * and the source document filename (the first one as invoked on
+ * the command line) for the title.
+ * The date is set to the current date.
+ */
+void
+teximdocopen(struct texi *p, size_t *pos)
+{
+	const char	*cp;
+	time_t		 t;
+	char		 date[32];
+
+	t = time(NULL);
+	strftime(date, sizeof(date), "%F", localtime(&t));
+
+	p->seenvs = -1;
+	teximacroopen(p, "Dd");
+	texiputchars(p, date);
+	teximacroclose(p);
+	teximacroopen(p, "Dt");
+	for (cp = p->title; '\0' != *cp; cp++)
+		texiputchar(p, toupper((unsigned int)*cp));
+	texiputchars(p, " 7");
+	teximacroclose(p);
+	teximacro(p, "Os");
+	teximacro(p, "Sh NAME");
+	teximacroopen(p, "Nm");
+	for (cp = p->title; '\0' != *cp; cp++)
+		texiputchar(p, *cp);
+	teximacroclose(p);
+	teximacroopen(p, "Nd");
+	/*
+	 * The subtitle `Nd' can consist of arbitrary macros, so paste
+	 * it and parse to the end of the line.
+	 */
+	if (NULL != p->subtitle) {
+		texisplice(p, p->subtitle, strlen(p->subtitle), *pos);
+		parseeoln(p, pos);
+	} else
+		texiputchars(p, "Unknown description");
+	teximacroclose(p);
+}
+