===================================================================
RCS file: /cvs/texi2mdoc/main.c,v
retrieving revision 1.45
retrieving revision 1.46
diff -u -p -r1.45 -r1.46
--- texi2mdoc/main.c	2015/02/25 10:01:54	1.45
+++ texi2mdoc/main.c	2015/02/25 14:37:17	1.46
@@ -1,4 +1,4 @@
-/*	$Id: main.c,v 1.45 2015/02/25 10:01:54 kristaps Exp $ */
+/*	$Id: main.c,v 1.46 2015/02/25 14:37:17 kristaps Exp $ */
 /*
  * Copyright (c) 2015 Kristaps Dzonsons <kristaps@bsd.lv>
  *
@@ -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 */
@@ -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,7 +427,7 @@ dodefn(struct texi *p, enum texicmd cmd, 
 		texiputchars(p, "Function");
 		break;
 	default:
-		parselinearg(p, buf, sz, pos);
+		parselinearg(p, pos);
 		break;
 	}
 
@@ -439,7 +437,7 @@ dodefn(struct texi *p, enum texicmd 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 +446,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 +461,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 +479,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 +488,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;
@@ -500,12 +498,11 @@ dodefn(struct texi *p, enum texicmd cmd, 
 
 	texivspace(p);
 	if (NULL != blk)
-		parseto(p, buf, sz, pos, blk);
+		parseto(p, pos, blk);
 }
 
 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 +510,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 - start, 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,12 +572,11 @@ 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], start[32];
 	const char	*endt, *startt;
@@ -599,44 +611,42 @@ doignblock(struct texi *p, enum texicmd cmd, 
 	 * then there'll be an "end" token of the same kind between us.
 	 * Thus, we keep track of scopes for matching "end" blocks.
 	 */
-	while (stack > 0 && *pos < sz) {
+	while (stack > 0 && *pos < BUFSZ(p)) {
 		if (stack > 10)
 			abort();
-		endt = memmem(&buf[*pos], sz - *pos, end, esz);
-		startt = memmem(&buf[*pos], sz - *pos, start, ssz);
+		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 = sz;
+			*pos = BUFSZ(p);
 			break;
 		} 
 
 		newpos = *pos;
 		if (NULL == startt || startt > endt) {
-			newpos += esz + (size_t)(endt - &buf[*pos]);
+			newpos += esz + (size_t)(endt - &BUF(p)[*pos]);
 			stack--;
 		} else {
-			newpos += ssz + (size_t)(startt - &buf[*pos]);
+			newpos += ssz + (size_t)(startt - &BUF(p)[*pos]);
 			stack++;
 		}
 
-		assert(newpos <= sz);
+		assert(newpos <= BUFSZ(p));
 		while (*pos < newpos)
-			advance(p, buf, pos);
+			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;
 
@@ -678,59 +688,57 @@ doinline(struct texi *p, enum texicmd cmd,
 	}
 
 	if (NULL == macro || p->literal || TEXILIST_TABLE == p->list) {
-		parsebracket(p, buf, sz, pos);
+		parsebracket(p, pos);
 		return;
 	}
 
 	teximacroopen(p, macro);
 	p->seenws = 0;
-	parsebracket(p, buf, sz, pos);
-	texipunctuate(p, buf, sz, pos);
+	parsebracket(p, pos);
+	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;
@@ -738,35 +746,34 @@ doverbatim(struct texi *p, enum texicmd cmd, 
 	/* We read from the @verbatim\n newline inclusive! */
 	end = "\n@end verbatim\n";
 	endsz = strlen(end);
-	advanceeoln(p, buf, sz, pos, 0);
-	if (*pos == sz) {
+	advanceeoln(p, pos, 0);
+	if (*pos == BUFSZ(p)) {
 		texiwarn(p, "unexpected end of file");
 		return;
 	}
 
-	term = memmem(&buf[*pos], sz - *pos, end, endsz);
+	term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);
 	if (NULL == term) {
 		texiwarn(p, "unterminated verbatim block");
-		endpos = sz;
+		endpos = BUFSZ(p);
 	} else
-		endpos = *pos + (size_t)(term - &buf[*pos]);
+		endpos = *pos + (size_t)(term - &BUF(p)[*pos]);
 
-	assert(endpos <= sz);
-	assert('\n' == buf[*pos]);
-	advance(p, buf, pos);
+	assert(endpos <= BUFSZ(p));
+	assert('\n' == BUF(p)[*pos]);
+	advance(p, pos);
 	teximacro(p, "Bd -literal -offset indent");
 	while (*pos < endpos) {
-		texiputchar(p, buf[*pos]);
-		advance(p, buf, pos);
+		texiputchar(p, BUF(p)[*pos]);
+		advance(p, pos);
 	}
 	teximacro(p, "Ed");
-	if (*pos < sz)
-		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;
@@ -774,22 +781,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) {
@@ -803,7 +810,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");
@@ -823,8 +830,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;
@@ -832,23 +838,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) {
@@ -862,7 +868,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");
@@ -889,16 +895,14 @@ 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);
 }
 
 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)
 {
 
 	switch (cmd) {
@@ -913,28 +917,26 @@ 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);
+	advanceeoln(p, pos, 1);
+	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)
 {
 
 	teximacro(p, "Bd -literal -offset indent");
 	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
+	advanceeoln(p, 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);
@@ -942,32 +944,30 @@ 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;
 
-	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 && '\n' != buf[end])
+	while (end < BUFSZ(p) && '\n' != BUF(p)[end])
 		end++;
