BROKEN CHECK-IN. Wide-ranging updates.

Removed libmdoc internal argv limit (all dynamic).
Removed "data" union in mdoc_node (to be selectively re-added).

10 files changed, 837 insertions, 851 deletions

diff --git a/action.c b/action.c
index 77cb5b8b..f1224c1d 100644
--- a/action.c
+++ b/action.c
@@ -33,12 +33,24 @@
  * children have been filled in (post-fix order).
  */
 
+enum	merr {
+	ENOWIDTH
+};
+
+enum	mwarn {
+	WBADSEC,
+	WNOWIDTH,
+	WBADDATE
+};
+
 struct	actions {
 	int	(*post)(struct mdoc *);
 };
 
-/* Per-macro action routines. */
-
+static	int	 nwarn(struct mdoc *, 
+			const struct mdoc_node *, enum mwarn);
+static	int	 nerr(struct mdoc *, 
+			const struct mdoc_node *, enum merr);
 static	int	 post_ar(struct mdoc *);
 static	int	 post_bl(struct mdoc *);
 static	int	 post_bl_width(struct mdoc *);
@@ -49,11 +61,8 @@ static	int	 post_nm(struct mdoc *);
 static	int	 post_os(struct mdoc *);
 static	int	 post_sh(struct mdoc *);
 static	int	 post_ex(struct mdoc *);
-
 static	int	 post_prologue(struct mdoc *);
 
-/* Array of macro action routines. */
-
 const	struct actions mdoc_actions[MDOC_MAX] = {
 	{ NULL }, /* \" */
 	{ post_dd }, /* Dd */ 
@@ -165,6 +174,53 @@ const	struct actions mdoc_actions[MDOC_MAX] = {
 };
 
 
+#define	merr(m, t) nerr((m), (m)->last, (t))
+static int
+nerr(struct mdoc *m, const struct mdoc_node *n, enum merr type)
+{
+	char		*p;
+
+	p = NULL;
+
+	switch (type) {
+	case (ENOWIDTH):
+		p = "missing width argument";
+		break;
+	}
+
+	assert(p);
+	return(mdoc_nerr(m, n, p));
+}
+
+
+#define	mwarn(m, t) nwarn((m), (m)->last, (t))
+static int
+nwarn(struct mdoc *m, const struct mdoc_node *n, enum mwarn type)
+{
+	char		*p;
+	int		 c;
+
+	p = NULL;
+	c = WARN_SYNTAX;
+
+	switch (type) {
+	case (WBADSEC):
+		p = "inappropriate document section in manual section";
+		c = WARN_COMPAT;
+		break;
+	case (WNOWIDTH):
+		p = "cannot determine default width";
+		break;
+	case (WBADDATE):
+		p = "malformed date syntax";
+		break;
+	}
+
+	assert(p);
+	return(mdoc_nwarn(m, n, c, p));
+}
+
+
 static int
 post_ex(struct mdoc *mdoc)
 {
@@ -174,19 +230,22 @@ post_ex(struct mdoc *mdoc)
 	 * our name (if it's been set).
 	 */
 
-	if (0 == mdoc->last->data.elem.argc)
+	if (NULL == mdoc->last->args)
 		return(1);
-	if (mdoc->last->data.elem.argv[0].sz)
+	if (mdoc->last->args->argv[0].sz)
 		return(1);
 
 	assert(mdoc->meta.name);
 
 	mdoc_msg(mdoc, "writing %s argument: %s", 
-			mdoc_argnames[MDOC_Std], mdoc->meta.name);
+			mdoc_argnames[MDOC_Std], 
+			mdoc->meta.name);
 
-	mdoc->last->data.elem.argv[0].sz = 1;
-	mdoc->last->data.elem.argv[0].value = xcalloc(1, sizeof(char *));
-	mdoc->last->data.elem.argv[0].value[0] = xstrdup(mdoc->meta.name);
+	assert(1 == mdoc->last->args->argv[0].sz);
+
+	mdoc->last->args->argv[0].sz = 1;
+	mdoc->last->args->argv[0].value = xcalloc(1, sizeof(char *));
+	mdoc->last->args->argv[0].value[0] = xstrdup(mdoc->meta.name);
 	return(1);
 }
 
@@ -240,9 +299,7 @@ post_sh(struct mdoc *mdoc)
 		case (9):
 			break;
 		default:
-			return(mdoc_warn(mdoc, WARN_COMPAT,
-					"inappropriate section for "
-					"manual section"));
+			return(mwarn(mdoc, WBADSEC));
 		}
 		break;
 	default:
@@ -288,7 +345,7 @@ post_dt(struct mdoc *mdoc)
 	 *   --> title = TITLE, volume = local, msec = 0, arch = NULL
 	 */
 
