===================================================================
RCS file: /cvs/texi2mdoc/main.c,v
retrieving revision 1.44
retrieving revision 1.58
diff -u -p -r1.44 -r1.58
--- texi2mdoc/main.c	2015/02/24 21:06:52	1.44
+++ texi2mdoc/main.c	2015/03/02 18:12:53	1.58
@@ -1,4 +1,4 @@
-/*	$Id: main.c,v 1.44 2015/02/24 21:06:52 kristaps Exp $ */
+/*	$Id: main.c,v 1.58 2015/03/02 18:12:53 kristaps Exp $ */
 /*
  * Copyright (c) 2015 Kristaps Dzonsons <kristaps@bsd.lv>
  *
@@ -26,7 +26,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <time.h>
+#include <unistd.h>
 
 #include "extern.h"
 
@@ -38,43 +38,43 @@ static	const char *const sects[SECTSZ] = {
 	"No",
 };
 
-static	void doaccent(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doblock(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dobracket(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dodefindex(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dodefn(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doend(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doignargn(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doignblock(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doignbracket(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doignline(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doinline(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doinclude(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doitem(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doitemize(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dolink(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void domacro(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void domath(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void domultitable(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dotable(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dotop(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dosecoffs(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dosection(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dosubsubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dotab(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dotitle(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void dovalue(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doverb(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doverbatim(struct texi *, enum texicmd, const char *, size_t, size_t *);
-static	void doverbinclude(struct texi *, enum texicmd, const char *, size_t, size_t *);
+static	void doaccent(struct texi *, enum texicmd, size_t *);
+static	void doblock(struct texi *, enum texicmd, size_t *);
+static	void dobracket(struct texi *, enum texicmd, size_t *);
+static	void dobye(struct texi *, enum texicmd, size_t *);
+static	void dodefindex(struct texi *, enum texicmd, size_t *);
+static	void dodefn(struct texi *, enum texicmd, size_t *);
+static	void dodisplay(struct texi *, enum texicmd, size_t *);
+static	void doend(struct texi *, enum texicmd, size_t *);
+static	void doenumerate(struct texi *, enum texicmd, size_t *);
+static	void doexample(struct texi *, enum texicmd, size_t *);
+static	void doignargn(struct texi *, enum texicmd, size_t *);
+static	void doignblock(struct texi *, enum texicmd, size_t *);
+static	void doignbracket(struct texi *, enum texicmd, size_t *);
+static	void doignline(struct texi *, enum texicmd, size_t *);
+static	void doinline(struct texi *, enum texicmd, size_t *);
+static	void doinclude(struct texi *, enum texicmd, size_t *);
+static	void doitem(struct texi *, enum texicmd, size_t *);
+static	void doitemize(struct texi *, enum texicmd, size_t *);
+static	void dolink(struct texi *, enum texicmd, size_t *);
+static	void domacro(struct texi *, enum texicmd, size_t *);
+static	void domath(struct texi *, enum texicmd, size_t *);
+static	void domultitable(struct texi *, enum texicmd, size_t *);
+static	void doquotation(struct texi *, enum texicmd, size_t *);
+static	void dotable(struct texi *, enum texicmd, size_t *);
+static	void dotop(struct texi *, enum texicmd, size_t *);
+static	void dosecoffs(struct texi *, enum texicmd, size_t *);
+static	void dosection(struct texi *, enum texicmd, size_t *);
+static	void dosp(struct texi *, enum texicmd, size_t *);
+static	void dosubsection(struct texi *, enum texicmd, size_t *);
+static	void dosubsubsection(struct texi *, enum texicmd, size_t *);
+static	void dosymbol(struct texi *, enum texicmd, size_t *);
+static	void dotab(struct texi *, enum texicmd, size_t *);
+static	void dotitle(struct texi *, enum texicmd, size_t *);
+static	void dovalue(struct texi *, enum texicmd, size_t *);
+static	void doverb(struct texi *, enum texicmd, size_t *);
+static	void doverbatim(struct texi *, enum texicmd, size_t *);
+static	void doverbinclude(struct texi *, enum texicmd, size_t *);
 
 static	const struct texitok __texitoks[TEXICMD__MAX] = {
 	/* TEXICMD__BEGIN */
