===================================================================
RCS file: /cvs/texi2mdoc/util.c,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -p -r1.13 -r1.14
--- texi2mdoc/util.c	2015/02/24 14:35:40	1.13
+++ texi2mdoc/util.c	2015/02/25 14:37:17	1.14
@@ -1,4 +1,4 @@
-/*	$Id: util.c,v 1.13 2015/02/24 14:35:40 kristaps Exp $ */
+/*	$Id: util.c,v 1.14 2015/02/25 14:37:17 kristaps Exp $ */
 /*
  * Copyright (c) 2015 Kristaps Dzonsons <kristaps@bsd.lv>
  *
@@ -43,10 +43,7 @@ texifilepop(struct texi *p)
 
 	assert(p->filepos > 0);
 	f = &p->files[--p->filepos];
-	if (TEXISRC_FILE == f->type)
-		munmap(f->map, f->mapsz);
-	else
-		free(f->map);
+	free(f->map);
 }
 
 static void
@@ -206,16 +203,14 @@ texiputchars(struct texi *p, const char *s)
 /*
  * This puts all characters onto the output stream but makes sure to
  * escape mdoc(7) slashes.
+ * FIXME: useless.
  */
 void
-texiputbuf(struct texi *p, const char *buf, size_t start, size_t end)
+texiputbuf(struct texi *p, size_t start, size_t end)
 {
 
-	for ( ; start < end; start++) {
-		texiputchar(p, buf[start]);
-		if ('\\' == buf[start])
-			texiputchar(p, 'e');
-	}
+	for ( ; start < end; start++)
+		texiputchar(p, BUF(p)[start]);
 }
 
 /*
@@ -309,10 +304,10 @@ 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)
 {
 
-	if ('\n' == buf[*pos]) {
+	if ('\n' == BUF(p)[*pos]) {
 		p->files[p->filepos - 1].line++;
 		p->files[p->filepos - 1].col = 0;
 	} else
@@ -329,15 +324,15 @@ 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 ('.'):
@@ -353,11 +348,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] || 
+		'\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);
 		}
 	}
 }
@@ -368,27 +364,27 @@ 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])) {
-			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])
+		if (*pos && '\n' == BUF(p)[*pos] && '\n' == BUF(p)[*pos - 1])
 			texivspace(p);
-		advance(p, buf, pos);
+		advance(p, pos);
 	}
 	return(*pos);
 }
@@ -399,14 +395,13 @@ advancenext(struct texi *p, const char *buf, size_t sz
  * the @\n.
  */
 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])
+		advance(p, pos);
+	if (*pos < BUFSZ(p) && consumenl)
+		advance(p, pos);
 	return(*pos);
 }
 
@@ -415,17 +410,16 @@ 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);
+		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 *pos)
 {
 	size_t		  valsz, realsz, aasz, asz, 
 			   ssz, i, j, k, start, end;
@@ -433,13 +427,13 @@ texiexecmacro(struct texi *p, struct teximacro *m,
 	char		**args;
 	const char	 *cp;
 
-	args = argparse(p, buf, sz, pos, &asz, m->argsz);
+	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, strlen(m->value), pos);
 		return;
 	}
 
@@ -482,15 +476,10 @@ texiexecmacro(struct texi *p, struct teximacro *m,
 
 		/* 
 		 * 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.
+		 * 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;
 		}
 
@@ -508,7 +497,7 @@ texiexecmacro(struct texi *p, struct teximacro *m,
 		i = end;
 	}
 
-	parsemembuf(p, val, strlen(val));
+	texisplice(p, val, strlen(val), pos);
 
 	for (i = 0; i < asz; i++)
 		free(args[i]);
@@ -522,8 +511,7 @@ 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)
 {
 
 	if (p->seenws && 0 == p->outmacro && 
@@ -535,28 +523,28 @@ texiword(struct texi *p, const char *buf, 
 
 	p->seenws = 0;
 
-	while (*pos < sz && ! ismspace(buf[*pos])) {
-		switch (buf[*pos]) {
+	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 (*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);
 	}
 }
 
@@ -566,39 +554,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(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(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. */
@@ -606,7 +593,7 @@ 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);
 	}
 
@@ -615,23 +602,23 @@ texicmd(struct texi *p, const char *buf, size_t pos, 
 		toksz = strlen(p->indexs[i]);
 		if (len != 5 + toksz)
 			continue;
-		if (strncmp(&buf[pos], p->indexs[i], toksz))
+		if (strncmp(&BUF(p)[pos], p->indexs[i], 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);
 }
 
@@ -644,48 +631,47 @@ 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;
 	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);
+		cmd = texicmd(p, *pos, &end, &macro);
+		advanceto(p, pos, end);
 		if (NULL != macro)
-			texiexecmacro(p, macro, buf, sz, pos);
+			texiexecmacro(p, macro, 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);
 }
@@ -695,44 +681,44 @@ 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)
 {
 	size_t		  end;
 	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]) {
+	while ((*pos = advancenext(p, pos)) < BUFSZ(p)) {
+		switch (BUF(p)[*pos]) {
 		case ('}'):
-			advance(p, buf, pos);
+			advance(p, pos);
 			return;
 		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);
+		cmd = texicmd(p, *pos, &end, &macro);
+		advanceto(p, pos, end);
 		if (NULL != macro)
-			texiexecmacro(p, macro, buf, sz, pos);
+			texiexecmacro(p, macro, 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);
 	}
 }
 
