===================================================================
RCS file: /cvs/texi2mdoc/util.c,v
retrieving revision 1.20
retrieving revision 1.31
diff -u -p -r1.20 -r1.31
--- texi2mdoc/util.c	2015/03/01 00:25:08	1.20
+++ texi2mdoc/util.c	2015/03/12 04:24:19	1.31
@@ -1,4 +1,4 @@
-/*	$Id: util.c,v 1.20 2015/03/01 00:25:08 kristaps Exp $ */
+/*	$Id: util.c,v 1.31 2015/03/12 04:24:19 kristaps Exp $ */
 /*
  * Copyright (c) 2015 Kristaps Dzonsons <kristaps@bsd.lv>
  *
@@ -31,6 +31,44 @@
 #include "extern.h"
 
 /*
+ * Table of macros.
+ * These ABSOLUTELY MUST BE 2 or three characters long.
+ */
+static	const char *const mdocs[] = {
+	"Ap",		"Dd",		"Dt",		"Os",
+	"Sh",		"Ss",		"Pp",		"D1",
+	"Dl",		"Bd",		"Ed",		"Bl",
+	"El",		"It",		"Ad",		"An",
+	"Ar",		"Cd",		"Cm",		"Dv",
+	"Er",		"Ev",		"Ex",		"Fa",
+	"Fd",		"Fl",		"Fn",		"Ft",
+	"Ic",		"In",		"Li",		"Nd",
+	"Nm",		"Op",		"Ot",		"Pa",
+	"Rv",		"St",		"Va",		"Vt",
+	"Xr",		"%A",		"%B",		"%D",
+	"%I",		"%J",		"%N",		"%O",
+	"%P",		"%R",		"%T",		"%V",
+	"Ac",		"Ao",		"Aq",		"At",
+	"Bc",		"Bf",		"Bo",		"Bq",
+	"Bsx",		"Bx",		"Db",		"Dc",
+	"Do",		"Dq",		"Ec",		"Ef",
+	"Em",		"Eo",		"Fx",		"Ms",
+	"No",		"Ns",		"Nx",		"Ox",
+	"Pc",		"Pf",		"Po",		"Pq",
+	"Qc",		"Ql",		"Qo",		"Qq",
+	"Re",		"Rs",		"Sc",		"So",
+	"Sq",		"Sm",		"Sx",		"Sy",
+	"Tn",		"Ux",		"Xc",		"Xo",
+	"Fo",		"Fc",		"Oo",		"Oc",
+	"Bk",		"Ek",		"Bt",		"Hf",
+	"Fr",		"Ud",		"Lb",		"Lp",
+	"Lk",		"Mt",		"Brq",		"Bro",
+	"Brc",		"%C",		"Es",		"En",
+	"Dx",		"%Q",		"br",		"sp",
+	"%U",		"Ta",		"ll",		NULL,
+	};
+
+/*
  * Unmap the top-most file in the stack of files currently opened (that
  * is, nested calls to parsefile()).
  */
@@ -65,7 +103,121 @@ texivaluefree(struct texivalue *p)
 	free(p->value);
 }
 