-	mdoc->meta.title = xstrdup(n->data.text.string);
+	mdoc->meta.title = xstrdup(n->string);
 	mdoc_msg(mdoc, "title: %s", mdoc->meta.title);
 
 	if (NULL == (n = n->next)) {
@@ -306,14 +363,14 @@ post_dt(struct mdoc *mdoc)
 	 *       arch = NULL
 	 */
 
-	if ((cp = mdoc_a2msec(n->data.text.string))) {
+	if ((cp = mdoc_a2msec(n->string))) {
 		mdoc->meta.vol = xstrdup(cp);
 		errno = 0;
-		lval = strtol(n->data.text.string, &ep, 10);
-		if (n->data.text.string[0] != '\0' && *ep == '\0')
+		lval = strtol(n->string, &ep, 10);
+		if (n->string[0] != '\0' && *ep == '\0')
 			mdoc->meta.msec = (int)lval;
 	} else 
-		mdoc->meta.vol = xstrdup(n->data.text.string);
+		mdoc->meta.vol = xstrdup(n->string);
 
 	if (NULL == (n = n->next)) {
 		mdoc_msg(mdoc, "volume: %s", mdoc->meta.vol);
@@ -329,15 +386,15 @@ post_dt(struct mdoc *mdoc)
 	 *               VOL
 	 */
 
-	if ((cp = mdoc_a2vol(n->data.text.string))) {
+	if ((cp = mdoc_a2vol(n->string))) {
 		free(mdoc->meta.vol);
 		mdoc->meta.vol = xstrdup(cp);
 		n = n->next;
 	} else {
-		cp = mdoc_a2arch(n->data.text.string);
+		cp = mdoc_a2arch(n->string);
 		if (NULL == cp) {
 			free(mdoc->meta.vol);
-			mdoc->meta.vol = xstrdup(n->data.text.string);
+			mdoc->meta.vol = xstrdup(n->string);
 		} else
 			mdoc->meta.arch = xstrdup(cp);
 	}	
@@ -385,7 +442,6 @@ static int
 post_bl_tagwidth(struct mdoc *mdoc)
 {
 	struct mdoc_node  *n;
-	struct mdoc_block *b;
 	int		   sz;
 	char		   buf[32];
 
@@ -394,30 +450,25 @@ post_bl_tagwidth(struct mdoc *mdoc)
 	 * to intuit our width from the first body element.  
 	 */
 
-	b = &mdoc->last->data.block;
-
-	if (NULL == (n = b->body->child))
+	if (NULL == (n = mdoc->last->body->child))
 		return(1);
-	assert(MDOC_It == n->tok);
 
 	/*
 	 * Use the text width, if a text node, or the default macro
 	 * width if a macro.
 	 */
 
-	if ((n = n->data.block.head->child)) {
+	if ((n = n->head->child)) {
 		if (MDOC_TEXT != n->type) {
-			if (0 == (sz = mdoc_macro2len(n->tok)))
+			if (0 == (sz = (int)mdoc_macro2len(n->tok)))
 				sz = -1;
 		} else
-			sz = (int)strlen(n->data.text.string) + 1;
+			sz = (int)strlen(n->string) + 1;
 	} else
 		sz = -1;
 
 	if (-1 == sz) {
-		if ( ! mdoc_warn(mdoc, WARN_SYNTAX,
-				"cannot determine default %s",
-				mdoc_argnames[MDOC_Width]))
+		if ( ! mwarn(mdoc, WNOWIDTH))
 			return(0);
 		sz = 10;
 	}
@@ -429,38 +480,53 @@ post_bl_tagwidth(struct mdoc *mdoc)
 	 * We're guaranteed that a MDOC_Width doesn't already exist.
 	 */
 
-	(b->argc)++;
-	b->argv = xrealloc(b->argv, b->argc * sizeof(struct mdoc_arg));
+	if (NULL == mdoc->last->args) {
+		mdoc->last->args = xcalloc
+			(1, sizeof(struct mdoc_arg));
+		mdoc->last->args->refcnt = 1;
+	}
+
+	n = mdoc->last;
+	sz = (int)n->args->argc;
+	
+	(n->args->argc)++;
+
+	n->args->argv = xrealloc(n->args->argv, 
+			n->args->argc * sizeof(struct mdoc_arg));
 
-	b->argv[b->argc - 1].arg = MDOC_Width;
-	b->argv[b->argc - 1].line = mdoc->last->line;
-	b->argv[b->argc - 1].pos = mdoc->last->pos;
-	b->argv[b->argc - 1].sz = 1;
-	b->argv[b->argc - 1].value = xcalloc(1, sizeof(char *));
-	b->argv[b->argc - 1].value[0] = xstrdup(buf);
+	n->args->argv[sz - 1].arg = MDOC_Width;
+	n->args->argv[sz - 1].line = mdoc->last->line;
+	n->args->argv[sz - 1].pos = mdoc->last->pos;
+	n->args->argv[sz - 1].sz = 1;
+	n->args->argv[sz - 1].value = xcalloc(1, sizeof(char *));
+	n->args->argv[sz - 1].value[0] = xstrdup(buf);
 
-	mdoc_msg(mdoc, "adding %s argument: %dn", 
-			mdoc_argnames[MDOC_Width], sz);
+	mdoc_msg(mdoc, "adding %s argument: %s", 
+			mdoc_argnames[MDOC_Width], buf);
 
 	return(1);
 }
 
 
 static int
-post_bl_width(struct mdoc *mdoc)
+post_bl_width(struct mdoc *m)
 {
 	size_t		  width;
 	int		  i, tok;
 	char		  buf[32];
 	char		**p;
 
-	for (i = 0; i < (int)mdoc->last->data.block.argc; i++) 
-		if (MDOC_Width == mdoc->last->data.block.argv[i].arg)
+	if (NULL == m->last->args)
+		return(merr(m, ENOWIDTH));
+
+	for (i = 0; i < (int)m->last->args->argc; i++)
+		if (MDOC_Width == m->last->args->argv[i].arg)
 			break;
 
-	assert(i < (int)mdoc->last->data.block.argc);
-	assert(1 == mdoc->last->data.block.argv[i].sz);
-	p = &mdoc->last->data.block.argv[i].value[0];
+	if (i == (int)m->last->args->argc)
+		return(merr(m, ENOWIDTH));
+
+	p = &m->last->args->argv[i].value[0];
 
 	/*
 	 * If the value to -width is a macro, then we re-write it to be
@@ -469,14 +535,12 @@ post_bl_width(struct mdoc *mdoc)
 
 	if (xstrcmp(*p, "Ds"))
 		width = 8;
-	else if (MDOC_MAX == (tok = mdoc_find(mdoc, *p)))
+	else if (MDOC_MAX == (tok = mdoc_tokhash_find(m->htab, *p)))
 		return(1);
 	else if (0 == (width = mdoc_macro2len(tok))) 
-		return(mdoc_warn(mdoc, WARN_SYNTAX,
-					"%s macro has no length", 
-					mdoc_argnames[MDOC_Width]));
+		return(mwarn(m, WNOWIDTH));
 
-	mdoc_msg(mdoc, "re-writing %s argument: %s -> %zun", 
+	mdoc_msg(m, "re-writing %s argument: %s -> %zun", 
 			mdoc_argnames[MDOC_Width], *p, width);
 
 	/* The value already exists: free and reallocate it. */
@@ -484,7 +548,7 @@ post_bl_width(struct mdoc *mdoc)
 	(void)snprintf(buf, sizeof(buf), "%zun", width);
 
 	free(*p);
-	*p = strdup(buf);
+	*p = xstrdup(buf);
 
 	return(1);
 }
@@ -493,7 +557,7 @@ post_bl_width(struct mdoc *mdoc)
 static int
 post_bl(struct mdoc *mdoc)
 {
-	int		  i, r;
+	int		  i, r, len;
 
 	if (MDOC_BLOCK != mdoc->last->type)
 		return(1);
@@ -506,10 +570,12 @@ post_bl(struct mdoc *mdoc)
 	 * rewritten into real lengths).
 	 */
 
-	for (r = i = 0; i < (int)mdoc->last->data.block.argc; i++) {
-		if (MDOC_Tag == mdoc->last->data.block.argv[i].arg)
+	len = (int)(mdoc->last->args ? mdoc->last->args->argc : 0);
+
+	for (r = i = 0; i < len; i++) {
+		if (MDOC_Tag == mdoc->last->args->argv[i].arg)
 			r |= 1 << 0;
-		if (MDOC_Width == mdoc->last->data.block.argv[i].arg)
+		if (MDOC_Width == mdoc->last->args->argv[i].arg)
 			r |= 1 << 1;
 	}
 
@@ -556,8 +622,11 @@ post_dd(struct mdoc *mdoc)
 
 	(void)xstrlcpys(buf, mdoc->last->child, sizeof(buf));
 
-	if (0 == (mdoc->meta.date = mdoc_atotime(buf)))
-		return(mdoc_err(mdoc, "invalid date syntax"));
+	if (0 == (mdoc->meta.date = mdoc_atotime(buf))) {
+		if ( ! mwarn(mdoc, WBADDATE))
+			return(0);
+		mdoc->meta.date = time(NULL);
+	}
 
 	mdoc_msg(mdoc, "date: %u", mdoc->meta.date);
 	return(post_prologue(mdoc));
diff --git a/argv.c b/argv.c
index 2394426a..75823ec5 100644
--- a/argv.c
+++ b/argv.c
@@ -29,6 +29,8 @@
  * Routines to parse arguments of macros.  Arguments follow the syntax
  * of `-arg [val [valN...]]'.  Arguments come in all types:  quoted
  * arguments, multiple arguments per value, no-value arguments, etc.
+ *
+ * There's no limit to the number or arguments that may be allocated.
  */
 
 #define	ARGS_QUOTED	(1 << 0)
@@ -41,32 +43,31 @@
 #define	ARGV_MULTI	(1 << 2)
 #define	ARGV_OPT_SINGLE	(1 << 3)
 
+enum 	mwarn {
+	WQUOTPARM,
+	WARGVPARM,
+	WCOLEMPTY,
+	WTAILWS	
+};
+
+enum	merr {
+	EQUOTTERM,
+	EARGVAL	
+};
+
 static	int		 argv_a2arg(int, const char *);
 static	int		 args(struct mdoc *, int, int *, 
 				char *, int, char **);
 static	int		 argv(struct mdoc *, int, int,
-				struct mdoc_arg *, int *, char *);
+				struct mdoc_argv *, int *, char *);
 static	int		 argv_single(struct mdoc *, int, 
-				struct mdoc_arg *, int *, char *);
+				struct mdoc_argv *, int *, char *);
 static	int		 argv_opt_single(struct mdoc *, int, 
-				struct mdoc_arg *, int *, char *);
+				struct mdoc_argv *, int *, char *);
 static	int		 argv_multi(struct mdoc *, int, 
-				struct mdoc_arg *, int *, char *);
-static	int		 pwarn(struct mdoc *, int, int, int);
-static	int		 perr(struct mdoc *, int, int, int);
-
-/* Warning messages. */
-
-#define	WQUOTPARM	(0)
-#define	WARGVPARM	(1)
-#define	WCOLEMPTY	(2)
-#define	WTAILWS		(3)
-
-/* Error messages. */
-
-#define	EQUOTTERM	(0)
-#define	EARGVAL		(1)
-#define	EARGMANY	(2)
+				struct mdoc_argv *, int *, char *);
+static	int		 pwarn(struct mdoc *, int, int, enum mwarn);
+static	int		 perr(struct mdoc *, int, int, enum merr);
 
 /* Per-argument flags. */
 
@@ -209,59 +210,158 @@ static	int mdoc_argflags[MDOC_MAX] = {
 };
 
 
+/*
+ * Parse an argument from line text.  This comes in the form of -key
+ * [value0...], which may either have a single mandatory value, at least
+ * one mandatory value, an optional single value, or no value.
+ */
+int
+mdoc_argv(struct mdoc *mdoc, int line, int tok,
+		struct mdoc_arg **v, int *pos, char *buf)
+{
+	int		  i;
+	char		 *p;
+	struct mdoc_argv tmp;
+	struct mdoc_arg	 *arg;
+
+	if (0 == buf[*pos])
+		return(ARGV_EOLN);
+
+	assert( ! isspace((u_char)buf[*pos]));
+
+	if ('-' != buf[*pos])
+		return(ARGV_WORD);
+
+	i = *pos;
+	p = &buf[++(*pos)];
+
+	assert(*pos > 0);
+
+	/* LINTED */
+	while (buf[*pos]) {
+		if (isspace((u_char)buf[*pos])) 
+			if ('\\' != buf[*pos - 1])
+				break;
+		(*pos)++;
+	}
+
+	if (buf[*pos])
+		buf[(*pos)++] = 0;
+
+	(void)memset(&tmp, 0, sizeof(struct mdoc_argv));
+	tmp.line = line;
+	tmp.pos = *pos;
+
+	/*
+	 * We now parse out the per-macro arguments.  XXX - this can be
+	 * made much cleaner using per-argument tables.  See argv_a2arg
+	 * for details.
+	 */
+
+	if (MDOC_ARG_MAX == (tmp.arg = argv_a2arg(tok, p))) {
+		if ( ! pwarn(mdoc, line, i, WARGVPARM))
+			return(ARGV_ERROR);
+		return(ARGV_WORD);
+	}
+
+	while (buf[*pos] && isspace((u_char)buf[*pos]))
+		(*pos)++;
+
+	/* FIXME: whitespace if no value. */
+
+	if ( ! argv(mdoc, tok, line, &tmp, pos, buf))
+		return(ARGV_ERROR);
+
+	if (NULL == (arg = *v)) {
+		v = xcalloc(1, sizeof(struct mdoc_arg));
+		arg = *v;
+	}
+
+	arg->argc++;
+	arg->argv = xrealloc(arg->argv, arg->argc * 
+			sizeof(struct mdoc_arg));
+
+	(void)memcpy(&arg->argv[(int)arg->argc - 1], 
+			&tmp, sizeof(struct mdoc_argv));
+
+	return(ARGV_ARG);
+}
+
+
+void
+mdoc_argv_free(struct mdoc_arg *p)
+{
+	int		 i, j;
+
+	if (p->refcnt && --(p->refcnt) > 0)
+		return;
+
+	/* LINTED */
+	for (i = 0; i < (int)p->argc; i++) {
+		if (0 == p->argv[i].sz)
+			continue;
+		/* LINTED */
+		for (j = 0; j < (int)p->argv[i].sz; j++)
+			free(p->argv[i].value[j]);
+		free(p->argv[i].value);
+	}
+
+	if (p->argc)
+		free(p->argv);
+	free(p);
+}
+
+
+
 static int
-perr(struct mdoc *mdoc, int line, int pos, int code)
+perr(struct mdoc *mdoc, int line, int pos, enum merr code)
 {
-	int		 c;
+	char		*p;
+
+	p = NULL;
 
 	switch (code) {
 	case (EQUOTTERM):
-		c = mdoc_perr(mdoc, line, pos, 
-				"unterminated quoted parameter");
+		p = "unterminated quoted parameter";
 		break;
 	case (EARGVAL):
-		c = mdoc_perr(mdoc, line, pos, 
-				"argument requires a value");
+		p = "argument requires a value";
 		break;
-	case (EARGMANY):
-		c = mdoc_perr(mdoc, line, pos, 
-				"too many values for argument");
-		break;
-	default:
-		abort();
-		/* NOTREACHED */
 	}
-	return(c);
+
+	assert(p);
+	return(mdoc_perr(mdoc, line, pos, p));
 }
 
 
 static int
-pwarn(struct mdoc *mdoc, int line, int pos, int code)
+pwarn(struct mdoc *mdoc, int line, int pos, enum mwarn code)
 {
+	char		*p;
 	int		 c;
 
+	p = NULL;
+	c = WARN_SYNTAX;
+
 	switch (code) {
 	case (WQUOTPARM):
-		c = mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX, 
-				"unexpected quoted parameter");
+		p = "unexpected quoted parameter";
 		break;
 	case (WARGVPARM):
-		c = mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX, 
-				"argument-like parameter");
+		p = "argument-like parameter";
 		break;
 	case (WCOLEMPTY):
-		c = mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX, 
-				"last list column is empty");
+		p = "last list column is empty";
+		c = WARN_COMPAT;
 		break;
 	case (WTAILWS):
-		c = mdoc_pwarn(mdoc, line, pos, WARN_COMPAT, 
-				"trailing whitespace");
+		p = "trailing whitespace";
+		c = WARN_COMPAT;
 		break;
-	default:
-		abort();
-		/* NOTREACHED */
 	}
-	return(c);
+
+	assert(p);
+	return(mdoc_pwarn(mdoc, line, pos, c, p));
 }
 
 
@@ -287,7 +387,7 @@ mdoc_args(struct mdoc *mdoc, int line,
 				break;
 
 		assert(n);
-		c = (int)n->data.block.argc;
+		c = (int)(n->args ? n->args->argc : 0);
 		assert(c > 0);
 
 		/*
@@ -298,7 +398,7 @@ mdoc_args(struct mdoc *mdoc, int line,
 
 		/* LINTED */
 		for (i = 0; i < c; i++) {
-			switch (n->data.block.argv[i].arg) {
+			switch (n->args->argv[i].arg) {
 			case (MDOC_Column):
 				fl |= ARGS_TABSEP;
 				fl &= ~ARGS_DELIM;
@@ -312,6 +412,7 @@ mdoc_args(struct mdoc *mdoc, int line,
 				break;
 			}
 		}
+		break;
 	default:
 		break;
 	}
@@ -621,48 +722,43 @@ argv_a2arg(int tok, const char *argv)
 
 static int
 argv_multi(struct mdoc *mdoc, int line, 
-		struct mdoc_arg *v, int *pos, char *buf)
+		struct mdoc_argv *v, int *pos, char *buf)
 {
 	int		 c, ppos;
 	char		*p;
 
-	v->sz = 0;
-	v->value = xcalloc(MDOC_LINEARG_MAX, sizeof(char *));
-
 	ppos = *pos;
 
-	for (v->sz = 0; v->sz < MDOC_LINEARG_MAX; v->sz++) {
+	for (v->sz = 0; ; v->sz++) {
 		if ('-' == buf[*pos])
 			break;
 		c = args(mdoc, line, pos, buf, ARGS_QUOTED, &p);
-		if (ARGS_ERROR == c) {
-			free(v->value);
+		if (ARGS_ERROR == c)
 			return(0);
-		} else if (ARGS_EOLN == c)
+		else if (ARGS_EOLN == c)
 			break;
+
+		if (0 == v->sz % 5)
+			v->value = xrealloc(v->value, 
+				(v->sz + 5) * sizeof(char *));
+
 		v->value[(int)v->sz] = p;
 	}
 
-	if (0 < v->sz && v->sz < MDOC_LINEARG_MAX)
+	if (v->sz)
 		return(1);
 
-	free(v->value);
-	if (0 == v->sz) 
-		return(perr(mdoc, line, ppos, EARGVAL));
-
-	return(perr(mdoc, line, ppos, EARGMANY));
+	return(perr(mdoc, line, ppos, EARGVAL));
 }
 
 
 static int
 argv_opt_single(struct mdoc *mdoc, int line, 
-		struct mdoc_arg *v, int *pos, char *buf)
+		struct mdoc_argv *v, int *pos, char *buf)
 {
-	int		 c, ppos;
+	int		 c;
 	char		*p;
 
-	ppos = *pos;
-
 	if ('-' == buf[*pos])
 		return(1);
 
@@ -684,7 +780,7 @@ argv_opt_single(struct mdoc *mdoc, int line,
  */
 static int
 argv_single(struct mdoc *mdoc, int line, 
-		struct mdoc_arg *v, int *pos, char *buf)
+		struct mdoc_argv *v, int *pos, char *buf)
 {
 	int		 c, ppos;
 	char		*p;
@@ -711,7 +807,7 @@ argv_single(struct mdoc *mdoc, int line,
  */
 static int
 argv(struct mdoc *mdoc, int tok, int line, 
-		struct mdoc_arg *v, int *pos, char *buf)
+		struct mdoc_argv *v, int *pos, char *buf)
 {
 	int		 fl;
 
@@ -745,85 +841,3 @@ argv(struct mdoc *mdoc, int tok, int line,
 
 	return(1);
 }
-
-
-/*
- * Parse an argument from line text.  This comes in the form of -key
- * [value0...], which may either have a single mandatory value, at least
- * one mandatory value, an optional single value, or no value.
- */
-int
-mdoc_argv(struct mdoc *mdoc, int line, int tok,
-		struct mdoc_arg *v, int *pos, char *buf)
-{
-	int		 i;
-	char		*p;
-
-	(void)memset(v, 0, sizeof(struct mdoc_arg));
-
-	if (0 == buf[*pos])
-		return(ARGV_EOLN);
-
-	assert( ! isspace((u_char)buf[*pos]));
-
-	if ('-' != buf[*pos])
-		return(ARGV_WORD);
-
-	i = *pos;
-	p = &buf[++(*pos)];
-
-	v->line = line;
-	v->pos = *pos;
-
-	assert(*pos > 0);
-
-	/* LINTED */
-	while (buf[*pos]) {
-		if (isspace((u_char)buf[*pos])) 
-			if ('\\' != buf[*pos - 1])
-				break;
-		(*pos)++;
-	}
-
-	if (buf[*pos])
-		buf[(*pos)++] = 0;
-
-	/*
-	 * We now parse out the per-macro arguments.  XXX - this can be
-	 * made much cleaner using per-argument tables.  See argv_a2arg
-	 * for details.
-	 */
-
-	if (MDOC_ARG_MAX == (v->arg = argv_a2arg(tok, p))) {
-		if ( ! pwarn(mdoc, line, i, WARGVPARM))
-			return(ARGV_ERROR);
-		return(ARGV_WORD);
-	}
-
-	while (buf[*pos] && isspace((u_char)buf[*pos]))
-		(*pos)++;
-
-	/* FIXME: whitespace if no value. */
-
-	if ( ! argv(mdoc, tok, line, v, pos, buf))
-		return(ARGV_ERROR);
-
-	return(ARGV_ARG);
-}
-
-
-void
-mdoc_argv_free(int sz, struct mdoc_arg *arg)
-{
-	int		 i;
-
-	for (i = 0; i < sz; i++) {
-		if (0 == arg[i].sz) {
-			assert(NULL == arg[i].value);
-			continue;
-		}
-		assert(arg[i].value);
-		free(arg[i].value);
-	}
-}
-
diff --git a/hash.c b/hash.c
index 1e83cc91..b70f7cf7 100644
--- a/hash.c
+++ b/hash.c
@@ -128,6 +128,11 @@ mdoc_tokhash_find(const void *arg, const char *tmp)
 	assert(0 == (size_t)slot % sizeof(struct mdoc_macro));
 	slot /= sizeof(struct mdoc_macro);
 
+	/* 
+	 * FIXME: is this necessary, or do we only need to check the
+	 * remaining characters (2+)? 
+	 */
+
 	if (0 != strcmp(mdoc_macronames[slot], tmp))
 		return(MDOC_MAX);
 	return(slot);
diff --git a/macro.c b/macro.c
index a7048a23..7de4908b 100644
--- a/macro.c
+++ b/macro.c
@@ -31,11 +31,6 @@
  * macro. 
  */
 
-/* 
- * FIXME: don't use static mdoc_argv values, as they require us to do a
- * complicated copy-over when actually assigning them to dynamic memory.
- */
-
 #include "private.h"
 
 static int	  macro_obsolete(MACRO_PROT_ARGS);
@@ -71,7 +66,6 @@ static	int	  perr(struct mdoc *, int, int, int);
 
 #define	ENOCTX		(1)
 #define	ENOPARMS	(2)
-#define	EARGVLIM	(3)
 
 /* Central table of library: who gets parsed how. */
 
@@ -204,11 +198,6 @@ perr(struct mdoc *mdoc, int line, int pos, int type)
 		c = mdoc_perr(mdoc, line, pos, 
 				"macro doesn't expect parameters");
 		break;
-	case (EARGVLIM):
-		c = mdoc_perr(mdoc, line, pos, 
-				"argument hard-limit %d reached",
-				MDOC_LINEARG_MAX);
-		break;
 	default:
 		abort();
 		/* NOTREACHED */
@@ -243,7 +232,7 @@ lookup(struct mdoc *mdoc, int line, int pos, int from, const char *p)
 {
 	int		 res;
 
-	res = mdoc_find(mdoc, p);
+	res = mdoc_tokhash_find(mdoc->htab, p);
 	if (MDOC_PARSED & mdoc_macros[from].flags)
 		return(res);
 	if (MDOC_MAX == res)
@@ -731,16 +720,17 @@ macro_scoped_close(MACRO_PROT_ARGS)
 static int
 macro_text(MACRO_PROT_ARGS)
 {
-	int		  la, lastpunct, c, w, argc;
-	struct mdoc_arg	  argv[MDOC_LINEARG_MAX];
+	int		  la, lastpunct, c, w;
+	struct mdoc_arg	 *arg;
 	char		 *p;
 
 	la = ppos;
 	lastpunct = 0;
+	arg = NULL;
 
-	for (argc = 0; argc < MDOC_LINEARG_MAX; argc++) {
+	for (;;) {
 		la = *pos;
-		c = mdoc_argv(mdoc, line, tok, &argv[argc], pos, buf);
+		c = mdoc_argv(mdoc, line, tok, &arg, pos, buf);
 		if (ARGV_EOLN == c)
 			break;
 		if (ARGV_WORD == c) {
@@ -748,23 +738,12 @@ macro_text(MACRO_PROT_ARGS)
 			break;
 		} else if (ARGV_ARG == c)
 			continue;
-
-		mdoc_argv_free(argc, argv);
+		mdoc_argv_free(arg);
 		return(0);
 	}
 
-	if (MDOC_LINEARG_MAX == argc) {
-		mdoc_argv_free(argc - 1, argv);
-		return(perr(mdoc, line, ppos, EARGVLIM));
-	}
-
-	c = mdoc_elem_alloc(mdoc, line, ppos, 
-			tok, (size_t)argc, argv);
-
-	if (0 == c) {
-		mdoc_argv_free(argc, argv);
+	if ( ! mdoc_elem_alloc(mdoc, line, ppos, tok, arg))
 		return(0);
-	}
 
 	mdoc->next = MDOC_NEXT_CHILD;
 
@@ -774,11 +753,8 @@ macro_text(MACRO_PROT_ARGS)
 		w = mdoc_args(mdoc, line, pos, buf, tok, &p);
 		assert(ARGS_PHRASE != c);
 
-		if (ARGS_ERROR == w) {
-			mdoc_argv_free(argc, argv);
+		if (ARGS_ERROR == w)
 			return(0);
-		}
-
 		if (ARGS_EOLN == w)
 			break;
 		if (ARGS_PUNCT == w)
@@ -788,37 +764,29 @@ macro_text(MACRO_PROT_ARGS)
 			lookup(mdoc, line, la, tok, p);
 
 		if (MDOC_MAX != c && -1 != c) {
-			if (0 == lastpunct && ! rewind_elem(mdoc, tok)) {
-				mdoc_argv_free(argc, argv);
+			if (0 == lastpunct && ! rewind_elem(mdoc, tok))
 				return(0);
-			}
-			mdoc_argv_free(argc, argv);
 			c = mdoc_macro(mdoc, c, line, la, pos, buf);
 			if (0 == c)
 				return(0);
 			if (ppos > 1)
 				return(1);
 			return(append_delims(mdoc, line, pos, buf));
-		} else if (-1 == c) {
-			mdoc_argv_free(argc, argv);
+		} else if (-1 == c)
 			return(0);
-		}
 
 		/* FIXME: .Fl and .Ar handling of `|'. */
 
 		if (ARGS_QWORD != w && mdoc_isdelim(p)) {
-			if (0 == lastpunct && ! rewind_elem(mdoc, tok)) {
-				mdoc_argv_free(argc, argv);
+			if (0 == lastpunct && ! rewind_elem(mdoc, tok))
 				return(0);
-			}
 			lastpunct = 1;
 		} else if (lastpunct) {
-			c = mdoc_elem_alloc(mdoc, line, ppos, 
-					tok, (size_t)argc, argv);
-			if (0 == c) {
-				mdoc_argv_free(argc, argv);
+			c = mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
+
+			if (0 == c)
 				return(0);
-			}
+
 			mdoc->next = MDOC_NEXT_CHILD;
 			lastpunct = 0;
 		}
@@ -828,8 +796,6 @@ macro_text(MACRO_PROT_ARGS)
 		mdoc->next = MDOC_NEXT_SIBLING;
 	}
 
-	mdoc_argv_free(argc, argv);
-
 	if (0 == lastpunct && ! rewind_elem(mdoc, tok))
 		return(0);
 	if (ppos > 1)
@@ -865,8 +831,8 @@ macro_text(MACRO_PROT_ARGS)
 static int
 macro_scoped(MACRO_PROT_ARGS)
 {
-	int		  c, lastarg, argc;
-	struct mdoc_arg	  argv[MDOC_LINEARG_MAX];
+	int		  c, lastarg;
+	struct mdoc_arg	 *arg;
 	char		 *p;
 
 	assert ( ! (MDOC_CALLABLE & mdoc_macros[tok].flags));
@@ -881,10 +847,12 @@ macro_scoped(MACRO_PROT_ARGS)
 	}
 
 	/* Parse arguments. */
+	
+	arg = NULL;
 
-	for (argc = 0; argc < MDOC_LINEARG_MAX; argc++) {
+	for (;;) {
 		lastarg = *pos;
-		c = mdoc_argv(mdoc, line, tok, &argv[argc], pos, buf);
+		c = mdoc_argv(mdoc, line, tok, &arg, pos, buf);
 		if (ARGV_EOLN == c)
 			break;
 		if (ARGV_WORD == c) {
@@ -892,20 +860,11 @@ macro_scoped(MACRO_PROT_ARGS)
 			break;
 		} else if (ARGV_ARG == c)
 			continue;
-		mdoc_argv_free(argc, argv);
+		mdoc_argv_free(arg);
 		return(0);
 	}
 
-	if (MDOC_LINEARG_MAX == argc) {
-		mdoc_argv_free(argc - 1, argv);
-		return(perr(mdoc, line, ppos, EARGVLIM));
-	}
-
-	c = mdoc_block_alloc(mdoc, line, ppos, 
-			tok, (size_t)argc, argv);
-	mdoc_argv_free(argc, argv);
-
-	if (0 == c)
+	if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, arg))
 		return(0);
 
 	mdoc->next = MDOC_NEXT_CHILD;
@@ -998,7 +957,7 @@ macro_scoped_line(MACRO_PROT_ARGS)
 	int		  lastarg, c;
 	char		  *p;
 
-	if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, 0, NULL))
+	if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, NULL))
 		return(0);
 	mdoc->next = MDOC_NEXT_CHILD;
 