@@ -742,88 +728,91 @@ 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;
 	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]) {
+		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);
+		cmd = texicmd(p, *pos, &end, &macro);
+		advanceto(p, pos, end);
 		if (NULL != macro)
-			texiexecmacro(p, macro, buf, sz, pos);
+			texiexecmacro(p, macro, 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);
 }
 
 /*
  * 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)
+static void
+parsesingle(struct texi *p, size_t *pos)
 {
 	size_t		  end;
 	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);
+	cmd = texicmd(p, *pos, &end, &macro);
+	advanceto(p, pos, end);
 	if (NULL != macro)
-		texiexecmacro(p, macro, buf, sz, pos);
+		texiexecmacro(p, macro, 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);
 }
 
 /*
@@ -835,18 +824,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);
+	else if (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
+		parsesingle(p, pos);
 	else
 		return(0);
 
@@ -856,41 +845,35 @@ 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;
+	memmove(f->map + *pos + sz, f->map + *pos, f->mapsz - *pos);
+	memcpy(f->map + *pos, buf, sz);
+	f->mapsz += sz;
 }
 
 /*
@@ -899,8 +882,7 @@ 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;
 	enum texicmd	  cmd;
@@ -910,50 +892,50 @@ parseto(struct texi *p, const char *buf, 
 	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);
+		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);
+			texiexecmacro(p, macro, 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);
 	}
 }
 
@@ -965,7 +947,6 @@ void
 parsestdin(struct texi *p)
 {
 	struct texifile	*f;
-	size_t		 off;
 	ssize_t		 ssz;
 
 	assert(0 == p->filepos);
@@ -975,18 +956,18 @@ parsestdin(struct texi *p)
 	f->type = TEXISRC_STDIN;
 	f->name = "<stdin>";
 
-	for (off = 0; ; off += (size_t)ssz) {
-		if (off == f->mapsz) {
-			if (f->mapsz == (1U << 31))
+	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->mapsz = f->mapsz > 65536 / 2 ? 
-				2 * f->mapsz : 65536;
-			f->map = realloc(f->map, f->mapsz);
+			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)off, f->mapsz - off);
+		ssz = read(STDIN_FILENO, f->map + 
+			(int)f->mapsz, f->mapmaxsz - f->mapsz);
 		if (0 == ssz)
 			break;
 		else if (-1 == ssz) 
@@ -994,7 +975,7 @@ parsestdin(struct texi *p)
 	}
 
 	p->filepos++;
-	parseeof(p, f->map, off);
+	parseeof(p);
 	texifilepop(p);
 }
 
@@ -1011,6 +992,7 @@ parsefile(struct texi *p, const char *fname, int parse
 	int		 fd;
 	struct stat	 st;
 	size_t		 i;
+	char		*map;
 
 	if (64 == p->filepos) 
 		texierr(p, "too many open files");
@@ -1026,22 +1008,28 @@ parsefile(struct texi *p, const char *fname, int parse
 		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) {
 		for (i = 0; i < f->mapsz; i++)
-			texiputchar(p, f->map[i]);
+			texiputchar(p, map[i]);
 		if (p->outcol)
 			texiputchar(p, '\n');
-	} else
-		parseeof(p, f->map, f->mapsz);
+		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);
 }
 
@@ -1053,8 +1041,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;
 
@@ -1066,7 +1053,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);
@@ -1077,45 +1064,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);
 }
@@ -1128,25 +1115,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);
 }
@@ -1190,19 +1177,18 @@ 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;
 
-	if ('{' != buf[*pos] && hint) {
+	if ('{' != BUF(p)[*pos] && hint) {
 		/*
 		 * Special case: if we encounter an unbracketed argument
 		 * and we're being invoked with non-zero arguments
@@ -1214,51 +1200,51 @@ argparse(struct texi *p, const char *buf, 
 		if (NULL == args)
 			texiabort(p, NULL);
 		start = *pos;
-		while (*pos < sz) {
-			if ('\n' == buf[*pos])
+		while (*pos < BUFSZ(p)) {
+			if ('\n' == BUF(p)[*pos])
 				break;
-			advance(p, buf, pos);
+			advance(p, pos);
 		}
 		args[0] = malloc(*pos - start + 1);
-		memcpy(args[0], &buf[start], *pos - start);
+		memcpy(args[0], &BUF(p)[start], *pos - start);
 		args[0][*pos - start] = '\0';
-		if (*pos < sz && '\n' == buf[*pos])
-			advance(p, buf, pos);
+		if (*pos < BUFSZ(p) && '\n' == BUF(p)[*pos])
+			advance(p, pos);
 		return(args);
-	} else if ('{' != buf[*pos])
+	} else if ('{' != BUF(p)[*pos])
 		return(args);
 
 	/* 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;
 		/* FIXME: use reallocarray. */
 		args = realloc
@@ -1270,17 +1256,17 @@ 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);
 }