@@ -268,7 +268,7 @@ static	const struct texitok __texitoks[TEXICMD__MAX] =
 	{ doaccent, "ringaccent", 10 }, /* TEXICMD_RINGACCENT */
 	{ doinline, "samp", 4 }, /* TEXICMD_SAMP */
 	{ doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */
-	{ dobracket, "sc", 2 }, /* TEXICMD_SC */
+	{ doinline, "sc", 2 }, /* TEXICMD_SC */
 	{ dosection, "section", 7 }, /* TEXICMD_SECTION */
 	{ dovalue, "set", 3 }, /* TEXICMD_SET */
 	{ doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */
@@ -295,8 +295,8 @@ static	const struct texitok __texitoks[TEXICMD__MAX] =
 	{ dosubsubsection, "subsubsection", 13 }, /* TEXICMD_SUBSUBSECTION */
 	{ doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */
 	{ doignline, "summarycontents", 15 }, /* TEXICMD_SUMMARYCONTENTS */
-	{ doignline, "synindex", 8 }, /* TEXICMD_SYNINDEX */
-	{ doignline, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */
+	{ dodefindex, "synindex", 8 }, /* TEXICMD_SYNINDEX */
+	{ dodefindex, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */
 	{ doinline, "t", 1 }, /* TEXICMD_T */
 	{ dotab, "tab", 3 }, /* TEXICMD_TAB */
 	{ dosymbol, "\t", 1 }, /* TEXICMD_TABSYM */
@@ -342,26 +342,25 @@ static	const struct texitok __texitoks[TEXICMD__MAX] =
 const	struct texitok *const texitoks = __texitoks;
 
 static void
-dodefindex(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dodefindex(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	size_t	 start, end;
 	char	*cp;
 
-	while (*pos < sz && isws(buf[*pos]))
-		advance(p, buf, pos);
+	while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+		advance(p, pos);
 
 	start = end = *pos;
-	while (end < sz && ! ismspace(buf[end]))
+	while (end < BUFSZ(p) && ! ismspace(BUF(p)[end]))
 		end++;
 
 	if (start == end) {
-		advanceeoln(p, buf, sz, pos, 1);
+		advanceeoln(p, pos, 1);
 		return;
 	} else if (NULL == (cp = malloc(end - start + 1)))
 		texiabort(p, NULL);
 
-	memcpy(cp, &buf[start], end - start);
+	memcpy(cp, &BUF(p)[start], end - start);
 	cp[end - start] = '\0';
 
 	p->indexs = realloc(p->indexs, 
@@ -373,8 +372,7 @@ dodefindex(struct texi *p, enum texicmd cmd, 
 }
 
 static void
-dodefn(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	const char	*blk;
 
@@ -399,8 +397,8 @@ dodefn(struct texi *p, enum texicmd cmd, 
 
 	if (p->ign) {
 		NULL != blk ?
-			parseto(p, buf, sz, pos, blk) :
-			parseeoln(p, buf, sz, pos);
+			parseto(p, pos, blk) :
+			parseeoln(p, pos);
 		return;
 	}
 
@@ -429,17 +427,18 @@ dodefn(struct texi *p, enum texicmd cmd, 
 		texiputchars(p, "Function");
 		break;
 	default:
-		parselinearg(p, buf, sz, pos);
+		parselinearg(p, pos);
 		break;
 	}
 
-	texiputchars(p, ":\n");
+	texiputchar(p, ':');
+	texiputchar(p, '\n');
 
 	switch (cmd) {
 	case (TEXICMD_DEFMAC):
 	case (TEXICMD_DEFMACX):
 		teximacroopen(p, "Dv");
-		while (parselinearg(p, buf, sz, pos)) 
+		while (parselinearg(p, pos)) 
 			/* Spin. */ ;
 		teximacroclose(p);
 		break;
@@ -448,10 +447,10 @@ dodefn(struct texi *p, enum texicmd cmd, 
 	case (TEXICMD_DEFUN):
 	case (TEXICMD_DEFUNX):
 		teximacroopen(p, "Fo");
-		parselinearg(p, buf, sz, pos);
+		parselinearg(p, pos);
 		teximacroclose(p);
 		teximacroopen(p, "Fa");
-		while (parselinearg(p, buf, sz, pos)) 
+		while (parselinearg(p, pos)) 
 			/* Spin. */ ;
 		teximacroclose(p);
 		teximacro(p, "Fc");
@@ -463,13 +462,13 @@ dodefn(struct texi *p, enum texicmd cmd, 
 	case (TEXICMD_DEFTYPEMETHOD):
 	case (TEXICMD_DEFTYPEMETHODX):
 		teximacroopen(p, "Ft");
-		parselinearg(p, buf, sz, pos);
+		parselinearg(p, pos);
 		teximacroclose(p);
 		teximacroopen(p, "Fo");
-		parselinearg(p, buf, sz, pos);
+		parselinearg(p, pos);
 		teximacroclose(p);
 		teximacroopen(p, "Fa");
-		while (parselinearg(p, buf, sz, pos)) 
+		while (parselinearg(p, pos)) 
 			/* Spin. */ ;
 		teximacroclose(p);
 		teximacro(p, "Fc");
@@ -481,7 +480,7 @@ dodefn(struct texi *p, enum texicmd cmd, 
 	case (TEXICMD_DEFTYPEVR):
 	case (TEXICMD_DEFTYPEVRX):
 		teximacroopen(p, "Vt");
-		while (parselinearg(p, buf, sz, pos)) 
+		while (parselinearg(p, pos)) 
 			/* Spin. */ ;
 		teximacroclose(p);
 		break;
@@ -490,7 +489,7 @@ dodefn(struct texi *p, enum texicmd cmd, 
 	case (TEXICMD_DEFVR):
 	case (TEXICMD_DEFVRX):
 		teximacroopen(p, "Va");
-		while (parselinearg(p, buf, sz, pos)) 
+		while (parselinearg(p, pos)) 
 			/* Spin. */ ;
 		teximacroclose(p);
 		break;
@@ -498,14 +497,49 @@ dodefn(struct texi *p, enum texicmd cmd, 
 		abort();
 	}
 
-	texivspace(p);
-	if (NULL != blk)
-		parseto(p, buf, sz, pos, blk);
+	if (NULL == blk)
+		return;
+
+	/*
+	 * All "block" definitions have their block bodies indented
+	 * unless they have the "x" form of the command following.
+	 * E.g.,
+	 *   @deffn some function
+	 *   @deffnx another
+	 *   An explanation.
+	 *   @end deffn
+	 * With this loop, we delay opening the indented block until we
+	 * skipped past conformant macros.
+	 */
+	for (;;) {
+		switch (peekcmd(p, *pos)) {
+		case (TEXICMD_DEFFNX):
+		case (TEXICMD_DEFMACX):
+		case (TEXICMD_DEFTPX):
+		case (TEXICMD_DEFTYPEFNX):
+		case (TEXICMD_DEFTYPEFUNX):
+		case (TEXICMD_DEFTYPEMETHODX):
+		case (TEXICMD_DEFTYPEVARX):
+		case (TEXICMD_DEFTYPEVRX):
+		case (TEXICMD_DEFUNX):
+		case (TEXICMD_DEFVARX):
+		case (TEXICMD_DEFVRX):
+			texivspace(p);
+			parseeoln(p, pos);
+			continue;
+		default:
+			break;
+		}
+		break;
+	}
+	teximacro(p, "Bd -filled -offset indent");
+	p->seenvs = 1;
+	parseto(p, pos, blk);
+	teximacro(p, "Ed");
 }
 
 static void
-domacro(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+domacro(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	size_t		  start, end, endtoksz, len;
 	struct teximacro  m;
@@ -513,42 +547,58 @@ domacro(struct texi *p, enum texicmd cmd, 
 
 	memset(&m, 0, sizeof(struct teximacro));
 
-	while (*pos < sz && isws(buf[*pos]))
-		advance(p, buf, pos);
+	while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+		advance(p, pos);
 
-	for (start = end = *pos; end < sz; end++)
-		if (ismspace(buf[end]) || '{' == buf[end])
+	for (start = end = *pos; end < BUFSZ(p); end++)
+		if (ismspace(BUF(p)[end]) || '{' == BUF(p)[end])
 			break;
 
 	if (start == end)
 		texierr(p, "zero-length macro name");
 
-	advanceto(p, buf, pos, end);
+	advanceto(p, pos, end);
 
 	m.key = malloc(end - start + 1);
 	if (NULL == m.key)
 		texiabort(p, NULL);
-	memcpy(m.key, &buf[start], end - start);
+	memcpy(m.key, &BUF(p)[start], end - start);
 	m.key[end - start] = '\0';
 
-	m.args = argparse(p, buf, sz, pos, &m.argsz, 0);
-	advanceeoln(p, buf, sz, pos, 0);
+	m.args = argparse(p, pos, &m.argsz, 0);
 
+	/* Note: we advance to the beginning of the macro. */
+	advanceeoln(p, pos, 1);
+
+	/*
+	 * According to the Texinfo manual, the macro ends on the
+	 * newline subsequent the @end macro.
+	 * That's COMPLETELY FUCKING WRONG.
+	 * It ends inclusive the newline, which is why so many macros
+	 * say things like @r{hello}@c, where the subsequent @c swallows
+	 * the newline.
+	 * However, it does swallow the leading newline, so look for the
+	 * @end macro without the leading newline else we might look
+	 * past empty macros.
+	 */
 	start = *pos;
-	endtok = "\n@end macro\n";
+	endtok = "@end macro\n";
 	endtoksz = strlen(endtok);
-	blk = memmem(&buf[start], sz, endtok, endtoksz);
+	blk = memmem(&BUF(p)[start], BUFSZ(p) - start, endtok, endtoksz);
 	if (NULL == blk)
 		texierr(p, "unterminated macro body");
-	while (&buf[*pos] != blk)
-		advance(p, buf, pos);
-	assert('\n' == buf[*pos]);
-	advance(p, buf, pos);
-	len = blk - &buf[start];
+	/* Roll us back one character. */
+	while (&BUF(p)[*pos] != blk)
+		advance(p, pos);
+	assert('@' == BUF(p)[*pos]);
+	if ('\n' != BUF(p)[*pos - 1]) 
+		texierr(p, "cannot handle @end macro in-line");
+
+	len = blk - &BUF(p)[start];
 	m.value = malloc(len + 1);
 	if (NULL == m.value)
 		texiabort(p, NULL);
-	memcpy(m.value, &buf[start], len);
+	memcpy(m.value, &BUF(p)[start], len);
 	m.value[len] = '\0';
 
 	p->macros = realloc
@@ -559,54 +609,81 @@ domacro(struct texi *p, enum texicmd cmd, 
 		texiabort(p, NULL);
 
 	p->macros[p->macrosz++] = m;
-	advanceeoln(p, buf, sz, pos, 1);
+	advanceeoln(p, pos, 1);
 }
 
 static void
-doignblock(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doignblock(struct texi *p, enum texicmd cmd, size_t *pos)
 {
-	char		 end[32];
-	const char	*term;
-	size_t		 endsz, endpos;
+	char		 end[32], start[32];
+	const char	*endt, *startt;
+	size_t		 esz, ssz, newpos, stack;
 
 	/* 
-	 * We want to completely ignore everything in these blocks, so
-	 * simply jump to the @end block.
+	 * FIXME: this is cheating.
+	 * These tokens are supposed to begin on a newline.
+	 * However, if we do that, then we would need to check within
+	 * the loop for trailer (or leading, as the case may be)
+	 * newline, and that's just a bit too complicated right now.
+	 * This is becasue
+	 * 	@ifset BAR
+	 * 	@ifset FOO
+	 * 	@end ifset
+	 * 	@end ifset
+	 * won't work right now: we'd read after the first "@end ifset"
+	 * to the next line, then look for the next line after that.
 	 */
-	endsz = snprintf(end, sizeof(end), 
-		"\n@end %s\n", texitoks[cmd].tok);
-	assert(endsz < sizeof(end));
+	ssz = snprintf(start, sizeof(start), 
+		"@%s", texitoks[cmd].tok);
+	assert(ssz < sizeof(start));
+	esz = snprintf(end, sizeof(end), 
+		"@end %s\n", texitoks[cmd].tok);
+	assert(esz < sizeof(end));
+	stack = 1;
 
-	/* 
-	 * Look up where our end token occurs.
-	 * Set our end position based on the relative offset of that
-	 * from our current position, or the EOF if we don't have a
-	 * proper ending point.
+	/*
+	 * Here we look for the end token "end" somewhere in the file in
+	 * front of us.
+	 * It's not that easy, of course: if we have a nested block,
+	 * then there'll be an "end" token of the same kind between us.
+	 * Thus, we keep track of scopes for matching "end" blocks.
 	 */
-	term = memmem(&buf[*pos], sz, end, endsz);
-	endpos = NULL == term ? sz :
-		*pos + (size_t)(term - &buf[*pos]);
-	assert(endpos <= sz);
-	while (*pos < endpos)
-		advance(p, buf, pos);
+	while (stack > 0 && *pos < BUFSZ(p)) {
+		if (stack > 64)
+			texierr(p, "run-away nested stack?");
+		endt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, esz);
+		startt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, start, ssz);
+		if (NULL == endt) {
+			texiwarn(p, "unterminated \"%s\" "
+				"block", texitoks[cmd].tok);
+			*pos = BUFSZ(p);
+			break;
+		} 
 
-	/* Only do this if we're not already at the end. */
-	if (endpos < sz)
-		advanceto(p, buf, pos, endpos + endsz);
+		newpos = *pos;
+		if (NULL == startt || startt > endt) {
+			newpos += esz + (size_t)(endt - &BUF(p)[*pos]);
+			stack--;
+		} else {
+			newpos += ssz + (size_t)(startt - &BUF(p)[*pos]);
+			stack++;
+		}
+
+		assert(newpos <= BUFSZ(p));
+		while (*pos < newpos)
+			advance(p, pos);
+	}
 }
 
 static void
-doblock(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doblock(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	
-	parseto(p, buf, sz, pos, texitoks[cmd].tok);
+	parseto(p, pos, texitoks[cmd].tok);
 }
 
 static void
-doinline(struct texi *p, enum texicmd cmd,
-	const char *buf, size_t sz, size_t *pos)
+doinline(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	const char	*macro = NULL;
 
@@ -648,91 +725,100 @@ doinline(struct texi *p, enum texicmd cmd,
 	}
 
 	if (NULL == macro || p->literal || TEXILIST_TABLE == p->list) {
-		parsebracket(p, buf, sz, pos);
+		if (TEXICMD_SC == cmd)
+			p->uppercase++;
+		parsebracket(p, pos, 0);
+		if (TEXICMD_SC == cmd)
+			p->uppercase--;
 		return;
 	}
 
 	teximacroopen(p, macro);
 	p->seenws = 0;
-	parsebracket(p, buf, sz, pos);
-	texipunctuate(p, buf, sz, pos);
+	if (TEXICMD_SC == cmd)
+		p->uppercase++;
+	parsebracket(p, pos, 0);
+	if (TEXICMD_SC == cmd)
+		p->uppercase--;
+	texipunctuate(p, pos);
 	teximacroclose(p);
 }
 
 static void
-doverb(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doverb(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	char	 delim;
 	size_t	 start;
 
-	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;
-	advance(p, buf, pos);
-	if (*pos == sz)
+	advance(p, pos);
+	if (*pos == BUFSZ(p))
 		return;
 
-	delim = buf[*pos];
-	advance(p, buf, pos);
+	delim = BUF(p)[*pos];
+	advance(p, pos);
 	/* Make sure we flush out our initial whitespace... */
 	if (p->seenws && p->outcol && 0 == p->literal)
 		texiputchar(p, ' ');
 	p->seenws = 0;
 	start = *pos;
 	/* Read until we see the delimiter then end-brace. */
-	while (*pos < sz - 1) {
-		if (buf[*pos] == delim && buf[*pos + 1] == '}') 
+	while (*pos < BUFSZ(p) - 1) {
+		if (BUF(p)[*pos] == delim && BUF(p)[*pos + 1] == '}') 
 			break;
-		advance(p, buf, pos);
+		advance(p, pos);
 	}
-	if (*pos == sz - 1)
+	if (*pos >= BUFSZ(p) - 1)
 		return;
-	texiputbuf(p, buf, start, *pos);
+	texiputbuf(p, start, *pos);
 
 	/* Make sure we read after the end-brace. */
-	assert(delim == buf[*pos]);
-	advance(p, buf, pos);
-	assert('}' == buf[*pos]);
-	advance(p, buf, pos);
+	assert(delim == BUF(p)[*pos]);
+	advance(p, pos);
+	assert('}' == BUF(p)[*pos]);
+	advance(p, pos);
 }
 
 static void
-doverbatim(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doverbatim(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	const char	*end, *term;
 	size_t		 endsz, endpos;
 
-	advanceeoln(p, buf, sz, pos, 1);
-
-	/* We end at exactly this token. */
+	/* We read from the @verbatim\n newline inclusive! */
 	end = "\n@end verbatim\n";
 	endsz = strlen(end);
+	advanceeoln(p, pos, 0);
+	if (*pos == BUFSZ(p)) {
+		texiwarn(p, "unexpected end of file");
+		return;
+	}
 
-	/* 
-	 * Look up where our end token occurs.
-	 * Set our end position based on the relative offset of that
-	 * from our current position.
-	 */
-	term = memmem(&buf[*pos], sz, end, endsz);
-	endpos = NULL == term ? sz :
-		*pos + (size_t)(term - &buf[*pos]);
+	term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);
+	if (NULL == term) {
+		texiwarn(p, "unterminated verbatim block");
+		endpos = BUFSZ(p);
+	} else
+		endpos = *pos + (size_t)(term - &BUF(p)[*pos]);
 
+	assert(endpos <= BUFSZ(p));
+	assert('\n' == BUF(p)[*pos]);
+	advance(p, pos);
 	teximacro(p, "Bd -literal -offset indent");
-	assert(endpos <= sz);
 	while (*pos < endpos) {
-		texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+		texiputchar(p, BUF(p)[*pos]);
+		advance(p, pos);
 	}
 	teximacro(p, "Ed");
-	advanceto(p, buf, pos, endpos + endsz);
+	if (*pos < BUFSZ(p))
+		advanceto(p, pos, endpos + endsz);
 }
 
 static void
-doverbinclude(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doverbinclude(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	char	 	 fname[PATH_MAX], path[PATH_MAX];
 	int	 	 rc;
@@ -740,22 +826,22 @@ doverbinclude(struct texi *p, enum texicmd cmd, 
 	const char	*v;
 	enum texicmd	 type;
 
-	while (*pos < sz && ' ' == buf[*pos])
-		advance(p, buf, pos);
+	while (*pos < BUFSZ(p) && ' ' == BUF(p)[*pos])
+		advance(p, pos);
 
-	for (i = 0; *pos < sz && '\n' != buf[*pos]; ) {
+	for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {
 		if (i == sizeof(fname) - 1)
 			break;
-		if ('@' != buf[*pos]) {
-			fname[i++] = buf[*pos];
-			advance(p, buf, pos);
+		if ('@' != BUF(p)[*pos]) {
+			fname[i++] = BUF(p)[*pos];
+			advance(p, pos);
 			continue;
 		}
-		type = texicmd(p, buf, *pos, sz, &end, NULL);
-		advanceto(p, buf, pos, end);
+		type = texicmd(p, *pos, &end, NULL);
+		advanceto(p, pos, end);
 		if (TEXICMD_VALUE != type) 
 			texierr(p, "unknown verbatiminclude command");
-		v = valueblookup(p, buf, sz, pos);
+		v = valueblookup(p, pos);
 		if (NULL == v)
 			continue;
 		while ('\0' != *v) {
@@ -769,7 +855,7 @@ doverbinclude(struct texi *p, enum texicmd cmd, 
 
 	if (i == 0)
 		texierr(p, "path too short");
-	else if ('\n' != buf[*pos])
+	else if ('\n' != BUF(p)[*pos])
 		texierr(p, "path too long");
 	else if ('/' == fname[0])
 		texierr(p, "no absolute paths");
@@ -789,8 +875,7 @@ doverbinclude(struct texi *p, enum texicmd cmd, 
 }
 
 static void
-doinclude(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doinclude(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	char	 	 fname[PATH_MAX], path[PATH_MAX];
 	size_t	 	 i, end;
@@ -798,23 +883,23 @@ doinclude(struct texi *p, enum texicmd cmd, 
 	const char	*v;
 	enum texicmd	 type;
 
-	while (*pos < sz && ' ' == buf[*pos])
-		advance(p, buf, pos);
+	while (*pos < BUFSZ(p) && ' ' == BUF(p)[*pos])
+		advance(p, pos);
 
 	/* Read in the filename. */
-	for (i = 0; *pos < sz && '\n' != buf[*pos]; ) {
+	for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {
 		if (i == sizeof(fname) - 1)
 			break;
-		if ('@' != buf[*pos]) {
-			fname[i++] = buf[*pos];
-			advance(p, buf, pos);
+		if ('@' != BUF(p)[*pos]) {
+			fname[i++] = BUF(p)[*pos];
+			advance(p, pos);
 			continue;
 		}
-		type = texicmd(p, buf, *pos, sz, &end, NULL);
-		advanceto(p, buf, pos, end);
+		type = texicmd(p, *pos, &end, NULL);
+		advanceto(p, pos, end);
 		if (TEXICMD_VALUE != type) 
 			texierr(p, "unknown include command");
-		v = valueblookup(p, buf, sz, pos);
+		v = valueblookup(p, pos);
 		if (NULL == v)
 			continue;
 		while ('\0' != *v) {
@@ -828,7 +913,7 @@ doinclude(struct texi *p, enum texicmd cmd, 
 
 	if (i == 0)
 		texierr(p, "path too short");
-	else if ('\n' != buf[*pos])
+	else if ('\n' != BUF(p)[*pos])
 		texierr(p, "path too long");
 	else if ('/' == fname[0])
 		texierr(p, "no absolute paths");
@@ -855,18 +940,18 @@ doinclude(struct texi *p, enum texicmd cmd, 
 }
 
 static void
-dobracket(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dobracket(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
-	parsebracket(p, buf, sz, pos);
+	parsebracket(p, pos, 0);
 }
 
 static void
-dodisplay(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dodisplay(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
+	advanceeoln(p, pos, 1);
+
 	switch (cmd) {
 	case (TEXICMD_FORMAT):
 	case (TEXICMD_SMALLFORMAT):
@@ -878,29 +963,25 @@ dodisplay(struct texi *p, enum texicmd cmd, 
 	}
 
 	p->seenvs = 1;
-	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
-	parseto(p, buf, sz, pos, texitoks[cmd].tok);
+	parseto(p, pos, texitoks[cmd].tok);
 	teximacro(p, "Ed");
 }
 
 static void
-doexample(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doexample(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
+	advanceeoln(p, pos, 1);
+
 	teximacro(p, "Bd -literal -offset indent");
-	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
 	p->literal++;
-	parseto(p, buf, sz, pos, texitoks[cmd].tok);
+	parseto(p, pos, texitoks[cmd].tok);
 	p->literal--;
 	teximacro(p, "Ed");
 }
 
 static void
-dobye(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dobye(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
 	texiexit(p);
@@ -908,32 +989,37 @@ dobye(struct texi *p, enum texicmd cmd, 
 }
 
 static void
-dotitle(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dotitle(struct texi *p, enum texicmd cmd, size_t *pos)
 {
-	size_t	 start, end;
+	size_t	 start;
 
-	while (*pos < sz && isws(buf[*pos]))
-		advance(p, buf, pos);
-	start = end = *pos;
-	while (end < sz && '\n' != buf[end])
-		end++;
-	advanceeoln(p, buf, sz, pos, 1);
+	while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+		advance(p, pos);
+
+	/* We want to suck down the entire line, inclusive \n. */
+	start = *pos;
+	while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
+		if ('@' == BUF(p)[*pos])
+			advance(p, pos);
+		advance(p, pos);
+	}
+	if (*pos < BUFSZ(p))
+		advance(p, pos);
+
+	/* Copy this into a buffer. */
 	free(p->subtitle);
-	p->subtitle = malloc(end - start + 1);
-	if (NULL == p->subtitle)
+	if (NULL == (p->subtitle = malloc(*pos - start + 1)))
 		texiabort(p, NULL);
-	memcpy(p->subtitle, &buf[start], end - start);
-	p->subtitle[end - start] = '\0';
+	memcpy(p->subtitle, &BUF(p)[start], *pos - start);
+	p->subtitle[*pos - start] = '\0';
 }
 
 static void
-doaccent(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doaccent(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	int	 brace = 0;
 
-	if (*pos == sz) {
+	if (*pos == BUFSZ(p)) {
 		texiwarn(p, "truncated: @%s", texitoks[cmd].tok);
 		return;
 	}
@@ -951,21 +1037,21 @@ doaccent(struct texi *p, enum texicmd cmd, 
 	 * the critical one.
 	 * Otherwise, space can sit between us and our argument.
 	 */
-	if ('{' == buf[*pos]) {
+	if ('{' == BUF(p)[*pos]) {
 		brace = 1;
-		advance(p, buf, pos);
-	} else if (isalpha(texitoks[cmd].tok[0])) 
-		while (*pos < sz && isws(buf[*pos]))
-			advance(p, buf, pos);
+		advance(p, pos);
+	} else if (isalpha((unsigned char)texitoks[cmd].tok[0])) 
+		while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+			advance(p, pos);
 
-	if (*pos == sz) {
+	if (*pos == BUFSZ(p)) {
 		texiwarn(p, "truncated: @%s", texitoks[cmd].tok);
 		return;
 	}
 
 	switch (cmd) {
 	case (TEXICMD_ACUTE):
-		switch (buf[*pos]) {
+		switch (BUF(p)[*pos]) {
 		case ('a'): case ('A'):
 		case ('e'): case ('E'):
 		case ('i'): case ('I'):
@@ -977,19 +1063,19 @@ doaccent(struct texi *p, enum texicmd cmd, 
 			texiwarn(p, "ignoring accent");
 			break;
 		}
-		texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+		texiputchar(p, BUF(p)[*pos]);
+		advance(p, pos);
 		break;
 	case (TEXICMD_CEDILLA):
-		if ('c' == buf[*pos] || 'C' == buf[*pos])
+		if ('c' == BUF(p)[*pos] || 'C' == BUF(p)[*pos])
 			texiputchars(p, "\\(,");
 		else
 			texiwarn(p, "ignoring accent");
-		texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+		texiputchar(p, BUF(p)[*pos]);
+		advance(p, pos);
 		break;
 	case (TEXICMD_CIRCUMFLEX):
-		switch (buf[*pos]) {
+		switch (BUF(p)[*pos]) {
 		case ('a'): case ('A'):
 		case ('e'): case ('E'):
 		case ('i'): case ('I'):
@@ -1001,19 +1087,19 @@ doaccent(struct texi *p, enum texicmd cmd, 
 			texiwarn(p, "ignoring accent");
 			break;
 		}
-		texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+		texiputchar(p, BUF(p)[*pos]);
+		advance(p, pos);
 		break;
 	case (TEXICMD_DOTLESS):
-		if ('i' == buf[*pos] || 'j' == buf[*pos])
+		if ('i' == BUF(p)[*pos] || 'j' == BUF(p)[*pos])
 			texiputchars(p, "\\(.");
 		else
 			texiwarn(p, "ignoring accent");
-		texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+		texiputchar(p, BUF(p)[*pos]);
+		advance(p, pos);
 		break;
 	case (TEXICMD_GRAVE):
-		switch (buf[*pos]) {
+		switch (BUF(p)[*pos]) {
 		case ('a'): case ('A'):
 		case ('e'): case ('E'):
 		case ('i'): case ('I'):
@@ -1025,11 +1111,11 @@ doaccent(struct texi *p, enum texicmd cmd, 
 			texiwarn(p, "ignoring accent");
 			break;
 		}
-		texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+		texiputchar(p, BUF(p)[*pos]);
+		advance(p, pos);
 		break;
 	case (TEXICMD_TILDE):
-		switch (buf[*pos]) {
+		switch (BUF(p)[*pos]) {
 		case ('a'): case ('A'):
 		case ('n'): case ('N'):
 		case ('o'): case ('O'):
@@ -1039,11 +1125,11 @@ doaccent(struct texi *p, enum texicmd cmd, 
 			texiwarn(p, "ignoring accent");
 			break;
 		}
-		texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+		texiputchar(p, BUF(p)[*pos]);
+		advance(p, pos);
 		break;
 	case (TEXICMD_UMLAUT):
-		switch (buf[*pos]) {
+		switch (BUF(p)[*pos]) {
 		case ('a'): case ('A'):
 		case ('e'): case ('E'):
 		case ('i'): case ('I'):
@@ -1056,22 +1142,22 @@ doaccent(struct texi *p, enum texicmd cmd, 
 			texiwarn(p, "ignoring accent");
 			break;
 		}
-		texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+		texiputchar(p, BUF(p)[*pos]);
+		advance(p, pos);
 		break;
 	default:
-		texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+		texiputchar(p, BUF(p)[*pos]);
+		advance(p, pos);
 		break;
 	}
 
 	if (brace) {
-		while (*pos < sz && '}' != buf[*pos]) {
-			texiputchar(p, buf[*pos]);
-			advance(p, buf, pos);
+		while (*pos < BUFSZ(p) && '}' != BUF(p)[*pos]) {
+			texiputchar(p, BUF(p)[*pos]);
+			advance(p, pos);
 		}
-		if (*pos < sz)
-			advance(p, buf, pos);
+		if (*pos < BUFSZ(p))
+			advance(p, pos);
 	} 
 
 	switch (cmd) {
@@ -1087,8 +1173,7 @@ doaccent(struct texi *p, enum texicmd cmd, 
 }
 
 static void
-dosymbol(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dosymbol(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
 	/* Remember to pad us. */
@@ -1277,128 +1362,88 @@ dosymbol(struct texi *p, enum texicmd cmd, 
 	}
 
 	/* Alphabetic commands have braces we ignore. */
-	if (isalpha(texitoks[cmd].tok[0]))
-		doignbracket(p, cmd, buf, sz, pos);
+	if (isalpha((unsigned char)texitoks[cmd].tok[0]))
+		doignbracket(p, cmd, pos);
 }
 
 static void
-doquotation(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doquotation(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	
 	teximacro(p, "Qo");
-	parseto(p, buf, sz, pos, "quotation");
+	parseto(p, pos, "quotation");
 	teximacro(p, "Qc");
 }
 
 static void
-domath(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+domath(struct texi *p, enum texicmd cmd, size_t *pos)
 {
-	size_t	 nest, start;
 
-	/*
-	 * Math handling is different from everything else.
-	 * We don't allow any subcomponents, and we ignore the rules in
-	 * terms of @-commands.
-	 * This departs from GNU's rules, but whatever.
-	 */
-	while (*pos < sz && isws(buf[*pos]))
-		advance(p, buf, pos);
-	if (*pos == sz || '{' != buf[*pos])
-		return;
-	advance(p, buf, pos);
-	if (p->seenws && p->outcol && 0 == p->literal)
-		texiputchar(p, ' ');
-	p->seenws = 0;
-	for (nest = 1, start = *pos; *pos < sz && nest > 0; ) {
-		if ('{' == buf[*pos])
-			nest++;
-		else if ('}' == buf[*pos])
-			if (0 == --nest)
-				continue;
-		advance(p, buf, pos);
-	}
-	if (*pos == sz)
-		return;
-	assert('}' == buf[*pos]);
-	texiputbuf(p, buf, start, *pos);
-	advance(p, buf, pos);
+	parsebracket(p, pos, 1);
 }
 
 static void
-dovalue(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dovalue(struct texi *p, enum texicmd cmd, size_t *pos)
 {
-	size_t		 start, end, i;
+	size_t		 start, end;
 	char		*key, *val;
 	const char	*cp;
 
 	if (TEXICMD_SET == cmd) {
-		while (*pos < sz && isws(buf[*pos]))
-			advance(p, buf, pos);
-		for (start = end = *pos; end < sz; end++)
-			if (ismspace(buf[end]))
+		while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+			advance(p, pos);
+		for (start = end = *pos; end < BUFSZ(p); end++)
+			if (ismspace(BUF(p)[end]))
 				break;
 		/* We don't allow empty keys. */
 		if (start == end)
 			return;
-		advanceto(p, buf, pos, end);
+		advanceto(p, pos, end);
 
 		key = malloc(end - start + 1);
 		if (NULL == key)
 			texiabort(p, NULL);
-		memcpy(key, &buf[start], end - start);
+		memcpy(key, &BUF(p)[start], end - start);
 		key[end - start] = '\0';
 
-		while (*pos < sz && isws(buf[*pos]))
-			advance(p, buf, pos);
-		for (start = end = *pos; end < sz; end++)
-			if ('\n' == buf[end])
+		while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+			advance(p, pos);
+		for (start = end = *pos; end < BUFSZ(p); end++)
+			if ('\n' == BUF(p)[end])
 				break;
 		/* We do allow empty values. */
-		advanceeoln(p, buf, sz, pos, 1);
+		advanceeoln(p, pos, 1);
 
 		val = malloc(end - start + 1);
 		if (NULL == val)
 			texiabort(p, NULL);
-		memcpy(val, &buf[start], end - start);
+		memcpy(val, &BUF(p)[start], end - start);
 		val[end - start] = '\0';
 		valueadd(p, key, val);
 	} else if (TEXICMD_VALUE == cmd) {
 		if (p->seenws)
 			texiputchar(p, ' ');
 		p->seenws = 0;
-		if (NULL != (cp = valueblookup(p, buf, sz, pos))) {
-			for (i = 0; i < p->valstackpos; i++)
-				if (cp == p->valstack[i])
-					break;
-			if (i < p->valstackpos)
-				texierr(p, "recursive value");
-			if (64 == p->valstackpos) 
-				texierr(p, "too many nested values");
-			p->valstack[p->valstackpos++] = cp;
-			parsemembuf(p, cp, strlen(cp));
-			p->valstackpos--;
-		} else
+		if (NULL != (cp = valueblookup(p, pos)))
+			texisplice(p, cp, strlen(cp), *pos);
+		else
 			texiputchars(p, "{No value}");
 	} else if (TEXICMD_IFCLEAR == cmd) {
-		if (NULL != valuellookup(p, buf, sz, pos))
-			doignblock(p, cmd, buf, sz, pos);
+		if (NULL != valuellookup(p, pos))
+			doignblock(p, cmd, pos);
 		else
-			parseto(p, buf, sz, pos, texitoks[cmd].tok);
+			parseto(p, pos, texitoks[cmd].tok);
 	} else if (TEXICMD_IFSET == cmd) {
-		if (NULL == valuellookup(p, buf, sz, pos))
-			doignblock(p, cmd, buf, sz, pos);
+		if (NULL == valuellookup(p, pos))
+			doignblock(p, cmd,  pos);
 		else
-			parseto(p, buf, sz, pos, texitoks[cmd].tok);
+			parseto(p, pos, texitoks[cmd].tok);
 	} else if (TEXICMD_CLEAR == cmd)
-		valuelclear(p, buf, sz, pos);
+		valuelclear(p, pos);
 }
 
 static void
-dolink(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dolink(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	int	 c;
 
@@ -1427,26 +1472,25 @@ dolink(struct texi *p, enum texicmd cmd, 
 		abort();
 	}
 
-	c = parsearg(p, buf, sz, pos, 0);
+	c = parsearg(p, pos, 0);
 	p->ign++;
 	while (c > 0)
-		c = parsearg(p, buf, sz, pos, 1);
+		c = parsearg(p, pos, 1);
 	p->ign--;
 
-	texipunctuate(p, buf, sz, pos);
+	texipunctuate(p, pos);
 	teximacroclose(p);
 }
 
 static void
-doignargn(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doignargn(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	int	 c;
 
-	c = parsearg(p, buf, sz, pos, 0);
+	c = parsearg(p, pos, 0);
 	p->ign++;
 	while (c > 0)
-		c = parsearg(p, buf, sz, pos, 1);
+		c = parsearg(p, pos, 1);
 	p->ign--;
 }
 
@@ -1471,8 +1515,7 @@ sectioner(struct texi *p, int sec)
 }
 
 static void
-dosubsubsection(struct texi *p, enum texicmd cmd, 
-		const char *buf, size_t sz, size_t *pos)
+dosubsubsection(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	int	 sec;
 
@@ -1481,14 +1524,13 @@ dosubsubsection(struct texi *p, enum texicmd cmd, 
 	/* We don't have a subsubsubsection, so make one up. */
 	texivspace(p);
 	teximacroopen(p, sects[sec]);
-	parseeoln(p, buf, sz, pos);
+	parseeoln(p, pos);
 	teximacroclose(p);
 	texivspace(p);
 }
 
 static void
-dosubsection(struct texi *p, enum texicmd cmd, 
-		const char *buf, size_t sz, size_t *pos)
+dosubsection(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	int	 sec;
 
@@ -1503,15 +1545,14 @@ dosubsection(struct texi *p, enum texicmd cmd, 
 	if (sec > 1)
 		texivspace(p);
 	teximacroopen(p, sects[sec]);
-	parseeoln(p, buf, sz, pos);
+	parseeoln(p, pos);
 	teximacroclose(p);
 	if (sec > 1)
 		texivspace(p);
 }
 
 static void
-dosecoffs(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dosecoffs(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
 	if (TEXICMD_RAISESECTIONS == cmd)
@@ -1521,15 +1562,16 @@ dosecoffs(struct texi *p, enum texicmd cmd, 
 }
 
 static void
-dosection(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dosection(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	int		 sec;
 
 	switch (cmd) {
+	case (TEXICMD_TOP):
+		sec = 0;
+		break;
 	case (TEXICMD_APPENDIX):
 	case (TEXICMD_CHAPTER):
-	case (TEXICMD_TOP):
 	case (TEXICMD_UNNUMBERED):
 		sec = sectioner(p, 0);
 		break;
@@ -1548,74 +1590,42 @@ dosection(struct texi *p, enum texicmd cmd, 
 	else if (p->literal)
 		texierr(p, "\"%s\" in a literal scope!?", sects[sec]);
 
+	if (0 == sec && NULL != p->chapters) {
+		teximdocclose(p, 0);
+		teximdocopen(p, pos);
+	}
+
 	teximacroopen(p, sects[sec]);
-	parseeoln(p, buf, sz, pos);
+	parseeoln(p, pos);
 	teximacroclose(p);
 	p->seenvs = 1;
 }
 
 static void
-dosp(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dotop(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
-	if (p->literal)
-		texiputchar(p, '\n');
-	else
-		texivspace(p);
-	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
+	if (--p->ign)
+		texierr(p, "@top command while ignoring");
+
+	if (NULL == p->chapters)
+		teximdocopen(p, pos);
+	dosection(p, cmd, pos);
 }
 
 static void
-dotop(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dosp(struct texi *p, enum texicmd cmd, size_t *pos)
 {
-	const char	*cp;
-	time_t		 t;
-	char		 date[32];
 
-	if (--p->ign)
-		texierr(p, "@top command while ignoring (%d)", p->ign);
-
-	/*
-	 * 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.
-	 */
-	t = time(NULL);
-	strftime(date, sizeof(date), "%F", localtime(&t));
-
-	teximacroopen(p, "Dd");
-	texiputchars(p, date);
-	teximacroclose(p);
-	teximacroopen(p, "Dt");
-	for (cp = p->title; '\0' != *cp; cp++)
-		texiputchar(p, toupper(*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");
-	if (NULL != p->subtitle)
-		for (cp = p->subtitle; '\0' != *cp; cp++)
-			texiputchar(p, *cp);
+	advanceeoln(p, pos, 1);
+	if (p->literal)
+		texiputchar(p, '\n');
 	else
-		texiputchars(p, "Unknown description");
-	teximacroclose(p);
-	p->seenvs = 1;
-	dosection(p, cmd, buf, sz, pos);
+		texivspace(p);
 }
 
 static void
-doitem(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doitem(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
 	/* Multitable is using raw tbl(7). */
@@ -1643,7 +1653,7 @@ doitem(struct texi *p, enum texicmd cmd, 
 
 	/* Trick so we don't start with Pp. */
 	p->seenvs = 1;
-	parseeoln(p, buf, sz, pos);
+	parseeoln(p, pos);
 
 	if (TEXILIST_ITEM == p->list)
 		teximacroclose(p);
@@ -1652,8 +1662,7 @@ doitem(struct texi *p, enum texicmd cmd, 
 }
 
 static void
-dotab(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dotab(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
 	/* This command is only useful in @multitable. */
@@ -1662,8 +1671,7 @@ dotab(struct texi *p, enum texicmd cmd, 
 }
 
 static void
-domultitable(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+domultitable(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	enum texilist	sv = p->list;
 	int		svliteral = p->literal;
@@ -1680,29 +1688,29 @@ domultitable(struct texi *p, enum texicmd cmd, 
 	columns = 0;
 
 	/* Advance to the first argument... */
-	while (*pos < sz && isws(buf[*pos]))
-		advance(p, buf, pos);
+	while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+		advance(p, pos);
 
 	/* Make sure we don't print anything when scanning. */
 	p->ign++;
-	if ('@' == buf[*pos]) {
+	if (*pos < BUFSZ(p) && '@' == BUF(p)[*pos]) {
 		/* 
 		 * Look for @columnfractions.
 		 * We ignore these, but we do use the number of
 		 * arguments to set the number of columns that we'll
 		 * have.
 		 */
-		type = texicmd(p, buf, *pos, sz, &end, NULL);
-		advanceto(p, buf, pos, end);
+		type = texicmd(p, *pos, &end, NULL);
+		advanceto(p, pos, end);
 		if (TEXICMD_COLUMNFRACTIONS != type) 
 			texierr(p, "unknown multitable command");
-		while (*pos < sz && '\n' != buf[*pos]) {
-			while (*pos < sz && isws(buf[*pos]))
-				advance(p, buf, pos);
-			while (*pos < sz && ! isws(buf[*pos])) {
-				if ('\n' == buf[*pos])
+		while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
+			while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+				advance(p, pos);
+			while (*pos < BUFSZ(p) && ! isws(BUF(p)[*pos])) {
+				if ('\n' == BUF(p)[*pos])
 					break;
-				advance(p, buf, pos);
+				advance(p, pos);
 			}
 			columns++;
 		}
@@ -1713,7 +1721,7 @@ domultitable(struct texi *p, enum texicmd cmd, 
 		 * tbl(7) figure it out.
 		 * So use this only to count arguments.
 		 */
-		while (parselinearg(p, buf, sz, pos) > 0)
+		while (parselinearg(p, pos) > 0)
 			columns++;
 	p->ign--;
 
@@ -1725,7 +1733,7 @@ domultitable(struct texi *p, enum texicmd cmd, 
 	}
 	texiputchars(p, ".\n");
 	p->outmacro++;
-	parseto(p, buf, sz, pos, texitoks[cmd].tok);
+	parseto(p, pos, texitoks[cmd].tok);
 	p->outmacro--;
 	teximacro(p, "TE");
 	p->literal = svliteral;
@@ -1733,86 +1741,80 @@ domultitable(struct texi *p, enum texicmd cmd, 
 }
 
 static void
-dotable(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+dotable(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	enum texilist	sv = p->list;
 
+	advanceeoln(p, pos, 1);
+
 	p->list = TEXILIST_ITEM;
 	teximacro(p, "Bl -tag -width Ds");
-	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
 	p->seenvs = 1;
-	parseto(p, buf, sz, pos, texitoks[cmd].tok);
+	parseto(p, pos, texitoks[cmd].tok);
 	teximacro(p, "El");
 	p->list = sv;
 }
 
 static void
-doend(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doend(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	size_t	 start;
 
-	while (*pos < sz && isws(buf[*pos]))
-		advance(p, buf, pos);
+	while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+		advance(p, pos);
 	start = *pos;
-	while (*pos < sz && '\n' != buf[*pos])
-		advance(p, buf, pos);
+	while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
+		advance(p, pos);
 
-	texiwarn(p, "unexpected \"end\": %.*s", (int)(*pos - start), &buf[start]);
-	advanceeoln(p, buf, sz, pos, 1);
+	texiwarn(p, "unexpected \"end\": %.*s", 
+		(int)(*pos - start), &BUF(p)[start]);
+	advanceeoln(p, pos, 1);
 }
 
 static void
-doenumerate(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doenumerate(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	enum texilist	 sv = p->list;
 
+	advanceeoln(p, pos, 1);
+
 	p->list = TEXILIST_NOITEM;
 	teximacro(p, "Bl -enum");
 	p->seenvs = 1;
-	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
-	parseto(p, buf, sz, pos, "enumerate");
+	parseto(p, pos, texitoks[cmd].tok);
 	teximacro(p, "El");
 	p->list = sv;
 }
 
 static void
-doitemize(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doitemize(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 	enum texilist	sv = p->list;
 
+	advanceeoln(p, pos, 1);
+
 	p->list = TEXILIST_NOITEM;
 	teximacro(p, "Bl -bullet");
 	p->seenvs = 1;
-	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
-	parseto(p, buf, sz, pos, "itemize");
+	parseto(p, pos, texitoks[cmd].tok);
 	teximacro(p, "El");
 	p->list = sv;
 }
 
 static void
-doignbracket(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doignbracket(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
 	p->ign++;
-	parsebracket(p, buf, sz, pos);
+	parsebracket(p, pos, 0);
 	p->ign--;
 }
 
 static void
-doignline(struct texi *p, enum texicmd cmd, 
-	const char *buf, size_t sz, size_t *pos)
+doignline(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
-	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
+	advanceeoln(p, pos, 1);
 }
 
 /*
@@ -1870,10 +1872,14 @@ main(int argc, char *argv[])
 
 	memset(&texi, 0, sizeof(struct texi));
 	texi.ign = 1;
+	texi.outfile = stdout;
 	Idir = NULL;
 
-	while (-1 != (c = getopt(argc, argv, "I:"))) 
+	while (-1 != (c = getopt(argc, argv, "C:I:"))) 
 		switch (c) {
+		case ('C'):
+			texi.chapters = optarg;
+			break;
 		case ('I'):
 			Idir = optarg;
 			break;
@@ -1907,8 +1913,8 @@ main(int argc, char *argv[])
 	}
 
 	texiexit(&texi);
-	return(EXIT_FAILURE);
+	exit(EXIT_SUCCESS);
 usage:
-	fprintf(stderr, "usage: %s [-Idirs] [file]\n", progname);
+	fprintf(stderr, "usage: %s [-Cdir] [-Idirs] [file]\n", progname);
 	return(EXIT_FAILURE);
 }