@@ -1082,7 +1041,7 @@ macro_constant_scoped(MACRO_PROT_ARGS)
 		break;
 	}
 
-	if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, 0, NULL))
+	if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, NULL))
 		return(0); 
 	mdoc->next = MDOC_NEXT_CHILD;
 
@@ -1185,14 +1144,13 @@ macro_constant_scoped(MACRO_PROT_ARGS)
 static int
 macro_constant_delimited(MACRO_PROT_ARGS)
 {
-	int		  lastarg, flushed, j, c, maxargs, argc,
+	int		  lastarg, flushed, j, c, maxargs, 
 			  igndelim, ignargs;
-	struct mdoc_arg	  argv[MDOC_LINEARG_MAX];
+	struct mdoc_arg	 *arg;
 	char		 *p;
 
 	lastarg = ppos;
 	flushed = 0;
-
 	
 	/* 
 	 * Maximum arguments per macro.  Some of these have none and
@@ -1241,13 +1199,12 @@ macro_constant_delimited(MACRO_PROT_ARGS)
 		break;
 	}
 
-	argc = 0;
+	arg = NULL;
 
 	if ( ! ignargs)
-		for ( ; argc < MDOC_LINEARG_MAX; argc++) {
+		for (;;) {
 			lastarg = *pos;
-			c = mdoc_argv(mdoc, line, tok, 
-					&argv[argc], pos, buf);
+			c = mdoc_argv(mdoc, line, tok, &arg, pos, buf);
 			if (ARGV_EOLN == c)
 				break;
 			if (ARGV_WORD == c) {
@@ -1255,21 +1212,11 @@ macro_constant_delimited(MACRO_PROT_ARGS)
 				break;
 			} else if (ARGV_ARG == c)
 				continue;
-			mdoc_argv_free(argc, argv);
+			mdoc_argv_free(arg);
 			return(0);
 		}
 
-	if (MDOC_LINEARG_MAX == argc) {
-		mdoc_argv_free(argc - 1, argv);
-		return(perr(mdoc, line, ppos, EARGVLIM));
-	}
-
-	c = mdoc_elem_alloc(mdoc, line, ppos, 
-			tok, (size_t)argc, argv);
-
-	mdoc_argv_free(argc, argv);
-
-	if (0 == c)
+	if ( ! mdoc_elem_alloc(mdoc, line, ppos, tok, arg))
 		return(0);
 
 	mdoc->next = MDOC_NEXT_CHILD;
@@ -1331,15 +1278,17 @@ macro_constant_delimited(MACRO_PROT_ARGS)
 static int
 macro_constant(MACRO_PROT_ARGS)
 {
-	int		  c, w, la, argc;
-	struct mdoc_arg	  argv[MDOC_LINEARG_MAX];
+	int		  c, w, la;
+	struct mdoc_arg	 *arg;
 	char		 *p;
 
 	assert( ! (MDOC_CALLABLE & mdoc_macros[tok].flags));
 
-	for (argc = 0; argc < MDOC_LINEARG_MAX; argc++) {
+	arg = NULL;
+
+	for (;;) {
 		la = *pos;
-		c = mdoc_argv(mdoc, line, tok, &argv[argc], pos, buf);
+		c = mdoc_argv(mdoc, line, tok, &arg, pos, buf);
 		if (ARGV_EOLN == c) 
 			break;
 		if (ARGV_WORD == c) {
@@ -1347,22 +1296,11 @@ macro_constant(MACRO_PROT_ARGS)
 			break;
 		} else if (ARGV_ARG == c)
 			continue;
-
-		mdoc_argv_free(argc, argv);
+		mdoc_argv_free(arg);
 		return(0);
 	}
 
-	if (MDOC_LINEARG_MAX == argc) {
-		mdoc_argv_free(argc - 1, argv);
-		return(perr(mdoc, line, ppos, EARGVLIM));
-	}
-
-	c = mdoc_elem_alloc(mdoc, line, ppos, 
-			tok, (size_t)argc, argv);
-
-	mdoc_argv_free(argc, argv);
-
-	if (0 == c)
+	if ( ! mdoc_elem_alloc(mdoc, line, ppos, tok, arg))
 		return(0);
 
 	mdoc->next = MDOC_NEXT_CHILD;
diff --git a/mdoc.c b/mdoc.c
index daafea62..f3f7f00f 100644
--- a/mdoc.c
+++ b/mdoc.c
@@ -32,16 +32,12 @@
  * in macro.c and validate.c.
  */
 
-static	struct mdoc_arg	 *argdup(size_t, const struct mdoc_arg *);
-static	void		  argfree(size_t, struct mdoc_arg *);
-static	void	  	  argcpy(struct mdoc_arg *, 
-				const struct mdoc_arg *);
-
 static	struct mdoc_node *mdoc_node_alloc(const struct mdoc *);
 static	int		  mdoc_node_append(struct mdoc *, 
 				struct mdoc_node *);
-static	void		  mdoc_elem_free(struct mdoc_elem *);
-static	void		  mdoc_text_free(struct mdoc_text *);
+
+static	int		  parsetext(struct mdoc *, int, char *);
+static	int		  parsemacro(struct mdoc *, int, char *);
 
 
 const	char *const __mdoc_macronames[MDOC_MAX] = {		 
@@ -173,76 +169,20 @@ mdoc_endparse(struct mdoc *mdoc)
 
 
 /*
- * Main line-parsing routine.  If the line is a macro-line (started with
- * a '.' control character), then pass along to the parser, which parses
- * subsequent macros until the end of line.  If normal text, simply
- * append the entire line to the chain.
+ * Main parse routine.  Parses a single line -- really just hands off to
+ * the macro or text parser.
  */
 int
-mdoc_parseln(struct mdoc *mdoc, int line, char *buf)
+mdoc_parseln(struct mdoc *m, int ln, char *buf)
 {
-	int		  c, i;
-	char		  tmp[5];
-
-	if (MDOC_HALT & mdoc->flags)
-		return(0);
-
-	mdoc->linetok = 0;
-
-	if ('.' != *buf) {
-		/*
-		 * Free-form text.  Not allowed in the prologue.
-		 */
-		if (SEC_PROLOGUE == mdoc->lastnamed)
-			return(mdoc_perr(mdoc, line, 0, 
-					"no text in prologue"));
 
-		if ( ! mdoc_word_alloc(mdoc, line, 0, buf))
-			return(0);
-		mdoc->next = MDOC_NEXT_SIBLING;
-		return(1);
-	}
-
-	/*
-	 * Control-character detected.  Begin the parsing sequence.
-	 */
-
-	if (buf[1] && '\\' == buf[1])
-		if (buf[2] && '\"' == buf[2])
-			return(1);
-
-	i = 1;
-	while (buf[i] && ! isspace((u_char)buf[i]) && 
-			i < (int)sizeof(tmp))
-		i++;
-
-	if (i == (int)sizeof(tmp)) {
-		mdoc->flags |= MDOC_HALT;
-		return(mdoc_perr(mdoc, line, 1, "unknown macro"));
-	} else if (i <= 2) {
-		mdoc->flags |= MDOC_HALT;
-		return(mdoc_perr(mdoc, line, 1, "unknown macro"));
-	}
-
-	i--;
-
-	(void)memcpy(tmp, buf + 1, (size_t)i);
-	tmp[i++] = 0;
-
-	if (MDOC_MAX == (c = mdoc_find(mdoc, tmp))) {
-		mdoc->flags |= MDOC_HALT;
-		return(mdoc_perr(mdoc, line, 1, "unknown macro"));
-	}
-
-	while (buf[i] && isspace((u_char)buf[i]))
-		i++;
+	/* If in error-mode, then we parse no more. */
 
-	if ( ! mdoc_macro(mdoc, c, line, 1, &i, buf)) {
-		mdoc->flags |= MDOC_HALT;
+	if (MDOC_HALT & m->flags)
 		return(0);
-	}
 
-	return(1);
+	return('.' == *buf ? parsemacro(m, ln, buf) :
+			parsetext(m, ln, buf));
 }
 
 
@@ -297,21 +237,26 @@ mdoc_vwarn(struct mdoc *mdoc, int ln, int pos,
 
 
 int
-mdoc_macro(struct mdoc *mdoc, int tok, 
-		int ln, int ppos, int *pos, char *buf)
+mdoc_macro(struct mdoc *m, int tok, 
+		int ln, int pp, int *pos, char *buf)
 {
 
-	assert(mdoc_macros[tok].fp);
+	/* FIXME - these should happen during validation. */
 
 	if (MDOC_PROLOGUE & mdoc_macros[tok].flags && 
-			SEC_PROLOGUE != mdoc->lastnamed)
-		return(mdoc_perr(mdoc, ln, ppos, "macro disallowed in document body"));
+			SEC_PROLOGUE != m->lastnamed)
+		return(mdoc_perr(m, ln, pp, 
+				"disallowed in document body"));
+
 	if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) && 
-			SEC_PROLOGUE == mdoc->lastnamed)
-		return(mdoc_perr(mdoc, ln, ppos, "macro disallowed in document prologue"));
-	if (1 != ppos && ! (MDOC_CALLABLE & mdoc_macros[tok].flags))
-		return(mdoc_perr(mdoc, ln, ppos, "macro not callable"));
-	return((*mdoc_macros[tok].fp)(mdoc, tok, ln, ppos, pos, buf));
+			SEC_PROLOGUE == m->lastnamed)
+		return(mdoc_perr(m, ln, pp, 
+				"disallowed in prologue"));
+
+	if (1 != pp && ! (MDOC_CALLABLE & mdoc_macros[tok].flags))
+		return(mdoc_perr(m, ln, pp, "not callable"));
+
+	return((*mdoc_macros[tok].fp)(m, tok, ln, pp, pos, buf));
 }
 
 