+static void
+texidex_free(struct texidex *p)
+{
+	size_t	 i;
+
+	for (i = 0; i < p->indexsz; i++)
+		free(p->index[i].term);
+
+	free(p->index);
+	free(p->name);
+	p->index = NULL;
+	p->indexsz = 0;
+}
+
 /*
+ * Add the text beginning at "index" and of "sz" bytes to the index
+ * named "tok" with name size "toksz".
+ * This will also output the necessary mdoc(7) to construct the index.
+ */
+void
+texindex(struct texi *p, const char *tok,
+	size_t toksz, const char *index, size_t sz)
+{
+	size_t	 i, isz;
+#ifdef HAVE_INDEX
+	char	*cp;
+#endif
+
+	if (0 == sz) {
+		texiwarn(p, "zero-length index entry");
+		return;
+	}
+
+	/* Look for the index.  (Must be found.) */
+	for (i = 0; i < p->indexsz; i++) {
+		if (strlen(p->indexs[i].name) != toksz)
+			continue;
+		if (strncmp(p->indexs[i].name, tok, toksz))
+			continue;
+		break;
+	}
+
+	assert(i < p->indexsz);
+	isz = p->indexs[i].indexsz;
+	/* Reallocate index's terms. */
+	p->indexs[i].index = realloc
+		(p->indexs[i].index,
+		 (isz + 1) * sizeof(struct texiterm));
+	if (NULL == p->indexs[i].index)
+		texiabort(p, NULL);
+
+	/* Add term to term array. */
+	p->indexs[i].index[isz].chapter = p->nodesz - 1;
+	p->indexs[i].index[isz].term = malloc(sz + 1);
+	if (NULL == p->indexs[i].index[isz].term)
+		texiabort(p, NULL);
+	memcpy(p->indexs[i].index[isz].term, index, sz);
+	p->indexs[i].index[isz].term[sz] = '\0';
+	
+	/* Output mdoc(7) for index. */
+#ifdef HAVE_INDEX
+	p->seenvs = -1;
+	teximacroopen(p, "Ix");
+	texiputchars(p, "idx");
+	texiputchars(p, p->indexs[i].name);
+	cp = p->indexs[i].index[isz].term;
+	while ('\n' != *cp) {
+		assert('\0' != *cp);
+		texiputchar(p, *cp++);
+	}
+	teximacroclose(p);
+#endif
+	p->indexs[i].indexsz++;
+}
+
+/*
+ * Add an index entry named "tok" of length "sz".
+ * This usually consists of two letters, e.g., "cp" or "vr".
+ * This does nothing if the index exists or is zero-sized.
+ */
+void
+texindex_add(struct texi *p, const char *tok, size_t sz)
+{
+	size_t	 i;
+	char	*cp;
+
+	if (0 == sz)
+		return;
+
+	/* Make sure we don't have a duplicate. */
+	for (i = 0; i < p->indexsz; i++) {
+		if (strlen(p->indexs[i].name) != sz)
+			continue;
+		if (strncmp(p->indexs[i].name, tok, sz))
+			continue;
+		return;
+	}
+
+	/* Reallocate indices. */
+	p->indexs = realloc(p->indexs, 
+		sizeof(struct texidex) * 
+		(p->indexsz + 1));
+	if (NULL == p->indexs)
+		texiabort(p, NULL);
+	if (NULL == (cp = malloc(sz + 1)))
+		texiabort(p, NULL);
+	memcpy(cp, tok, sz);
+	cp[sz] = '\0';
+	p->indexs[p->indexsz].name = cp;
+	p->indexs[p->indexsz].index = NULL;
+	p->indexs[p->indexsz].indexsz = 0;
+	p->indexsz++;
+}
+
+/*
  * Unmap all files that we're currently using and free all resources
  * that we've allocated during the parse.
  * The utility should exit(...) after this is called.
@@ -90,16 +242,18 @@ texiexit(struct texi *p)
 	for (i = 0; i < p->dirsz; i++)
 		free(p->dirs[i]);
 	for (i = 0; i < p->indexsz; i++)
-		free(p->indexs[i]);
+		texidex_free(&p->indexs[i]);
 	for (i = 0; i < p->valsz; i++) 
 		texivaluefree(&p->vals[i]);
 
+	free(p->nodes);
 	free(p->macros);
 	free(p->vals);
 	free(p->indexs);
 	free(p->dirs);
 	free(p->subtitle);
 	free(p->title);
+	free(p->copying);
 }
 
 /*
@@ -184,10 +338,12 @@ texiputchar(struct texi *p, char c)
 	if ('\'' == c && 0 == p->outcol)
 		fputs("\\&", p->outfile);
 
-	fputc(c, p->outfile);
+	if (p->uppercase)
+		fputc(toupper((unsigned int)c), p->outfile);
+	else
+		fputc(c, p->outfile);
 	if ('\\' == c)
 		fputc('e', p->outfile);
-	p->seenvs = 0;
 	if ('\n' == c) {
 		p->outcol = 0;
 		p->seenws = 0;
@@ -210,8 +366,12 @@ texiputchars(struct texi *p, const char *s)
 		fputs("\\&", p->outfile);
 	if ('\'' == *s && 0 == p->outcol)
 		fputs("\\&", p->outfile);
-	p->outcol += fputs(s, p->outfile);
-	p->seenvs = 0;
+	if (p->uppercase) 
+		for ( ; '\0' != *s; s++)
+			p->outcol += fputc(toupper
+				((unsigned int)*s), p->outfile);
+	else
+		p->outcol += fputs(s, p->outfile);
 }
 
 /*
@@ -235,7 +395,7 @@ void
 teximacroclose(struct texi *p)
 {
 
-	if (p->ign)
+	if (p->ign || p->literal|| TEXILIST_TABLE == p->list)
 		return;
 
 	if (0 == --p->outmacro) {
@@ -255,7 +415,7 @@ teximacroopen(struct texi *p, const char *s)
 {
 	int	 rc;
 
-	if (p->ign)
+	if (p->ign || p->literal|| TEXILIST_TABLE == p->list)
 		return;
 
 	if (p->outcol && 0 == p->outmacro) {
@@ -263,6 +423,9 @@ teximacroopen(struct texi *p, const char *s)
 		p->outcol = 0;
 	}
 
+	if (p->seenvs > 0 && 0 == p->outmacro)
+		fputs(".Pp\n", p->outfile);
+
 	if (0 == p->outmacro)
 		fputc('.', p->outfile);
 	else
@@ -274,7 +437,7 @@ teximacroopen(struct texi *p, const char *s)
 	fputc(' ', p->outfile);
 	p->outcol++;
 	p->outmacro++;
-	p->seenws = 0;
+	p->seenws = p->seenvs = 0;
 }
 
 /*
@@ -291,9 +454,10 @@ teximacro(struct texi *p, const char *s)
 		texierr(p, "\"%s\" in open line scope!?", s);
 	if (p->literal)
 		texierr(p, "\"%s\" in a literal scope!?", s);
-
 	if (p->outcol)
 		fputc('\n', p->outfile);
+	if (p->seenvs > 0)
+		fputs(".Pp\n", p->outfile);
 
 	fputc('.', p->outfile);
 	fputs(s, p->outfile);
@@ -308,10 +472,8 @@ void
 texivspace(struct texi *p)
 {
 
-	if (p->seenvs || TEXILIST_TABLE == p->list)
-		return;
-	teximacro(p, "Pp");
-	p->seenvs = 1;
+	if (TEXILIST_TABLE != p->list && p->seenvs >= 0)
+		p->seenvs = 1;
 }
 
 /*
@@ -362,6 +524,7 @@ texipunctuate(struct texi *p, size_t *pos)
 		case ('.'):
 		case ('"'):
 		case (':'):
+		case (';'):
 		case ('!'):
 		case ('?'):
 			continue;
@@ -373,7 +536,7 @@ texipunctuate(struct texi *p, size_t *pos)
 	if (end == *pos)
 		return;
 	if (end + 1 == BUFSZ(p) || ' ' == BUF(p)[end] || 
-		'\n' == BUF(p)[end]) {
+		'@' == BUF(p)[end] || '\n' == BUF(p)[end]) {
 		for ( ; start < end; start++) {
 			texiputchar(p, ' ');
 			texiputchar(p, BUF(p)[start]);
@@ -401,13 +564,9 @@ advancenext(struct texi *p, size_t *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(p)[*pos] && '\n' == BUF(p)[*pos - 1])
-			texivspace(p);
+		if (0 == p->seenvs && '\n' == BUF(p)[*pos])
+			if (*pos + 1 < BUFSZ(p) && '\n' == BUF(p)[*pos + 1])
+				p->seenvs = 1;
 		advance(p, pos);
 	}
 	return(*pos);
@@ -415,15 +574,18 @@ advancenext(struct texi *p, size_t *pos)
 
 /*
  * Advance to the EOLN in the input stream.
- * NOTE: THIS SHOULD NOT BE CALLED ON BLANK TEXT, as it will read up to
- * the @\n.
+ * This will skip over '@' markers in an effort to ignore escaped
+ * newlines.
  */
 size_t
 advanceeoln(struct texi *p, size_t *pos, int consumenl)
 {
 
-	while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
+	while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
+		if ('@' == BUF(p)[*pos])
+			advance(p, pos);
 		advance(p, pos);
+	}
 	if (*pos < BUFSZ(p) && consumenl)
 		advance(p, pos);
 	return(*pos);