-	advanceeoln(p, buf, sz, pos, 1);
+	advanceeoln(p, pos, 1);
 	free(p->subtitle);
 	p->subtitle = malloc(end - start + 1);
 	if (NULL == p->subtitle)
 		texiabort(p, NULL);
-	memcpy(p->subtitle, &buf[start], end - start);
+	memcpy(p->subtitle, &BUF(p)[start], end - start);
 	p->subtitle[end - 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;
 	}
@@ -985,21 +985,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);
+		advance(p, pos);
 	} else if (isalpha(texitoks[cmd].tok[0])) 
-		while (*pos < sz && isws(buf[*pos]))
-			advance(p, buf, pos);
+		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'):
@@ -1011,19 +1011,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'):
@@ -1035,19 +1035,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'):
@@ -1059,11 +1059,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'):
@@ -1073,11 +1073,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'):
@@ -1090,22 +1090,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) {
@@ -1121,8 +1121,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. */
@@ -1312,22 +1311,20 @@ 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);
+		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;
 
@@ -1337,102 +1334,91 @@ domath(struct texi *p, enum texicmd cmd, 
 	 * 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])
+	while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
+		advance(p, pos);
+	if (*pos == BUFSZ(p) || '{' != BUF(p)[*pos])
 		return;
-	advance(p, buf, pos);
+	advance(p, 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])
+	for (nest = 1, start = *pos; *pos < BUFSZ(p) && nest > 0; ) {
+		if ('{' == BUF(p)[*pos])
 			nest++;
-		else if ('}' == buf[*pos])
+		else if ('}' == BUF(p)[*pos])
 			if (0 == --nest)
 				continue;
-		advance(p, buf, pos);
+		advance(p, pos);
 	}
-	if (*pos == sz)
+	if (*pos == BUFSZ(p))
 		return;
-	assert('}' == buf[*pos]);
-	texiputbuf(p, buf, start, *pos);
-	advance(p, buf, pos);
+	assert('}' == BUF(p)[*pos]);
+	texiputbuf(p, start, *pos);
+	advance(p, pos);
 }
 
 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;
 
@@ -1461,26 +1447,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--;
 }
 
@@ -1505,8 +1490,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;
 
@@ -1515,14 +1499,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;
 
@@ -1537,15 +1520,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)
@@ -1555,8 +1537,7 @@ 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;
 
@@ -1583,14 +1564,13 @@ dosection(struct texi *p, enum texicmd cmd, 
 		texierr(p, "\"%s\" in a literal scope!?", sects[sec]);
 
 	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)
+dosp(struct texi *p, enum texicmd cmd, size_t *pos)
 {
 
 	if (p->literal)
@@ -1598,19 +1578,18 @@ dosp(struct texi *p, enum texicmd cmd, 
 	else
 		texivspace(p);
 	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
+	advanceeoln(p, pos, 1);
 }
 
 static void
-dotop(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)
 {
 	const char	*cp;
 	time_t		 t;
 	char		 date[32];
 
 	if (--p->ign)
-		texierr(p, "@top command while ignoring (%d)", p->ign);
+		texierr(p, "@top command while ignoring");
 
 	/*
 	 * Here we print our standard mdoc(7) prologue.
@@ -1644,12 +1623,11 @@ dotop(struct texi *p, enum texicmd cmd, 
 		texiputchars(p, "Unknown description");
 	teximacroclose(p);
 	p->seenvs = 1;
-	dosection(p, cmd, buf, sz, pos);
+	dosection(p, cmd, pos);
 }
 
 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). */
@@ -1677,7 +1655,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);
@@ -1686,8 +1664,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. */
@@ -1696,8 +1673,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;
@@ -1714,29 +1690,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 ('@' == 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++;
 		}
@@ -1747,7 +1723,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--;
 
@@ -1759,7 +1735,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;
@@ -1767,40 +1743,37 @@ 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;
 
 	p->list = TEXILIST_ITEM;
 	teximacro(p, "Bl -tag -width Ds");
 	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
+	advanceeoln(p, 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;
 
@@ -1808,15 +1781,14 @@ doenumerate(struct texi *p, enum texicmd cmd, 
 	teximacro(p, "Bl -enum");
 	p->seenvs = 1;
 	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
-	parseto(p, buf, sz, pos, "enumerate");
+	advanceeoln(p, pos, 1);
+	parseto(p, pos, "enumerate");
 	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;
 
@@ -1824,29 +1796,27 @@ doitemize(struct texi *p, enum texicmd cmd, 
 	teximacro(p, "Bl -bullet");
 	p->seenvs = 1;
 	/* FIXME: ignore and parseeoln. */
-	advanceeoln(p, buf, sz, pos, 1);
-	parseto(p, buf, sz, pos, "itemize");
+	advanceeoln(p, pos, 1);
+	parseto(p, pos, "itemize");
 	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);
 	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);
 }
 
 /*