@@ -323,27 +268,6 @@ mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *p)
 	assert(mdoc->first);
 	assert(MDOC_ROOT != p->type);
 
-	/* See if we exceed the suggest line-max. */
-
-	switch (p->type) {
-	case (MDOC_TEXT):
-		/* FALLTHROUGH */
-	case (MDOC_ELEM):
-		/* FALLTHROUGH */
-	case (MDOC_BLOCK):
-		mdoc->linetok++;
-		break;
-	default:
-		break;
-	}
-
-	/* This sort-of works (re-opening of text macros...). */
-	if (mdoc->linetok > MDOC_LINEARG_SOFTMAX) 
-		if ( ! mdoc_nwarn(mdoc, p, WARN_COMPAT, 
-					"suggested %d tokens per line exceeded (has %d)",
-					MDOC_LINEARG_SOFTMAX, mdoc->linetok))
-			return(0);
-
 	switch (mdoc->next) {
 	case (MDOC_NEXT_SIBLING):
 		mdoc->last->next = p;
@@ -365,15 +289,15 @@ mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *p)
 	switch (p->type) {
 	case (MDOC_HEAD):
 		assert(MDOC_BLOCK == p->parent->type);
-		p->parent->data.block.head = p;
+		p->parent->head = p;
 		break;
 	case (MDOC_TAIL):
 		assert(MDOC_BLOCK == p->parent->type);
-		p->parent->data.block.tail = p;
+		p->parent->tail = p;
 		break;
 	case (MDOC_BODY):
 		assert(MDOC_BLOCK == p->parent->type);
-		p->parent->data.block.body = p;
+		p->parent->body = p;
 		break;
 	default:
 		break;
@@ -468,7 +392,7 @@ mdoc_root_alloc(struct mdoc *mdoc)
 
 int
 mdoc_block_alloc(struct mdoc *mdoc, int line, int pos, 
-		int tok, size_t argsz, const struct mdoc_arg *args)
+		int tok, struct mdoc_arg *args)
 {
 	struct mdoc_node *p;
 
@@ -478,8 +402,10 @@ mdoc_block_alloc(struct mdoc *mdoc, int line, int pos,
 	p->line = line;
 	p->type = MDOC_BLOCK;
 	p->tok = tok;
-	p->data.block.argc = argsz;
-	p->data.block.argv = argdup(argsz, args);
+	p->args = args;
+
+	if (args)
+		(args->refcnt)++;
 
 	return(mdoc_node_append(mdoc, p));
 }
@@ -487,7 +413,7 @@ mdoc_block_alloc(struct mdoc *mdoc, int line, int pos,
 
 int
 mdoc_elem_alloc(struct mdoc *mdoc, int line, int pos, 
-		int tok, size_t argsz, const struct mdoc_arg *args)
+		int tok, struct mdoc_arg *args)
 {
 	struct mdoc_node *p;
 
@@ -497,8 +423,10 @@ mdoc_elem_alloc(struct mdoc *mdoc, int line, int pos,
 	p->pos = pos;
 	p->type = MDOC_ELEM;
 	p->tok = tok;
-	p->data.elem.argc = argsz;
-	p->data.elem.argv = argdup(argsz, args);
+	p->args = args;
+
+	if (args)
+		(args->refcnt)++;
 
 	return(mdoc_node_append(mdoc, p));
 }
@@ -515,77 +443,20 @@ mdoc_word_alloc(struct mdoc *mdoc,
 	p->line = line;
 	p->pos = pos;
 	p->type = MDOC_TEXT;
-	p->data.text.string = xstrdup(word);
+	p->string = xstrdup(word);
 
 	return(mdoc_node_append(mdoc, p));
 }
 
 
-static void
-argfree(size_t sz, struct mdoc_arg *p)
-{
-	int		 i, j;
-
-	if (0 == sz)
-		return;
-
-	assert(p);
-	/* LINTED */
-	for (i = 0; i < (int)sz; i++)
-		if (p[i].sz > 0) {
-			assert(p[i].value);
-			/* LINTED */
-			for (j = 0; j < (int)p[i].sz; j++)
-				free(p[i].value[j]);
-			free(p[i].value);
-		}
-	free(p);
-}
-
-
-static void
-mdoc_elem_free(struct mdoc_elem *p)
-{
-
-	argfree(p->argc, p->argv);
-}
-
-
-static void
-mdoc_block_free(struct mdoc_block *p)
-{
-
-	argfree(p->argc, p->argv);
-}
-
-
-static void
-mdoc_text_free(struct mdoc_text *p)
-{
-
-	if (p->string)
-		free(p->string);
-}
-
-
 void
 mdoc_node_free(struct mdoc_node *p)
 {
 
-	switch (p->type) {
-	case (MDOC_TEXT):
-		mdoc_text_free(&p->data.text);
-		break;
-	case (MDOC_ELEM):
-		mdoc_elem_free(&p->data.elem);
-		break;
-	case (MDOC_BLOCK):
-		mdoc_block_free(&p->data.block);
-		break;
-	default:
-		break;
-	}
-
+	if (p->string)
+		free(p->string);
+	if (p->args)
+		mdoc_argv_free(p->args);
 	free(p);
 }
 
@@ -603,43 +474,78 @@ mdoc_node_freelist(struct mdoc_node *p)
 }
 
 
-int
-mdoc_find(const struct mdoc *mdoc, const char *key)
+/*
+ * Parse free-form text, that is, a line that does not begin with the
+ * control character.
+ */
+static int
+parsetext(struct mdoc *mdoc, int line, char *buf)
 {
 
-	return(mdoc_tokhash_find(mdoc->htab, key));
+	if (SEC_PROLOGUE == mdoc->lastnamed)
+		return(mdoc_perr(mdoc, line, 0,
+			"text disallowed in prologue"));
+
+	if ( ! mdoc_word_alloc(mdoc, line, 0, buf))
+		return(0);
+
+	mdoc->next = MDOC_NEXT_SIBLING;
+	return(1);
 }
 
 
-static void
-argcpy(struct mdoc_arg *dst, const struct mdoc_arg *src)
+/*
+ * Parse a macro line, that is, a line beginning with the control
+ * character.
+ */
+int
+parsemacro(struct mdoc *m, int ln, char *buf)
 {
-	int		 i;
+	int		  i, c;
+	char		  mac[5];
 
-	dst->line = src->line;
-	dst->pos = src->pos;
-	dst->arg = src->arg;
-	if (0 == (dst->sz = src->sz))
-		return;
-	dst->value = xcalloc(dst->sz, sizeof(char *));
-	for (i = 0; i < (int)dst->sz; i++)
-		dst->value[i] = xstrdup(src->value[i]);
-}
+	/* Comments are quickly ignored. */
+
+	if (buf[1] && '\\' == buf[1])
+		if (buf[2] && '\"' == buf[2])
+			return(1);
 
+	/* Copy the first word into a nil-terminated buffer. */
 
-static struct mdoc_arg *
-argdup(size_t argsz, const struct mdoc_arg *args)
-{
-	struct mdoc_arg	*pp;
-	int		 i;
+	for (i = 1; i < 5; i++) {
+		if (0 == (mac[i - 1] = buf[i]))
+			break;
+		else if (isspace((unsigned char)buf[i]))
+			break;
+	}
 
-	if (0 == argsz)
-		return(NULL);
+	mac[i - 1] = 0;
+
+	if (i == 5 || i <= 2) {
+		(void)mdoc_perr(m, ln, 1, "unknown macro: %s%s", 
+				mac, i == 5 ? "..." : "");
+		goto err;
+	} 
+	
+	if (MDOC_MAX == (c = mdoc_tokhash_find(m->htab, mac))) {
+		(void)mdoc_perr(m, ln, 1, "unknown macro: %s", mac);
+		goto err;
+	}
 
-	pp = xcalloc((size_t)argsz, sizeof(struct mdoc_arg));
-	for (i = 0; i < (int)argsz; i++)
-		argcpy(&pp[i], &args[i]);
+	/* The macro is sane.  Jump to the next word. */
 
-	return(pp);
-}
+	while (buf[i] && isspace((unsigned char)buf[i]))
+		i++;
 
+	/* Begin recursive parse sequence. */
+
+	if ( ! mdoc_macro(m, c, ln, 1, &i, buf)) 
+		goto err;
+
+	return(1);
+
+err:	/* Error out. */
+
+	m->flags |= MDOC_HALT;
+	return(0);
+}
diff --git a/mdoc.h b/mdoc.h
index d0df5b30..3dad0027 100644
--- a/mdoc.h
+++ b/mdoc.h
@@ -173,15 +173,6 @@ enum	mdoc_warn {
 	WARN_COMPAT
 };
 