@@ -452,8 +614,13 @@ texiexecmacro(struct texi *p, struct teximacro *m, siz
 	const char	 *cp;
 
 	/* Disregard empty macros. */
-	if (0 == (valsz = realsz = strlen(m->value)))
+	if (0 == (valsz = realsz = strlen(m->value))) {
+		args = argparse(p, pos, &asz, m->argsz);
+		for (i = 0; i < asz; i++)
+			free(args[i]);
+		free(args);
 		return;
+	}
 
 	/*
 	 * This is important: it protect us from macros that invoke more
@@ -463,7 +630,7 @@ texiexecmacro(struct texi *p, struct teximacro *m, siz
 	 * The "sv" value was initialised at the start of the macro.
 	 */
 	if (sv > 0)
-		if (++p->files[p->filepos].depth > 64)
+		if (++p->files[p->filepos - 1].depth > 64)
 			texierr(p, "maximium recursive depth");
 
 	args = argparse(p, pos, &asz, m->argsz);
@@ -472,7 +639,7 @@ texiexecmacro(struct texi *p, struct teximacro *m, siz
 	aasz = asz < m->argsz ? asz : m->argsz;
 
 	if (0 == aasz) {
-		texisplice(p, m->value, valsz, pos);
+		texisplice(p, m->value, valsz, *pos);
 		return;
 	}
 
@@ -535,7 +702,7 @@ texiexecmacro(struct texi *p, struct teximacro *m, siz
 		i = end;
 	}
 
-	texisplice(p, val, strlen(val), pos);
+	texisplice(p, val, strlen(val), *pos);
 
 	for (i = 0; i < asz; i++)
 		free(args[i]);
@@ -551,16 +718,77 @@ texiexecmacro(struct texi *p, struct teximacro *m, siz
 static void
 parseword(struct texi *p, size_t *pos, char extra)
 {
+	size_t	 	 i, end, len;
+	int	 	 c;
 
+	/*
+	 * If a prior word had a terminating double-newline, then begin
+	 * this text block with a `Pp'.
+	 * We don't do this if we're in a literal context (we'll print
+	 * out the newlines themselves) nor in a `TS' table.
+	 */
+	if (p->seenvs > 0 && 0 == p->literal && TEXILIST_TABLE != p->list) {
+		if (p->outcol > 0)
+			fputc('\n', p->outfile);
+		fputs(".Pp\n", p->outfile);
+		p->outcol = 0;
+	}
+
+	/*
+	 * Some line control: if we (non-macro, non-literal) already
+	 * have more than 72 characters written to the screen, then
+	 * output a newline before getting started.
+	 */
 	if (p->seenws && 0 == p->outmacro && 
 		 p->outcol > 72 && 0 == p->literal)
 		texiputchar(p, '\n');
-	/* FIXME: abstract this: we use it elsewhere. */
+
+	/* Usual padding in the case of seen whitespace. */
 	if (p->seenws && p->outcol && 0 == p->literal)
 		texiputchar(p, ' ');
 
 	p->seenws = 0;
 
+	/*
+	 * If we're in a macro line, we might want to print text that
+	 * happens to be the same as an mdoc(7) macro.
+	 * Obviously, we need to escape these words.
+	 */
+	if (p->outmacro) {
+		end = *pos;
+		/* Read ahead to get the word length. */
+		while (end < BUFSZ(p) && ! ismspace(BUF(p)[end])) {
+			switch ((c = BUF(p)[end])) {
+			case ('@'):
+			case ('}'):
+			case ('{'):
+				break;
+			default:
+				if ('\0' != extra && extra == c)
+					break;
+				end++;
+				continue;
+			}
+			break;
+		}
+		len = end - *pos;
+		/* See if we have a match. */
+		for (i = 0; NULL != mdocs[i]; i++) {
+			/* All macros are 2 or three letters. */
+			if (len < 2 || len > 3)
+				continue;
+			/* Check the macro word length. */
+			if ('\0' == mdocs[i][2] && 2 != len)
+				continue;
+			else if ('\0' == mdocs[i][3] && 3 != len)
+				continue;
+			if (strncmp(mdocs[i], &BUF(p)[*pos], len))
+				continue;
+			texiputchars(p, "\\&");
+			break;
+		}
+	}
+
 	while (*pos < BUFSZ(p) && ! ismspace(BUF(p)[*pos])) {
 		switch (BUF(p)[*pos]) {
 		case ('@'):
@@ -570,7 +798,28 @@ parseword(struct texi *p, size_t *pos, char extra)
 		}
 		if ('\0' != extra && BUF(p)[*pos] == extra)
 			return;
-		if (*pos < BUFSZ(p) - 1 && 
+
+		if (p->literal) {
+			texiputchar(p, BUF(p)[*pos]);
+			advance(p, pos);
+			continue;
+		}
+
+		if ('"' == BUF(p)[*pos]) {
+			texiputchars(p, "\\(dq");
+		} else if (*pos < BUFSZ(p) - 2 && 
+			 '-' == BUF(p)[*pos] && 
+			 '-' == BUF(p)[*pos + 1] && 
+			 '-' == BUF(p)[*pos + 2]) {
+			texiputchars(p, "\\(em");
+			advance(p, pos);
+			advance(p, pos);
+		} else if (*pos < BUFSZ(p) - 1 && 
+			 '-' == BUF(p)[*pos] && 
+			 '-' == BUF(p)[*pos + 1]) {
+			texiputchars(p, "\\(en");
+			advance(p, pos);
+		} else if (*pos < BUFSZ(p) - 1 && 
 			 '`' == BUF(p)[*pos] && 
 			 '`' == BUF(p)[*pos + 1]) {
 			texiputchars(p, "\\(lq");
@@ -582,8 +831,27 @@ parseword(struct texi *p, size_t *pos, char extra)
 			advance(p, pos);
 		} else
 			texiputchar(p, BUF(p)[*pos]);
+
 		advance(p, pos);
 	}
+
+	/* 
+	 * New sentence, new line:if we (non-macro, non-literal) see a
+	 * period at the end of the last printed word, then open a
+	 * newline.
+	 */
+	if (0 == p->literal && 0 == p->outmacro && *pos < BUFSZ(p))
+		switch (BUF(p)[*pos - 1]) {
+		case ('.'):
+		case ('!'):
+		case ('?'):
+			texiputchar(p, '\n');
+			break;
+		default:
+			break;
+		}
+
+	p->seenvs = 0;
 }
 
 /*
@@ -607,7 +875,7 @@ texicmd(const struct texi *p, size_t pos, size_t *end,
 		return(TEXICMD__MAX);
 
 	/* Alphabetic commands are special. */
-	if ( ! isalpha((unsigned char)BUF(p)[pos])) {
+	if ( ! isalpha((unsigned int)BUF(p)[pos])) {
 		if ((*end = pos + 1) == BUFSZ(p))
 			return(TEXICMD__MAX);
 		for (i = 0; i < TEXICMD__MAX; i++) {
@@ -637,10 +905,10 @@ texicmd(const struct texi *p, size_t pos, size_t *end,
 
 	/* Look for it in our indices. */
 	for (i = 0; i < p->indexsz; i++) {
-		toksz = strlen(p->indexs[i]);
+		toksz = strlen(p->indexs[i].name);
 		if (len != 5 + toksz)
 			continue;
-		if (strncmp(&BUF(p)[pos], p->indexs[i], toksz))
+		if (strncmp(&BUF(p)[pos], p->indexs[i].name, toksz))
 			continue;
 		if (0 == strncmp(&BUF(p)[pos + toksz], "index", 5))
 			return(TEXICMD_USER_INDEX);
@@ -805,6 +1073,8 @@ parseeoln(struct texi *p, size_t *pos)
 				texiwarn(p, "unexpected \"{\"");
 			advance(p, pos);
 			continue;
+		case ('\n'):
+			continue;
 		case ('@'):
 			break;
 		default:
@@ -827,6 +1097,18 @@ parseeoln(struct texi *p, size_t *pos)
 		advance(p, pos);
 }
 
+enum texicmd
+peeklinecmd(const struct texi *p, size_t pos)
+{
+	size_t		end;
+
+	while (pos < BUFSZ(p) && isws(BUF(p)[pos]))
+		pos++;
+	if (pos == BUFSZ(p) || '@' != BUF(p)[pos])
+		return(TEXICMD__MAX);
+	return(texicmd(p, pos, &end, NULL));
+}
+
 /*
  * Peek to see if there's a command after subsequent whitespace.
  * If so, return the macro identifier.
@@ -927,7 +1209,7 @@ parseeof(struct texi *p)
 }
 
 void
-texisplice(struct texi *p, const char *buf, size_t sz, size_t *pos)
+texisplice(struct texi *p, const char *buf, size_t sz, size_t pos)
 {
 	char		*cp;
 	struct texifile	*f;
@@ -944,8 +1226,8 @@ texisplice(struct texi *p, const char *buf, size_t sz,
 	}
 
 	f->insplice += sz;
-	memmove(f->map + *pos + sz, f->map + *pos, f->mapsz - *pos);
-	memcpy(f->map + *pos, buf, sz);
+	memmove(f->map + pos + sz, f->map + pos, f->mapsz - pos);
+	memcpy(f->map + pos, buf, sz);
 	f->mapsz += sz;
 }
 
@@ -1011,6 +1293,9 @@ parseto(struct texi *p, size_t *pos, const char *endto
 		if (NULL != texitoks[cmd].fp) 
 			(*texitoks[cmd].fp)(p, cmd, pos);
 	}
+
+	if (*pos == BUFSZ(p)) 
+		texiwarn(p, "EOF expecting \"%s\" end\n", endtoken);
 }
 
 /*
@@ -1369,28 +1654,37 @@ teximdocclose(struct texi *p, int last)
 
 	/* Print a reference to the "top" node. */
 	if (p->chapnum > 1) {
-		snprintf(buf, sizeof(buf), "node1 7");
+		texiputchars(p, "Top node,");
+		snprintf(buf, sizeof(buf), "%s-1 7", p->chapters);
+		p->seenvs = 0;
 		teximacroopen(p, "Xr ");
 		texiputchars(p, buf);
-		texiputchars(p, " ,");
+		texiputchars(p, " ;");
 		teximacroclose(p);
 	}
 
 	/* Print a reference to the previous node. */
 	if (p->chapnum > 2) {
+		texiputchars(p, "previous node,");
 		snprintf(buf, sizeof(buf),
-			"node%zu 7", p->chapnum - 1);
+			"%s-%zu 7", p->chapters, p->chapnum - 1);
+		p->seenvs = 0;
 		teximacroopen(p, "Xr ");
 		texiputchars(p, buf);
 		if ( ! last) 
-			texiputchars(p, " ,");
+			texiputchars(p, " ;");
 		teximacroclose(p);
 	} 
 
 	/* Print a reference to the next node. */
 	if ( ! last) {
+		if (1 == p->chapnum)
+			texiputchars(p, "Next node,");
+		else
+			texiputchars(p, "next node,");
 		snprintf(buf, sizeof(buf),
-			"node%zu 7", p->chapnum + 1);
+			"%s-%zu 7", p->chapters, p->chapnum + 1);
+		p->seenvs = 0;
 		teximacroopen(p, "Xr ");
 		texiputchars(p, buf);
 		teximacroclose(p);
@@ -1405,7 +1699,7 @@ teximdocclose(struct texi *p, int last)
  * Otherwise just print the mdoc(7) prologue.
  */
 void
-teximdocopen(struct texi *p)
+teximdocopen(struct texi *p, size_t *pos)
 {
 	const char	*cp;
 	time_t		 t;
@@ -1413,8 +1707,19 @@ teximdocopen(struct texi *p)
 	char	 	 fname[PATH_MAX];
 
 	if (NULL != p->chapters) {
-		snprintf(fname, sizeof(fname), "%s/node%zu.7", 
-			p->chapters, ++p->chapnum);
+		p->chapnum++;
+		snprintf(fname, sizeof(fname), "%s-%zu", 
+			p->chapters, p->chapnum);
+		p->nodes = realloc(p->nodes,
+			(p->nodesz + 1) * sizeof(char *));
+		if (NULL == p->nodes)
+			texiabort(p, NULL);
+		p->nodes[p->nodesz] = strdup(fname);
+		if (NULL == p->nodes[p->nodesz])
+			texiabort(p, NULL);
+		p->nodesz++;
+		snprintf(fname, sizeof(fname), "%s-%zu.7", 
+			p->chapters, p->chapnum);
 		p->outfile = fopen(fname, "w");
 		if (NULL == p->outfile)
 			texiabort(p, fname);
@@ -1430,6 +1735,7 @@ teximdocopen(struct texi *p)
 	t = time(NULL);
 	strftime(date, sizeof(date), "%F", localtime(&t));
 
+	p->seenvs = -1;
 	teximacroopen(p, "Dd");
 	texiputchars(p, date);
 	teximacroclose(p);
@@ -1445,12 +1751,15 @@ teximdocopen(struct texi *p)
 		texiputchar(p, *cp);
 	teximacroclose(p);
 	teximacroopen(p, "Nd");
-	if (NULL != p->subtitle)
-		for (cp = p->subtitle; '\0' != *cp; cp++)
-			texiputchar(p, *cp);
-	else
+	/*
+	 * The subtitle `Nd' can consist of arbitrary macros, so paste
+	 * it and parse to the end of the line.
+	 */
+	if (NULL != p->subtitle) {
+		texisplice(p, p->subtitle, strlen(p->subtitle), *pos);
+		parseeoln(p, pos);
+	} else
 		texiputchars(p, "Unknown description");
 	teximacroclose(p);
-	p->seenvs = 1;
 }