-/* An argument to a macro (multiple values = `It -column'). */
-struct	mdoc_arg {
-	int	  	  arg;
-	int		  line;
-	int		  pos;
-	size_t		  sz;
-	char		**value;
-};
-
 /* Type of a syntax node. */
 enum	mdoc_type {
 	MDOC_TEXT,
@@ -229,31 +220,19 @@ struct	mdoc_meta {
 	char		 *name;
 };
 
-/* Text-only node. */
-struct	mdoc_text {
-	char		 *string;
-};
-
-/* Block (scoped) node. */
-struct	mdoc_block {
-	size_t		  argc;
-	struct mdoc_arg	 *argv;
-	struct mdoc_node *head;
-	struct mdoc_node *body;
-	struct mdoc_node *tail;
+/* An argument to a macro (multiple values = `It -column'). */
+struct	mdoc_argv {
+	int	  	  arg;
+	int		  line;
+	int		  pos;
+	size_t		  sz;
+	char		**value;
 };
 
-/* In-line element node. */
-struct	mdoc_elem {
+struct 	mdoc_arg {
 	size_t		  argc;
-	struct mdoc_arg	 *argv;
-};
-
-/* Typed nodes of an AST node. */
-union	mdoc_data {
-	struct mdoc_text  text;
-	struct mdoc_elem  elem;
-	struct mdoc_block block;
+	struct mdoc_argv *argv;
+	unsigned int	  refcnt;
 };
 
 /* Node in AST. */
@@ -269,10 +248,16 @@ struct	mdoc_node {
 #define	MDOC_VALID	 (1 << 0)
 #define	MDOC_ACTED	 (1 << 1)
 	enum mdoc_type	  type;
-	union mdoc_data	  data;
 	enum mdoc_sec	  sec;
+	struct mdoc_arg	 *args; 	/* BLOCK/ELEM */
+	struct mdoc_node *head;		/* BLOCK */
+	struct mdoc_node *body;		/* BLOCK */
+	struct mdoc_node *tail;		/* BLOCK */
+	char		 *string;	/* TEXT */
 };
 
+#define	MDOC_IGN_SCOPE	 (1 << 0)
+
 /* Call-backs for parse messages. */
 struct	mdoc_cb {
 	void	(*mdoc_msg)(void *, int, int, const char *);
@@ -297,6 +282,9 @@ void	 	  mdoc_free(struct mdoc *);
 /* Allocate a new parser instance. */
 struct	mdoc	 *mdoc_alloc(void *data, const struct mdoc_cb *);
 
+/* Set parse options. */
+void		  mdoc_setflags(struct mdoc *, int);
+
 /* Parse a single line in a stream (boolean retval). */
 int	 	  mdoc_parseln(struct mdoc *, int, char *buf);
 
diff --git a/mmain.c b/mmain.c
index f585992a..dc70c37d 100644
--- a/mmain.c
+++ b/mmain.c
@@ -44,11 +44,13 @@ struct	mmain {
 	u_long		  bufsz;	/* Input buffer size. */
 	char		 *in; 		/* Input file name. */
 	int		  fdin;		/* Input file desc. */
+	int		  pflags;	/* Parse flags. */
 };
 
 extern	char	 	 *__progname;
 
-static	int		  getsopts(struct mmain *, char *);
+static	int		  optswarn(struct mmain *, char *);
+static	int		  optsopt(struct mmain *, char *);
 static	int		  parse(struct mmain *);
 static	void		  msg_msg(void *, int, int, const char *);
 static	int		  msg_err(void *, int, int, const char *);
@@ -109,7 +111,7 @@ mmain_getopt(struct mmain *p, int argc, char *argv[],
 
 	extern int	 optind;
 
-	sz = strlcpy(opts, "VvW:", 32);
+	sz = strlcpy(opts, "VvW:f:", 32);
 	assert(sz < 32);
 
 	if (u) {
@@ -122,6 +124,10 @@ mmain_getopt(struct mmain *p, int argc, char *argv[],
 	/* LINTED */
 	while (-1 != (c = getopt(argc, argv, opts)))
 		switch (c) {
+		case ('f'):
+			if ( ! optsopt(p, optarg))
+				return(-1);
+			break;
 		case ('v'):
 			p->dbg++;
 			break;
@@ -129,7 +135,7 @@ mmain_getopt(struct mmain *p, int argc, char *argv[],
 			(void)printf("%s %s\n", __progname, VERSION);
 			return(0);
 		case ('W'):
-			if ( ! getsopts(p, optarg))
+			if ( ! optswarn(p, optarg))
 				return(-1);
 			break;
 		case ('?'):
@@ -208,7 +214,26 @@ mmain_mdoc(struct mmain *p)
 
 
 static int
-getsopts(struct mmain *p, char *arg)
+optsopt(struct mmain *p, char *arg)
+{
+	char		*v;
+	char		*toks[] = { "ignore-scope", NULL };
+
+	while (*arg) 
+		switch (getsubopt(&arg, toks, &v)) {
+		case (0):
+			p->pflags |= MDOC_IGN_SCOPE;
+			break;
+		default:
+			return(0);
+		}
+
+	return(1);
+}
+
+
+static int
+optswarn(struct mmain *p, char *arg)
 {
 	char		*v;
 	char		*toks[] = { "all", "compat", 
diff --git a/private.h b/private.h
index 728fbf4e..6a9cdf25 100644
--- a/private.h
+++ b/private.h
@@ -33,6 +33,7 @@ struct	mdoc {
 	int		  linetok;
 	int		  flags;
 #define	MDOC_HALT	 (1 << 0)
+	int		  pflags;
 	enum mdoc_next	  next;
 	struct mdoc_node *last;
 	struct mdoc_node *first;
@@ -42,14 +43,6 @@ struct	mdoc {
 };
 
 
-/* Hard-limit of macro arguments. */
-
-#define	MDOC_LINEARG_MAX 9
-
-/* Suggested limit of macro arguments. */
-
-#define	MDOC_LINEARG_SOFTMAX 9
-
 #define	MACRO_PROT_ARGS	struct mdoc *mdoc, int tok, int line, \
 			int ppos, int *pos, char *buf
 
@@ -106,13 +99,12 @@ int		  mdoc_verr(struct mdoc *, int, int,
 			const char *, ...);
 
 int		  mdoc_macro(MACRO_PROT_ARGS);
-int		  mdoc_find(const struct mdoc *, const char *);
 int		  mdoc_word_alloc(struct mdoc *, 
 			int, int, const char *);
 int		  mdoc_elem_alloc(struct mdoc *, int, int, 
-			int, size_t, const struct mdoc_arg *);
+			int, struct mdoc_arg *);
 int		  mdoc_block_alloc(struct mdoc *, int, int, 
-			int, size_t, const struct mdoc_arg *);
+			int, struct mdoc_arg *);
 int		  mdoc_root_alloc(struct mdoc *);
 int		  mdoc_head_alloc(struct mdoc *, int, int, int);
 int		  mdoc_tail_alloc(struct mdoc *, int, int, int);
@@ -141,13 +133,13 @@ int		  mdoc_valid_post(struct mdoc *);
 int		  mdoc_action_pre(struct mdoc *, struct mdoc_node *);
 int		  mdoc_action_post(struct mdoc *);
 
-int		  mdoc_argv(struct mdoc *, int, int, 
-			struct mdoc_arg *, int *, char *);
+int		  mdoc_argv(struct mdoc *, int, int,
+			struct mdoc_arg **, int *, char *);
 #define	ARGV_ERROR	(-1)
 #define	ARGV_EOLN	(0)
 #define	ARGV_ARG	(1)
 #define	ARGV_WORD	(2)
-void		  mdoc_argv_free(int, struct mdoc_arg *);
+void		  mdoc_argv_free(struct mdoc_arg *);
 int		  mdoc_args(struct mdoc *, int,
 			int *, char *, int, char **);
 #define	ARGS_ERROR	(-1)
diff --git a/validate.c b/validate.c
index ef0121bf..043c4219 100644
--- a/validate.c
+++ b/validate.c
@@ -24,6 +24,7 @@
 #include "private.h"
 
 /* FIXME: .Bl -diag can't have non-text children in HEAD. */
+/* TODO: ignoring Pp (it's superfluous in some invocations). */
 
 /*
  * Pre- and post-validate macros as they're parsed.  Pre-validation
@@ -36,11 +37,41 @@
 #define	PRE_ARGS	struct mdoc *mdoc, const struct mdoc_node *n
 #define	POST_ARGS	struct mdoc *mdoc
 
+enum	merr {
+	ENODATA,
+	ENOPROLOGUE,
+	ELINE,
+	EATT,
+	ENAME,
+	ELISTTYPE,
+	EDISPTYPE,
+	EMULTIDISP,
+	EMULTILIST,
+	EARGREP,
+	EBOOL,
+	ENESTDISP
+};
+
+enum	mwarn {
+	WWRONGMSEC,
+	WSECOOO,
+	WSECREP,
+	WBADSTAND,
+	WNAMESECINC,
+	WNOMULTILINE,
+	WMULTILINE,
+	WLINE,
+	WNOLINE,
+	WPROLOOO,
+	WPROLREP,
+	WARGVAL,
+	WBADSEC,
+	WBADMSEC
+};
+
 typedef	int	(*v_pre)(PRE_ARGS);
 typedef	int	(*v_post)(POST_ARGS);
 
-/* TODO: ignoring Pp (it's superfluous in some invocations). */
-
 struct	valids {
 	v_pre	*pre;
 	v_post	*post;
@@ -48,34 +79,32 @@ struct	valids {
 
 /* Utility checks. */
 
+static	int	nwarn(struct mdoc *, 
+			const struct mdoc_node *, enum mwarn);
+static	int	nerr(struct mdoc *, 
+			const struct mdoc_node *, enum merr);
 static	int	check_parent(PRE_ARGS, int, enum mdoc_type);
 static	int	check_msec(PRE_ARGS, ...);
 static	int	check_sec(PRE_ARGS, ...);
 static	int	check_stdarg(PRE_ARGS);
-
 static	int	check_text(struct mdoc *, 
 			int, int, const char *);
 static	int	check_argv(struct mdoc *, 
 			const struct mdoc_node *,
-			const struct mdoc_arg *);
-
+			const struct mdoc_argv *);
+static	int	check_args(struct mdoc *, 
+			const struct mdoc_node *);
 static	int	err_child_lt(struct mdoc *, const char *, int);
 static	int	warn_child_lt(struct mdoc *, const char *, int);
 static	int	err_child_gt(struct mdoc *, const char *, int);
 static	int	warn_child_gt(struct mdoc *, const char *, int);
 static	int	err_child_eq(struct mdoc *, const char *, int);
 static	int	warn_child_eq(struct mdoc *, const char *, int);
-
-/* Utility auxiliaries. */
-
 static	inline int count_child(struct mdoc *);
 static	inline int warn_count(struct mdoc *, const char *, 
 			int, const char *, int);
 static	inline int err_count(struct mdoc *, const char *, 
 			int, const char *, int);
-
-/* Specific pre-child-parse routines. */
-
 static	int	pre_an(PRE_ARGS);
 static	int	pre_bd(PRE_ARGS);
 static	int	pre_bl(PRE_ARGS);
@@ -93,14 +122,10 @@ static	int	pre_prologue(PRE_ARGS);
 static	int	pre_rv(PRE_ARGS);
 static	int	pre_sh(PRE_ARGS);
 static	int	pre_ss(PRE_ARGS);
-
-/* Specific post-child-parse routines. */
-
 static	int	herr_ge1(POST_ARGS);
 static	int	hwarn_le1(POST_ARGS);
 static	int	herr_eq0(POST_ARGS);
 static	int	eerr_eq0(POST_ARGS);
-static	int	eerr_le1(POST_ARGS);
 static	int	eerr_le2(POST_ARGS);
 static	int	eerr_eq1(POST_ARGS);
 static	int	eerr_ge1(POST_ARGS);
@@ -110,7 +135,6 @@ static	int	bwarn_ge1(POST_ARGS);
 static	int	hwarn_eq1(POST_ARGS);
 static	int	ewarn_ge1(POST_ARGS);
 static	int	ebool(POST_ARGS);
-
 static	int	post_an(POST_ARGS);
 static	int	post_at(POST_ARGS);
 static	int	post_bf(POST_ARGS);
@@ -124,8 +148,6 @@ static	int	post_sh_body(POST_ARGS);
 static	int	post_sh_head(POST_ARGS);
 static	int	post_st(POST_ARGS);
 
-/* Collections of pre-child-parse routines. */
-
 static	v_pre	pres_an[] = { pre_an, NULL };
 static	v_pre	pres_bd[] = { pre_display, pre_bd, NULL };
 static	v_pre	pres_bl[] = { pre_bl, NULL };
@@ -142,9 +164,6 @@ static	v_pre	pres_os[] = { pre_prologue, pre_os, NULL };
 static	v_pre	pres_rv[] = { pre_rv, NULL };
 static	v_pre	pres_sh[] = { pre_sh, NULL };
 static	v_pre	pres_ss[] = { pre_ss, NULL };
-
-/* Collections of post-child-parse routines. */
-
 static	v_post	posts_bool[] = { eerr_eq1, ebool, NULL };
 static	v_post	posts_bd[] = { herr_eq0, bwarn_ge1, NULL };
 static	v_post	posts_text[] = { eerr_ge1, NULL };
@@ -160,7 +179,7 @@ static	v_post	posts_pf[] = { eerr_eq1, NULL };
 static	v_post	posts_lb[] = { eerr_eq1, NULL };
 static	v_post	posts_st[] = { eerr_eq1, post_st, NULL };
 static	v_post	posts_pp[] = { ewarn_eq0, NULL };
-static	v_post	posts_ex[] = { eerr_le1, post_ex, NULL };
+static	v_post	posts_ex[] = { eerr_eq0, post_ex, NULL };
 static	v_post	posts_an[] = { post_an, NULL };
 static	v_post	posts_at[] = { post_at, NULL };
 static	v_post	posts_xr[] = { eerr_ge1, eerr_le2, NULL };
@@ -171,8 +190,6 @@ static	v_post	posts_fo[] = { hwarn_eq1, bwarn_ge1, NULL };
 static	v_post	posts_bk[] = { herr_eq0, bwarn_ge1, NULL };
 static	v_post	posts_fd[] = { ewarn_ge1, NULL };
 
-/* Per-macro pre- and post-child-check routine collections. */
-
 const	struct valids mdoc_valids[MDOC_MAX] = {
 	{ NULL, NULL }, 			/* \" */
 	{ pres_dd, posts_text },		/* Dd */
@@ -289,39 +306,18 @@ mdoc_valid_pre(struct mdoc *mdoc,
 		const struct mdoc_node *node)
 {
 	v_pre		*p;
-	struct mdoc_arg	*argv;
-	size_t		 argc;
-	int		 line, pos, i, j;
+	int		 line, pos;
 	const char	*tp;
 
 	if (MDOC_TEXT == node->type) {
-		tp = node->data.text.string;
+		tp = node->string;
 		line = node->line;
 		pos = node->pos;
 		return(check_text(mdoc, line, pos, tp));
 	}
 
-	if (MDOC_BLOCK == node->type || MDOC_ELEM == node->type) {
-		argv = MDOC_BLOCK == node->type ?
-			node->data.block.argv :
-			node->data.elem.argv;
-		argc = MDOC_BLOCK == node->type ?
-			node->data.block.argc :
-			node->data.elem.argc;
-
-		for (i = 0; i < (int)argc; i++) {
-			for (j = 0; j < (int)argv[i].sz; j++) {
-				tp = argv[i].value[j];
-				line = argv[i].line;
-				pos = argv[i].pos;
-				if ( ! check_text(mdoc, line, pos, tp))
-					return(0);
-			}
-			if ( ! check_argv(mdoc, node, &argv[i]))
-				return(0);
-		}
-	}
-
+	if ( ! check_args(mdoc, node))
+		return(0);
 	if (NULL == mdoc_valids[node->tok].pre)
 		return(1);
 	for (p = mdoc_valids[node->tok].pre; *p; p++)
@@ -363,6 +359,123 @@ mdoc_valid_post(struct mdoc *mdoc)
 }
 
 
+#define	merr(m, t) nerr((m), (m)->last, (t))
+static int
+nerr(struct mdoc *m, const struct mdoc_node *n, enum merr type)
+{
+	char		 *p;
+	
+	p = NULL;
+
+	switch (type) {
+	case (ENESTDISP):
+		p = "displays may not be nested";
+		break;
+	case (EBOOL):
+		p = "expected boolean value";
+		break;
+	case (EARGREP):
+		p = "argument repeated";
+		break;
+	case (EMULTIDISP):
+		p = "multiple display types specified";
+		break;
+	case (EMULTILIST):
+		p = "multiple list types specified";
+		break;
+	case (ELISTTYPE):
+		p = "missing list type";
+		break;
+	case (EDISPTYPE):
+		p = "missing display type";
+		break;
+	case (ELINE):
+		p = "expected line arguments";
+		break;
+	case (ENOPROLOGUE):
+		p = "document has no prologue";
+		break;
+	case (ENODATA):
+		p = "document has no data";
+		break;
+	case (EATT):
+		p = "expected valid AT&T symbol";
+		break;
+	case (ENAME):
+		p = "default name not yet set";
+		break;
+	}
+
+	assert(p);
+	return(mdoc_nerr(m, n, p));
+}
+
+
+#define	mwarn(m, t) nwarn((m), (m)->last, (t))
+static int
+nwarn(struct mdoc *m, const struct mdoc_node *n, enum mwarn type)
+{
+	char		 *p;
+	enum mdoc_warn	  c;
+
+	c = WARN_SYNTAX;
+	p = NULL;
+
+	switch (type) {
+	case (WBADMSEC):
+		p = "inappropriate manual section";
+		c = WARN_COMPAT;
+		break;
+	case (WBADSEC):
+		p = "inappropriate document section";
+		c = WARN_COMPAT;
+		break;
+	case (WARGVAL):
+		p = "argument value suggested";
+		c = WARN_COMPAT;
+		break;
+	case (WPROLREP):
+		p = "prologue macros repeated";
+		c = WARN_COMPAT;
+		break;
+	case (WPROLOOO):
+		p = "prologue macros out-of-order";
+		c = WARN_COMPAT;
+		break;
+	case (WNOLINE):
+		p = "suggested no line arguments";
+		break;
+	case (WLINE):
+		p = "suggested line arguments";
+		break;
+	case (WMULTILINE):
+		p = "suggested multi-line arguments";
+		break;
+	case (WNOMULTILINE):
+		p = "suggested no multi-line arguments";
+		break;
+	case (WWRONGMSEC):
+		p = "document section in wrong manual section";
+		c = WARN_COMPAT;
+		break;
+	case (WSECOOO):
+		p = "document section out of conventional order";
+		break;
+	case (WSECREP):
+		p = "document section repeated";
+		break;
+	case (WBADSTAND):
+		p = "unknown standard";
+		break;
+	case (WNAMESECINC):
+		p = "NAME section contents incomplete/badly-ordered";
+		break;
+	}
+	assert(p);
+	return(mdoc_nwarn(m, n, c, p));
+}
+
+
 
 static inline int
 warn_count(struct mdoc *m, const char *k, 
@@ -370,8 +483,7 @@ warn_count(struct mdoc *m, const char *k,
 {
 
 	return(mdoc_warn(m, WARN_SYNTAX, 
-				"suggests %s %s %d (has %d)", 
-				v, k, want, has));
+		"suggests %s %s %d (has %d)", v, k, want, has));
 }
 
 
@@ -380,8 +492,8 @@ err_count(struct mdoc *m, const char *k,
 		int want, const char *v, int has)
 {
 
-	return(mdoc_err(m, "requires %s %s %d (has %d)",
-				v, k, want, has));
+	return(mdoc_err(m, 
+		"requires %s %s %d (has %d)", v, k, want, has));
 }
 
 
@@ -420,7 +532,7 @@ b##lvl##_##name(POST_ARGS) 					\
 { 								\
 	if (MDOC_BODY != mdoc->last->type) 			\
 		return(1); 					\
-	return(func(mdoc, "multiline parameters", (num))); 	\
+	return(func(mdoc, "multi-line arguments", (num))); 	\
 }
 
 #define CHECK_ELEM_DEFN(name, lvl, func, num) 			\
@@ -428,7 +540,7 @@ static int							\
 e##lvl##_##name(POST_ARGS) 					\
 { 								\
 	assert(MDOC_ELEM == mdoc->last->type); 			\
-	return(func(mdoc, "line parameters", (num))); 		\
+	return(func(mdoc, "line arguments", (num))); 		\
 }
 
 #define CHECK_HEAD_DEFN(name, lvl, func, num)			\
@@ -437,7 +549,7 @@ h##lvl##_##name(POST_ARGS) 					\
 { 								\
 	if (MDOC_HEAD != mdoc->last->type) 			\
 		return(1); 					\
-	return(func(mdoc, "line parameters", (num)));	 	\
+	return(func(mdoc, "line arguments", (num)));	 	\
 }
 
 
@@ -453,7 +565,6 @@ CHECK_ELEM_DEFN(eq0, warn, warn_child_eq, 0)	/* ewarn_eq0() */
 CHECK_ELEM_DEFN(ge1, warn, warn_child_gt, 0)	/* ewarn_gt1() */
 CHECK_ELEM_DEFN(eq1, err, err_child_eq, 1)	/* eerr_eq1() */
 CHECK_ELEM_DEFN(le2, err, err_child_lt, 3)	/* eerr_le2() */
-CHECK_ELEM_DEFN(le1, err, err_child_lt, 2)	/* eerr_le1() */
 CHECK_ELEM_DEFN(eq0, err, err_child_eq, 0)	/* eerr_eq0() */
 CHECK_ELEM_DEFN(ge1, err, err_child_gt, 0)	/* eerr_ge1() */
 CHECK_HEAD_DEFN(eq0, err, err_child_eq, 0)	/* herr_eq0() */
@@ -466,12 +577,10 @@ static int
 check_stdarg(PRE_ARGS)
 {
 
-	if (MDOC_Std == n->data.elem.argv[0].arg && 
-			1 == n->data.elem.argc)
-		return(1);
-
-	return(mdoc_nwarn(mdoc, n, WARN_COMPAT, 
-				"one argument suggested"));
+	if (n->args && 1 == n->args->argc)
+		if (MDOC_Std == n->args->argv[0].arg)
+			return(1);
+	return(nwarn(mdoc, n, WARGVAL));
 }
 
 
@@ -484,6 +593,7 @@ check_sec(PRE_ARGS, ...)
 	va_start(ap, n);
 
 	for (;;) {
+		/* LINTED */
 		sec = (enum mdoc_sec)va_arg(ap, int);
 		if (SEC_CUSTOM == sec)
 			break;
@@ -494,8 +604,7 @@ check_sec(PRE_ARGS, ...)
 	}
 
 	va_end(ap);
-	return(mdoc_nwarn(mdoc, n, WARN_COMPAT, 
-		"inappropriate document section for macro"));
+	return(nwarn(mdoc, n, WBADSEC));
 }
 
 
@@ -507,6 +616,7 @@ check_msec(PRE_ARGS, ...)
 
 	va_start(ap, n);
 	for (;;) {
+		/* LINTED */
 		if (0 == (msec = va_arg(ap, int)))
 			break;
 		if (msec != mdoc->meta.msec)
@@ -516,44 +626,41 @@ check_msec(PRE_ARGS, ...)
 	}
 
 	va_end(ap);
-	return(mdoc_nwarn(mdoc, n, WARN_COMPAT, 
-		"inappropriate manual section for macro"));
+	return(nwarn(mdoc, n, WBADMSEC));
 }
 
 
-/*
- * Check over an argument.  When this has more stuff in it, make this
- * into a table-driven function; until then, a switch is fine.
- */
 static int
-check_argv(struct mdoc *mdoc, 
-		const struct mdoc_node *node,
-		const struct mdoc_arg *argv)
+check_args(struct mdoc *m, const struct mdoc_node *n)
 {
+	int		 i;
 
+	if (NULL == n->args)
+		return(1);
 
-	switch (argv->arg) {
-	case (MDOC_Std):
-		switch (node->tok) {
-		case (MDOC_Ex):
-			/*
-			 * If the -std does not have an argument, then
-			 * set it with the default name (if set).  This
-			 * only happens with MDOC_Ex.
-			 */
-			if (1 == argv->sz)
-				return(1);
-			assert(0 == argv->sz);
-			if (mdoc->meta.name)
-				return(1);
-			return(mdoc_nerr(mdoc, node, 
-					"default name not yet set"));
-		default:
-			break;
-		}
-		break;
-	default:
-		break;
+	for (i = 0; i < (int)n->args->argc; i++)
+		if ( ! check_argv(m, n, &n->args->argv[i]))
+			return(0);
+
+	return(1);
+}
+
+
+static int
+check_argv(struct mdoc *m, const struct mdoc_node *n, 
+		const struct mdoc_argv *v)
+{
+	int		 i;
+
+	for (i = 0; i < (int)v->sz; i++)
+		if ( ! check_text(m, v->line, v->pos, v->value[i]))
+			return(0);
+
+	if (MDOC_Std == v->arg && MDOC_Ex == n->tok) {
+		/* `Nm' name must be set. */
+		if (v->sz || m->meta.name)
+			return(1);
+		return(nerr(m, n, ENAME));
 	}
 
 	return(1);
@@ -570,7 +677,7 @@ check_text(struct mdoc *mdoc, int line, int pos, const char *p)
 	for ( ; *p; p++) {
 		if ( ! isprint((u_char)*p) && '\t' != *p)
 			return(mdoc_perr(mdoc, line, pos,
-				"invalid non-printing characters"));
+				"invalid non-printing character"));
 		if ('\\' != *p)
 			continue;
 		if ((c = mdoc_isescape(p))) {
@@ -620,31 +727,27 @@ pre_display(PRE_ARGS)
 	if (NULL == node)
 		return(1);
 
-	return(mdoc_nerr(mdoc, n, "displays may not be nested"));
+	return(nerr(mdoc, n, ENESTDISP));
 }
 
 
 static int
 pre_bl(PRE_ARGS)
 {
-	int		 type, i, width, offset;
-	struct mdoc_arg	*argv;
-	size_t		 argc;
+	int		 i, type, width, offset;
 
 	if (MDOC_BLOCK != n->type)
 		return(1);
-
-	argc = n->data.block.argc; 
+	if (NULL == n->args)
+		return(nerr(mdoc, n, ELISTTYPE));
 
 	/* Make sure that only one type of list is specified.  */
 
 	type = offset = width = -1;
 
 	/* LINTED */
-	for (i = 0; i < (int)argc; i++) {
-		argv = &n->data.block.argv[i];
-
-		switch (argv->arg) {
+	for (i = 0; i < (int)n->args->argc; i++)
+		switch (n->args->argv[i].arg) {
 		case (MDOC_Bullet):
 			/* FALLTHROUGH */
 		case (MDOC_Dash):
@@ -667,34 +770,28 @@ pre_bl(PRE_ARGS)
 			/* FALLTHROUGH */
 		case (MDOC_Column):
 			if (-1 == type) {
-				type = argv->arg;
+				type = n->args->argv[i].arg;
 				break;
 			}
-			return(mdoc_perr(mdoc, argv->line, argv->pos, 
-					"multiple types specified"));
+			return(nerr(mdoc, n, EMULTILIST));
 		case (MDOC_Width):
 			if (-1 == width) {
-				width = argv->arg;
+				width = n->args->argv[i].arg;
 				break;
 			}
-			return(mdoc_perr(mdoc, argv->line, argv->pos, 
-					"multiple -%s arguments",
-					mdoc_argnames[MDOC_Width]));
+			return(nerr(mdoc, n, EARGREP));
 		case (MDOC_Offset):
 			if (-1 == offset) {
-				offset = argv->arg;
+				offset = n->args->argv[i].arg;
 				break;
 			}
-			return(mdoc_perr(mdoc, argv->line, argv->pos, 
-					"multiple -%s arguments",
-					mdoc_argnames[MDOC_Offset]));
+			return(nerr(mdoc, n, EARGREP));
 		default:
 			break;
 		}
-	}
 
 	if (-1 == type)
-		return(mdoc_err(mdoc, "no type specified"));
+		return(nerr(mdoc, n, ELISTTYPE));
 
 	switch (type) {
 	case (MDOC_Column):
@@ -707,14 +804,13 @@ pre_bl(PRE_ARGS)
 		if (-1 == width)
 			break;
 		return(mdoc_nwarn(mdoc, n, WARN_SYNTAX,
-				"superfluous -%s argument",
+				"superfluous %s argument",
 				mdoc_argnames[MDOC_Width]));
 	case (MDOC_Tag):
-		if (-1 == width && ! mdoc_nwarn(mdoc, n, WARN_SYNTAX, 
-					"suggest -%s argument",
-					mdoc_argnames[MDOC_Width]))
-			return(0);
-		break;
+		if (-1 != width)
+			break;
+		return(mdoc_nerr(mdoc, n, "missing %s argument",
+				mdoc_argnames[MDOC_Width]));
 	default:
 		break;
 	}
@@ -726,22 +822,19 @@ pre_bl(PRE_ARGS)
 static int
 pre_bd(PRE_ARGS)
 {
-	int		 type, err, i;
-	struct mdoc_arg	*argv;
-	size_t		 argc;
+	int		 i, type, err;
 
 	if (MDOC_BLOCK != n->type)
 		return(1);
-
-	argc = n->data.block.argc;
+	if (NULL == n->args) 
+		return(nerr(mdoc, n, EDISPTYPE));
 
 	/* Make sure that only one type of display is specified.  */
 
 	/* LINTED */
-	for (i = 0, err = type = 0; ! err && i < (int)argc; i++) {
-		argv = &n->data.block.argv[i];
-
-		switch (argv->arg) {
+	for (i = 0, err = type = 0; ! err && 
+			i < (int)n->args->argc; i++)
+		switch (n->args->argv[i].arg) {
 		case (MDOC_Ragged):
 			/* FALLTHROUGH */
 		case (MDOC_Unfilled):
@@ -753,16 +846,14 @@ pre_bd(PRE_ARGS)
 		case (MDOC_File):
 			if (0 == type++) 
 				break;
-			return(mdoc_perr(mdoc, argv->line, argv->pos, 
-					"multiple types specified"));
+			return(nerr(mdoc, n, EMULTIDISP));
 		default:
 			break;
 		}
-	}
 
 	if (type)
 		return(1);
-	return(mdoc_err(mdoc, "no type specified"));
+	return(nerr(mdoc, n, EDISPTYPE));
 }
 
 
@@ -800,9 +891,9 @@ static int
 pre_an(PRE_ARGS)
 {
 
-	if (1 >= n->data.elem.argc)
+	if (n->args && 1 >= n->args->argc)
 		return(1);
-	return(mdoc_nerr(mdoc, n, "one argument allowed"));
+	return(mdoc_nerr(mdoc, n, "only one argument allowed"));
 }
 
 
@@ -863,12 +954,10 @@ pre_dt(PRE_ARGS)
 {
 
 	if (0 == mdoc->meta.date || mdoc->meta.os)
-		if ( ! mdoc_nwarn(mdoc, n, WARN_COMPAT, 
-					"out-of-order prologue"))
+		if ( ! nwarn(mdoc, n, WPROLOOO))
 			return(0);
 	if (mdoc->meta.title)
-		if ( ! mdoc_nwarn(mdoc, n, WARN_COMPAT, 
-					"prologue re-invoked"))
+		if ( ! nwarn(mdoc, n, WPROLREP))
 			return(0);
 	return(1);
 }
@@ -879,12 +968,10 @@ pre_os(PRE_ARGS)
 {
 
 	if (NULL == mdoc->meta.title || 0 == mdoc->meta.date)
-		if ( ! mdoc_nwarn(mdoc, n, WARN_COMPAT, 
-					"out-of-order prologue"))
+		if ( ! nwarn(mdoc, n, WPROLOOO))
 			return(0);
 	if (mdoc->meta.os)
-		if ( ! mdoc_nwarn(mdoc, n, WARN_COMPAT, 
-					"prologue re-invoked"))
+		if ( ! nwarn(mdoc, n, WPROLREP))
 			return(0);
 	return(1);
 }
@@ -895,12 +982,10 @@ pre_dd(PRE_ARGS)
 {
 
 	if (mdoc->meta.title || mdoc->meta.os)
-		if ( ! mdoc_nwarn(mdoc, n, WARN_COMPAT,
-					"out-of-order prologue"))
+		if ( ! nwarn(mdoc, n, WPROLOOO))
 			return(0);
 	if (mdoc->meta.date)
-		if ( ! mdoc_nwarn(mdoc, n, WARN_COMPAT,
-					"prologue re-invoked"))
+		if ( ! nwarn(mdoc, n, WPROLREP))
 			return(0);
 	return(1);
 }
@@ -915,13 +1000,14 @@ post_bf(POST_ARGS)
 	if (MDOC_BLOCK != mdoc->last->type)
 		return(1);
 
-	head = mdoc->last->data.block.head;
+	head = mdoc->last->head;
 
-	if (0 == mdoc->last->data.block.argc) {
-		if (NULL == head->child)
-			return(mdoc_err(mdoc, "argument expected"));
+	if (NULL == mdoc->last->args) {
+		if (NULL == head->child || 
+				MDOC_TEXT != head->child->type)
+			return(mdoc_err(mdoc, "text argument expected"));
 
-		p = head->child->data.text.string;
+		p = head->child->string;
 		if (xstrcmp(p, "Em"))
 			return(1);
 		else if (xstrcmp(p, "Li"))
@@ -932,11 +1018,9 @@ post_bf(POST_ARGS)
 	}
 
 	if (head->child)
-		return(mdoc_err(mdoc, "argument expected"));
+		return(mdoc_err(mdoc, "one argument expected"));
 
-	if (1 == mdoc->last->data.block.argc)
-		return(1);
-	return(mdoc_err(mdoc, "argument expected"));
+	return(1);
 }
 
 
@@ -948,7 +1032,7 @@ post_nm(POST_ARGS)
 		return(1);
 	if (mdoc->meta.name)
 		return(1);
-	return(mdoc_err(mdoc, "not yet invoked with name"));
+	return(merr(mdoc, ENAME));
 }
 
 
@@ -958,9 +1042,11 @@ post_at(POST_ARGS)
 
 	if (NULL == mdoc->last->child)
 		return(1);
-	if (mdoc_a2att(mdoc->last->child->data.text.string))
+	if (MDOC_TEXT != mdoc->last->child->type)
+		return(merr(mdoc, EATT));
+	if (mdoc_a2att(mdoc->last->child->string))
 		return(1);
-	return(mdoc_err(mdoc, "require valid AT&T symbol"));
+	return(merr(mdoc, EATT));
 }
 
 
@@ -968,15 +1054,15 @@ static int
 post_an(POST_ARGS)
 {
 
-	if (0 != mdoc->last->data.elem.argc) {
+	if (mdoc->last->args) {
 		if (NULL == mdoc->last->child)
 			return(1);
-		return(mdoc_err(mdoc, "argument(s) expected"));
+		return(merr(mdoc, ELINE));
 	}
 
 	if (mdoc->last->child)
 		return(1);
-	return(mdoc_err(mdoc, "argument(s) expected"));
+	return(merr(mdoc, ELINE));
 }
 
 
@@ -984,47 +1070,31 @@ static int
 post_ex(POST_ARGS)
 {
 
-	if (0 == mdoc->last->data.elem.argc) {
-		if (mdoc->last->child)
-			return(1);
-		return(mdoc_err(mdoc, "argument(s) expected"));
-	}
-	if (mdoc->last->child)
-		return(mdoc_err(mdoc, "argument(s) expected"));
-	if (1 != mdoc->last->data.elem.argc)
-		return(mdoc_err(mdoc, "argument(s) expected"));
-	if (MDOC_Std != mdoc->last->data.elem.argv[0].arg)
-		return(mdoc_err(mdoc, "argument(s) expected"));
-
-	return(1);
+	if (mdoc->last->args)
+		return(1);
+	return(merr(mdoc, ELINE));
 }
 
 
 static int
 post_it(POST_ARGS)
 {
-	int		  type, sv, i;
-#define	TYPE_NONE	 (0)
-#define	TYPE_BODY	 (1)
-#define	TYPE_HEAD	 (2)
-#define	TYPE_OHEAD	 (3)
-	size_t		  argc;
-	struct mdoc_node *n;
+	int		  type, i, cols;
+	struct mdoc_node *n, *c;
 
 	if (MDOC_BLOCK != mdoc->last->type)
 		return(1);
 
 	n = mdoc->last->parent->parent;
+	if (NULL == n->args)
+		return(merr(mdoc, ELISTTYPE));
 
-	argc = n->data.block.argc;
-	type = TYPE_NONE;
-	sv = -1;
-	
 	/* Some types require block-head, some not. */
 
 	/* LINTED */
-	for (i = 0; TYPE_NONE == type && i < (int)argc; i++)
-		switch (n->data.block.argv[i].arg) {
+	for (cols = type = -1, i = 0; -1 == type && 
+			i < (int)n->args->argc; i++)
+		switch (n->args->argv[i].arg) {
 		case (MDOC_Tag):
 			/* FALLTHROUGH */
 		case (MDOC_Diag):
@@ -1034,9 +1104,7 @@ post_it(POST_ARGS)
 		case (MDOC_Ohang):
 			/* FALLTHROUGH */
 		case (MDOC_Inset):
-			type = TYPE_HEAD;
-			sv = n->data.block.argv[i].arg;
-			break;
+			/* FALLTHROUGH */
 		case (MDOC_Bullet):
 			/* FALLTHROUGH */
 		case (MDOC_Dash):
@@ -1046,74 +1114,76 @@ post_it(POST_ARGS)
 		case (MDOC_Hyphen):
 			/* FALLTHROUGH */
 		case (MDOC_Item):
-			type = TYPE_BODY;
-			sv = n->data.block.argv[i].arg;
+			type = n->args->argv[i].arg;
 			break;
 		case (MDOC_Column):
-			type = TYPE_OHEAD;
-			sv = n->data.block.argv[i].arg;
+			type = n->args->argv[i].arg;
+			cols = (int)n->args->argv[i].sz;
 			break;
 		default:
 			break;
 		}
 
-	assert(TYPE_NONE != type);
-
-	n = mdoc->last->data.block.head;
+	if (-1 == type)
+		return(merr(mdoc, ELISTTYPE));
 
-	if (TYPE_HEAD == type) {
-		if (NULL == n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
-					"argument(s) suggested"))
+	switch (type) {
+	case (MDOC_Tag):
+		if (NULL == mdoc->last->head->child)
+			if ( ! mwarn(mdoc, WLINE))
 				return(0);
-
-		n = mdoc->last->data.block.body;
-		if (NULL == n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
-					"multiline body suggested"))
+		break;
+	case (MDOC_Hang):
+		/* FALLTHROUGH */
+	case (MDOC_Ohang):
+		/* FALLTHROUGH */
+	case (MDOC_Inset):
+		/* FALLTHROUGH */
+	case (MDOC_Diag):
+		if (NULL == mdoc->last->head->child)
+			if ( ! mwarn(mdoc, WLINE))
 				return(0);
-
-	} else if (TYPE_BODY == type) {
-		if (n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
-					"no argument suggested"))
+		if (NULL == mdoc->last->body->child)
+			if ( ! mwarn(mdoc, WMULTILINE))
 				return(0);
-	
-		n = mdoc->last->data.block.body;
-		if (NULL == n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
-					"multiline body suggested"))
+		break;
+	case (MDOC_Bullet):
+		/* FALLTHROUGH */
+	case (MDOC_Dash):
+		/* FALLTHROUGH */
+	case (MDOC_Enum):
+		/* FALLTHROUGH */
+	case (MDOC_Hyphen):
+		/* FALLTHROUGH */
+	case (MDOC_Item):
+		if (mdoc->last->head->child)
+			if ( ! mwarn(mdoc, WNOLINE))
 				return(0);
-	} else {
-		if (NULL == n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
-					"argument(s) suggested"))
+		if (NULL == mdoc->last->body->child)
+			if ( ! mwarn(mdoc, WMULTILINE))
 				return(0);
-	
-		n = mdoc->last->data.block.body;
-		if (n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
-					"no multiline body suggested"))
+		break;
+	case (MDOC_Column):
+		if (NULL == mdoc->last->head->child)
+			if ( ! mwarn(mdoc, WLINE))
 				return(0);
+		if (mdoc->last->body->child)
+			if ( ! mwarn(mdoc, WNOMULTILINE))
+				return(0);
+		c = mdoc->last->head->child;
+		for (i = 0; c; c = c->next)
+			i++;
+		if (i == cols)
+			break;
+		if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
+					"column mismatch (have %d, want %d)", i, cols))
+			return(0);
+		break;
+	default:
+		break;
 	}
 
-	if (MDOC_Column != sv)
-		return(1);
-
-	argc = mdoc->last->parent->parent->data.block.argv->sz;
-	n = mdoc->last->data.block.head->child;
-
-	for (i = 0; n; n = n->next)
-		i++;
-
-	if (i == (int)argc)
-		return(1);
-
-	return(mdoc_err(mdoc, "need %zu columns (have %d)", argc, i));
-#undef	TYPE_NONE
-#undef	TYPE_BODY
-#undef	TYPE_HEAD
-#undef	TYPE_OHEAD
+	return(1);
 }
 
 
@@ -1124,20 +1194,14 @@ post_bl(POST_ARGS)
 
 	if (MDOC_BODY != mdoc->last->type)
 		return(1);
-	if (NULL == (mdoc->last->child))
+	if (NULL == mdoc->last->child)
 		return(1);
 
-	/*
-	 * Only allow `It' macros to be the immediate descendants of the
-	 * `Bl' list. 
-	 */
-
 	/* LINTED */
 	for (n = mdoc->last->child; n; n = n->next) {
 		if (MDOC_BLOCK == n->type) 
 			if (MDOC_It == n->tok)
 				continue;
-
 		return(mdoc_nerr(mdoc, n, "bad child of parent %s",
 				mdoc_macronames[mdoc->last->tok]));
 	}
@@ -1155,16 +1219,16 @@ ebool(struct mdoc *mdoc)
 	for (n = mdoc->last->child; n; n = n->next) {
 		if (MDOC_TEXT != n->type)
 			break;
-		if (xstrcmp(n->data.text.string, "on"))
+		if (xstrcmp(n->string, "on"))
 			continue;
-		if (xstrcmp(n->data.text.string, "off"))
+		if (xstrcmp(n->string, "off"))
 			continue;
 		break;
 	}
 
 	if (NULL == n)
 		return(1);
-	return(mdoc_nerr(mdoc, n, "expected boolean"));
+	return(nerr(mdoc, n, EBOOL));
 }
 
 
@@ -1173,16 +1237,14 @@ post_root(POST_ARGS)
 {
 
 	if (NULL == mdoc->first->child)
-		return(mdoc_err(mdoc, "document lacks data"));
+		return(merr(mdoc, ENODATA));
 	if (SEC_PROLOGUE == mdoc->lastnamed)
-		return(mdoc_err(mdoc, "document lacks prologue"));
+		return(merr(mdoc, ENOPROLOGUE));
 
 	if (MDOC_BLOCK != mdoc->first->child->type)
-		return(mdoc_err(mdoc, "lacking post-prologue %s", 
-					mdoc_macronames[MDOC_Sh]));
+		return(merr(mdoc, ENODATA));
 	if (MDOC_Sh != mdoc->first->child->tok)
-		return(mdoc_err(mdoc, "lacking post-prologue %s", 
-					mdoc_macronames[MDOC_Sh]));
+		return(merr(mdoc, ENODATA));
 
 	return(1);
 }
@@ -1192,10 +1254,9 @@ static int
 post_st(POST_ARGS)
 {
 
-	if (mdoc_a2st(mdoc->last->child->data.text.string))
+	if (mdoc_a2st(mdoc->last->child->string))
 		return(1);
-
-	return(mdoc_warn(mdoc, WARN_SYNTAX, "invalid standard"));
+	return(mwarn(mdoc, WBADSTAND));
 }
 
 
@@ -1227,28 +1288,20 @@ post_sh_body(POST_ARGS)
 	 */
 
 	if (NULL == (n = mdoc->last->child))
-		return(mdoc_warn(mdoc, WARN_SYNTAX, 
-					"section should have %s and %s",
-					mdoc_macronames[MDOC_Nm],
-					mdoc_macronames[MDOC_Nd]));
+		return(mwarn(mdoc, WNAMESECINC));
 
 	for ( ; n && n->next; n = n->next) {
 		if (MDOC_ELEM == n->type && MDOC_Nm == n->tok)
 			continue;
 		if (MDOC_TEXT == n->type)
 			continue;
-		if ( ! (mdoc_nwarn(mdoc, n, WARN_SYNTAX, 
-					"section should have %s first",
-					mdoc_macronames[MDOC_Nm])))
+		if ( ! mwarn(mdoc, WNAMESECINC))
 			return(0);
 	}
 
 	if (MDOC_ELEM == n->type && MDOC_Nd == n->tok)
 		return(1);
-
-	return(mdoc_warn(mdoc, WARN_SYNTAX, 
-				"section should have %s last",
-				mdoc_macronames[MDOC_Nd]));
+	return(mwarn(mdoc, WNAMESECINC));
 }
 
 
@@ -1274,19 +1327,16 @@ post_sh_head(POST_ARGS)
 	/* The NAME section should always be first. */
 
 	if (SEC_BODY == mdoc->lastnamed && SEC_NAME != sec)
-		return(mdoc_warn(mdoc, WARN_SYNTAX, 
-				"section NAME should be first"));
+		return(mwarn(mdoc, WSECOOO));
 	if (SEC_CUSTOM == sec)
 		return(1);
 
 	/* Check for repeated or out-of-order sections. */
 
 	if (sec == mdoc->lastnamed)
-		return(mdoc_warn(mdoc, WARN_SYNTAX, 
-				"section repeated"));
+		return(mwarn(mdoc, WSECREP));
 	if (sec < mdoc->lastnamed)
-		return(mdoc_warn(mdoc, WARN_SYNTAX, 
-				"section out of conventional order"));
+		return(mwarn(mdoc, WSECOOO));
 
 	/* Check particular section/manual section conventions. */
 
@@ -1298,8 +1348,7 @@ post_sh_head(POST_ARGS)
 		case (3):
 			break;
 		default:
-			return(mdoc_warn(mdoc, WARN_COMPAT,
-				"section in wrong manual section"));
+			return(mwarn(mdoc, WWRONGMSEC));
 		}
 		break;
 	default:
diff --git a/xstd.c b/xstd.c
index 66aba8bd..8326aa2e 100644
--- a/xstd.c
+++ b/xstd.c
@@ -103,7 +103,7 @@ xstrlcpys(char *buf, const struct mdoc_node *n, size_t sz)
 
 	for ( ; n; n = n->next) {
 		assert(MDOC_TEXT == n->type);
-		p = n->data.text.string;
+		p = n->string;
 		if ( ! xstrlcat(buf, p, sz))
 			return(0);
 		if (n->next && ! xstrlcat(buf, " ", sz))