===================================================================
RCS file: /cvs/mandoc/Attic/validate.c,v
retrieving revision 1.51
retrieving revision 1.62
diff -u -p -r1.51 -r1.62
--- mandoc/Attic/validate.c	2009/02/22 14:31:08	1.51
+++ mandoc/Attic/validate.c	2009/02/27 09:14:02	1.62
@@ -1,4 +1,4 @@
-/* $Id: validate.c,v 1.51 2009/02/22 14:31:08 kristaps Exp $ */
+/* $Id: validate.c,v 1.62 2009/02/27 09:14:02 kristaps Exp $ */
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -17,6 +17,7 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 #include <assert.h>
+#include <ctype.h>
 #include <stdlib.h>
 
 #include "private.h"
@@ -29,15 +30,15 @@
  * the BLOCK case, this is the HEAD, BODY, TAIL and so on.
  */
 
-typedef	int	(*v_pre)(struct mdoc *, struct mdoc_node *);
-typedef	int	(*v_post)(struct mdoc *);
+#define	PRE_ARGS	struct mdoc *mdoc, const struct mdoc_node *n
+#define	POST_ARGS	struct mdoc *mdoc
 
+typedef	int	(*v_pre)(PRE_ARGS);
+typedef	int	(*v_post)(POST_ARGS);
+
 /* FIXME: some sections should only occur in specific msecs. */
 /* FIXME: ignoring Pp. */
-/* FIXME: .Ef arguments */
 /* FIXME: math symbols. */
-/* FIXME: valid character-escape checks. */
-/* FIXME: .Fd only in synopsis section. */
 
 struct	valids {
 	v_pre	*pre;
@@ -46,12 +47,15 @@ struct	valids {
 
 /* Utility checks. */
 
-static	int	check_parent(struct mdoc *, struct mdoc_node *, 
-			int, enum mdoc_type);
-static	int	check_msec(struct mdoc *, struct mdoc_node *, 
-			int, enum mdoc_msec *);
-static	int	check_stdarg(struct mdoc *, struct mdoc_node *);
+static	int	check_parent(PRE_ARGS, int, enum mdoc_type);
+static	int	check_msec(PRE_ARGS, int, enum mdoc_msec *);
+static	int	check_stdarg(PRE_ARGS);
+
+static	int	check_text(struct mdoc *, 
+			size_t, size_t, const char *);
+
 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);
@@ -67,50 +71,53 @@ static	inline int err_count(struct mdoc *, const char 
 
 /* Specific pre-child-parse routines. */
 
-static	int	pre_display(struct mdoc *, struct mdoc_node *);
-static	int	pre_sh(struct mdoc *, struct mdoc_node *);
-static	int	pre_ss(struct mdoc *, struct mdoc_node *);
-static	int	pre_bd(struct mdoc *, struct mdoc_node *);
-static	int	pre_bl(struct mdoc *, struct mdoc_node *);
-static	int	pre_it(struct mdoc *, struct mdoc_node *);
-static	int	pre_cd(struct mdoc *, struct mdoc_node *);
-static	int	pre_er(struct mdoc *, struct mdoc_node *);
-static	int	pre_ex(struct mdoc *, struct mdoc_node *);
-static	int	pre_rv(struct mdoc *, struct mdoc_node *);
-static	int	pre_an(struct mdoc *, struct mdoc_node *);
-static	int	pre_st(struct mdoc *, struct mdoc_node *);
-static	int	pre_prologue(struct mdoc *, struct mdoc_node *);
-static	int	pre_prologue(struct mdoc *, struct mdoc_node *);
-static	int	pre_prologue(struct mdoc *, struct mdoc_node *);
+static	int	pre_display(PRE_ARGS);
+static	int	pre_sh(PRE_ARGS);
+static	int	pre_ss(PRE_ARGS);
+static	int	pre_bd(PRE_ARGS);
+static	int	pre_bl(PRE_ARGS);
+static	int	pre_it(PRE_ARGS);
+static	int	pre_cd(PRE_ARGS);
+static	int	pre_er(PRE_ARGS);
+static	int	pre_ex(PRE_ARGS);
+static	int	pre_rv(PRE_ARGS);
+static	int	pre_an(PRE_ARGS);
+static	int	pre_st(PRE_ARGS);
+static	int	pre_prologue(PRE_ARGS);
+static	int	pre_prologue(PRE_ARGS);
+static	int	pre_prologue(PRE_ARGS);
 
 /* Specific post-child-parse routines. */
 
-static	int	herr_ge1(struct mdoc *);
-static	int	herr_le1(struct mdoc *);
-static	int	herr_eq0(struct mdoc *);
-static	int	eerr_eq0(struct mdoc *);
-static	int	eerr_le1(struct mdoc *);
-static	int	eerr_le2(struct mdoc *);
-static	int	eerr_eq1(struct mdoc *);
-static	int	eerr_ge1(struct mdoc *);
-static	int	ewarn_eq0(struct mdoc *);
-static	int	ewarn_eq1(struct mdoc *);
-static	int	bwarn_ge1(struct mdoc *);
-static	int	ewarn_ge1(struct mdoc *);
-static	int	ebool(struct mdoc *);
-static	int	post_sh(struct mdoc *);
-static	int	post_sh_body(struct mdoc *);
-static	int	post_sh_head(struct mdoc *);
-static	int	post_bl(struct mdoc *);
-static	int	post_it(struct mdoc *);
-static	int	post_ex(struct mdoc *);
-static	int	post_an(struct mdoc *);
-static	int	post_at(struct mdoc *);
-static	int	post_xr(struct mdoc *);
-static	int	post_nm(struct mdoc *);
-static	int	post_bf(struct mdoc *);
-static	int	post_root(struct mdoc *);
+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);
+static	int	ewarn_eq0(POST_ARGS);
+static	int	ewarn_eq1(POST_ARGS);
+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_sh(POST_ARGS);
+static	int	post_sh_body(POST_ARGS);
+static	int	post_sh_head(POST_ARGS);
+static	int	post_fd(POST_ARGS);
+static	int	post_bl(POST_ARGS);
+static	int	post_it(POST_ARGS);
+static	int	post_ex(POST_ARGS);
+static	int	post_an(POST_ARGS);
+static	int	post_at(POST_ARGS);
+static	int	post_xr(POST_ARGS);
+static	int	post_nm(POST_ARGS);
+static	int	post_bf(POST_ARGS);
+static	int	post_root(POST_ARGS);
+
 /* Collections of pre-child-parse routines. */
 
 static	v_pre	pres_prologue[] = { pre_prologue, NULL };
@@ -140,16 +147,18 @@ static	v_post	posts_bl[] = { herr_eq0, bwarn_ge1, post
 static	v_post	posts_it[] = { post_it, NULL };
 static	v_post	posts_in[] = { ewarn_eq1, NULL };
 static	v_post	posts_ss[] = { herr_ge1, NULL };
+static	v_post	posts_pf[] = { eerr_eq1, NULL };
 static	v_post	posts_pp[] = { ewarn_eq0, NULL };
 static	v_post	posts_ex[] = { eerr_le1, 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, post_xr, NULL };
 static	v_post	posts_nm[] = { post_nm, NULL };
-static	v_post	posts_bf[] = { herr_le1, post_bf, NULL };
+static	v_post	posts_bf[] = { hwarn_le1, post_bf, NULL };
 static	v_post	posts_rs[] = { herr_eq0, bwarn_ge1, NULL };
-static	v_post	posts_fo[] = { bwarn_ge1, NULL };
+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, post_fd, NULL };
 
 /* Per-macro pre- and post-child-check routine collections. */
 
@@ -178,7 +187,7 @@ const	struct valids mdoc_valids[MDOC_MAX] = {
 	{ NULL, posts_text },			/* Ev */ 
 	{ pres_ex, posts_ex },			/* Ex */ 
 	{ NULL, posts_text },			/* Fa */ 
-	{ NULL, posts_wtext },			/* Fd */
+	{ NULL, posts_fd },			/* Fd */
 	{ NULL, NULL },				/* Fl */
 	{ NULL, posts_text },			/* Fn */ 
 	{ NULL, posts_wtext },			/* Ft */ 
@@ -231,7 +240,7 @@ const	struct valids mdoc_valids[MDOC_MAX] = {
 	{ NULL, NULL },				/* Nx */
 	{ NULL, NULL },				/* Ox */
 	{ NULL, NULL },				/* Pc */
-	{ NULL, NULL },				/* Pf */
+	{ NULL, posts_pf },			/* Pf */
 	{ NULL, NULL },				/* Po */
 	{ NULL, posts_wline },			/* Pq */
 	{ NULL, NULL },				/* Qc */
@@ -263,288 +272,293 @@ const	struct valids mdoc_valids[MDOC_MAX] = {
 };
 
 
-static inline int
-warn_count(struct mdoc *m, const char *k, 
-		int want, const char *v, int has)
+int
+mdoc_valid_pre(struct mdoc *mdoc, 
+		const struct mdoc_node *node)
 {
+	v_pre		*p;
+	struct mdoc_arg	*argv;
+	size_t		 argc, i, j, line, pos;
+	const char	*tp;
 
-	return(mdoc_warn(m, WARN_SYNTAX, "suggests %s %d %s "
-				"(has %d)", v, want, k, has));
-}
+	if (MDOC_TEXT == node->type) {
+		tp = node->data.text.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;
 
-static inline int
-err_count(struct mdoc *m, const char *k,
-		int want, const char *v, int has)
-{
+		for (i = 0; i < argc; i++) {
+			if (0 == argv[i].sz)
+				continue;
+			for (j = 0; j < 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);
+			}
+		}
+	}
 
-	return(mdoc_err(m, "requires %s %d %s (has %d)",
-				v, want, k, has));
+	if (NULL == mdoc_valids[node->tok].pre)
+		return(1);
+	for (p = mdoc_valids[node->tok].pre; *p; p++)
+		if ( ! (*p)(mdoc, node)) 
+			return(0);
+	return(1);
 }
 
 
-static inline int
-count_child(struct mdoc *mdoc)
+int
+mdoc_valid_post(struct mdoc *mdoc)
 {
-	int		  i;
-	struct mdoc_node *n;
+	v_post		*p;
 
-	for (i = 0, n = mdoc->last->child; n; n = n->next, i++)
-		/* Do nothing */ ;
-	return(i);
-}
+	/*
+	 * This check occurs after the macro's children have been filled
+	 * in: postfix validation.  Since this happens when we're
+	 * rewinding the scope tree, it's possible to have multiple
+	 * invocations (as by design, for now), we set bit MDOC_VALID to
+	 * indicate that we've validated.
+	 */
 
-
-static int
-warn_child_gt(struct mdoc *mdoc, const char *p, int sz)
-{
-	int		  i;
-
-	if ((i = count_child(mdoc)) > sz)
+	if (MDOC_VALID & mdoc->last->flags)
 		return(1);
-	return(warn_count(mdoc, ">", sz, p, i));
-}
+	mdoc->last->flags |= MDOC_VALID;
 
-
-static int
-err_child_gt(struct mdoc *mdoc, const char *p, int sz)
-{
-	int		  i;
-
-	if ((i = count_child(mdoc)) > sz)
+	if (MDOC_TEXT == mdoc->last->type)
 		return(1);
-	return(err_count(mdoc, ">", sz, p, i));
-}
+	if (MDOC_ROOT == mdoc->last->type)
+		return(post_root(mdoc));
 
-
-static int
-warn_child_eq(struct mdoc *mdoc, const char *p, int sz)
-{
-	int		  i;
-
-	if ((i = count_child(mdoc)) == sz)
+	if (NULL == mdoc_valids[mdoc->last->tok].post)
 		return(1);
-	return(warn_count(mdoc, "==", sz, p, i));
-}
+	for (p = mdoc_valids[mdoc->last->tok].post; *p; p++)
+		if ( ! (*p)(mdoc)) 
+			return(0);
 
-
-static int
-err_child_eq(struct mdoc *mdoc, const char *p, int sz)
-{
-	int		  i;
-
-	if ((i = count_child(mdoc)) == sz)
-		return(1);
-	return(err_count(mdoc, "==", sz, p, i));
+	return(1);
 }
 
 
-static int
-err_child_lt(struct mdoc *mdoc, const char *p, int sz)
-{
-	int		  i;
 
-	if ((i = count_child(mdoc)) < sz)
-		return(1);
-	return(err_count(mdoc, "<", sz, p, i));
-}
-
-
-static int
-check_stdarg(struct mdoc *mdoc, struct mdoc_node *node)
+static inline int
+warn_count(struct mdoc *m, const char *k, 
+		int want, const char *v, int has)
 {
 
-	if (MDOC_Std == node->data.elem.argv[0].arg && 
-			1 == node->data.elem.argc)
-		return(1);
-
-	return(mdoc_nwarn(mdoc, node, WARN_COMPAT, 
-				"macro suggests single `%s' argument",
-				mdoc_argnames[MDOC_Std]));
+	return(mdoc_warn(m, WARN_SYNTAX, 
+				"suggests %s %s %d (has %d)", 
+				v, k, want, has));
 }
 
 
-static int
-check_msec(struct mdoc *mdoc, struct mdoc_node *node, 
-		int sz, enum mdoc_msec *msecs)
+static inline int
+err_count(struct mdoc *m, const char *k,
+		int want, const char *v, int has)
 {
-	int		 i;
 
-	for (i = 0; i < sz; i++)
-		if (msecs[i] == mdoc->meta.msec)
-			return(1);
-	return(mdoc_nwarn(mdoc, node, WARN_COMPAT, "macro not "
-				"appropriate for manual section"));
+	return(mdoc_err(m, "requires %s %s %d (has %d)",
+				v, k, want, has));
 }
 
 
-static int
-check_parent(struct mdoc *mdoc, struct mdoc_node *n, 
-		int tok, enum mdoc_type t)
+static inline int
+count_child(struct mdoc *mdoc)
 {
+	int		  i;
+	struct mdoc_node *n;
 
-	assert(n->parent);
-	if ((MDOC_ROOT == t || tok == n->parent->tok) &&
-			(t == n->parent->type))
-		return(1);
+	for (i = 0, n = mdoc->last->child; n; n = n->next, i++)
+		/* Do nothing */ ;
 
-	return(mdoc_nerr(mdoc, n, "require parent %s (have %s)", 
-			MDOC_ROOT == t ? "<root>" :
-			mdoc_macronames[tok],
-			MDOC_ROOT == n->parent->type ? "<root>" :
-			mdoc_macronames[n->parent->type]));
+	return(i);
 }
 
 
-static int
-bwarn_ge1(struct mdoc *mdoc)
-{
+/*
+ * Build these up with macros because they're basically the same check
+ * for different inequalities.  Yes, this could be done with functions,
+ * but this is reasonable for now.
+ */
 
-	if (MDOC_BODY != mdoc->last->type)
-		return(1);
-	return(warn_child_gt(mdoc, "multi-line parameters", 0));
+#define CHECK_CHILD_DEFN(lvl, name, ineq) 			\
+static int 							\
+lvl##_child_##name(struct mdoc *mdoc, const char *p, int sz) 	\
+{ 								\
+	int i; 							\
+	if ((i = count_child(mdoc)) ineq sz) 			\
+		return(1); 					\
+	return(lvl##_count(mdoc, #ineq, sz, p, i)); 		\
 }
 
-
-static int
-ewarn_eq1(struct mdoc *mdoc)
-{
-
-	assert(MDOC_ELEM == mdoc->last->type);
-	return(warn_child_eq(mdoc, "line parameters", 1));
+#define CHECK_BODY_DEFN(name, lvl, func, num) 			\
+static int 							\
+b##lvl##_##name(POST_ARGS) 					\
+{ 								\
+	if (MDOC_BODY != mdoc->last->type) 			\
+		return(1); 					\
+	return(func(mdoc, "multiline parameters", (num))); 	\
 }
 
-
-static int
-ewarn_eq0(struct mdoc *mdoc)
-{
-
-	assert(MDOC_ELEM == mdoc->last->type);
-	return(warn_child_eq(mdoc, "line parameters", 0));
+#define CHECK_ELEM_DEFN(name, lvl, func, num) 			\
+static int							\
+e##lvl##_##name(POST_ARGS) 					\
+{ 								\
+	assert(MDOC_ELEM == mdoc->last->type); 			\
+	return(func(mdoc, "line parameters", (num))); 		\
 }
 
-
-static int
-ewarn_ge1(struct mdoc *mdoc)
-{
-
-	assert(MDOC_ELEM == mdoc->last->type);
-	return(warn_child_gt(mdoc, "line parameters", 0));
+#define CHECK_HEAD_DEFN(name, lvl, func, num)			\
+static int 							\
+h##lvl##_##name(POST_ARGS) 					\
+{ 								\
+	if (MDOC_HEAD != mdoc->last->type) 			\
+		return(1); 					\
+	return(func(mdoc, "line parameters", (num)));	 	\
 }
 
 
-static int
-eerr_eq1(struct mdoc *mdoc)
-{
+CHECK_CHILD_DEFN(warn, gt, >)			/* warn_child_gt() */
+CHECK_CHILD_DEFN(err, gt, >)			/* err_child_gt() */
+CHECK_CHILD_DEFN(warn, eq, ==)			/* warn_child_eq() */
+CHECK_CHILD_DEFN(err, eq, ==)			/* err_child_eq() */
+CHECK_CHILD_DEFN(err, lt, <)			/* err_child_lt() */
+CHECK_CHILD_DEFN(warn, lt, <)			/* warn_child_lt() */
+CHECK_BODY_DEFN(ge1, warn, warn_child_gt, 0)	/* bwarn_ge1() */
+CHECK_ELEM_DEFN(eq1, warn, warn_child_eq, 1)	/* ewarn_eq1() */
+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() */
+CHECK_HEAD_DEFN(le1, warn, warn_child_lt, 2)	/* hwarn_le1() */
+CHECK_HEAD_DEFN(ge1, err, err_child_gt, 0)	/* herr_ge1() */
+CHECK_HEAD_DEFN(eq1, warn, warn_child_eq, 1)	/* hwarn_eq1() */
 
-	assert(MDOC_ELEM == mdoc->last->type);
-	return(err_child_eq(mdoc, "line parameters", 1));
-}
 
-
 static int
-eerr_le2(struct mdoc *mdoc)
+check_stdarg(PRE_ARGS)
 {
 
-	assert(MDOC_ELEM == mdoc->last->type);
-	return(err_child_lt(mdoc, "line parameters", 3));
-}
+	if (MDOC_Std == n->data.elem.argv[0].arg && 
+			1 == n->data.elem.argc)
+		return(1);
 
-
-static int
-eerr_le1(struct mdoc *mdoc)
-{
-
-	assert(MDOC_ELEM == mdoc->last->type);
-	return(err_child_lt(mdoc, "line parameters", 2));
+	return(mdoc_nwarn(mdoc, n, WARN_COMPAT, 
+				"one argument suggested"));
 }
 
 
 static int
-eerr_eq0(struct mdoc *mdoc)
+check_msec(PRE_ARGS, int sz, enum mdoc_msec *msecs)
 {
+	int		 i;
 
-	assert(MDOC_ELEM == mdoc->last->type);
-	return(err_child_eq(mdoc, "line parameters", 0));
+	for (i = 0; i < sz; i++)
+		if (msecs[i] == mdoc->meta.msec)
+			return(1);
+	return(mdoc_nwarn(mdoc, n, WARN_COMPAT, 
+				"invalid manual section"));
 }
 
 
 static int
-eerr_ge1(struct mdoc *mdoc)
+check_text(struct mdoc *mdoc, size_t line, size_t pos, const char *p)
 {
+	size_t		 c;
 
-	assert(MDOC_ELEM == mdoc->last->type);
-	return(err_child_gt(mdoc, "line parameters", 0));
-}
+	/* XXX - indicate deprecated escapes \*(xx and \*x. */
 
+	for ( ; *p; p++) {
+		if ( ! isprint((int)*p) && '\t' != *p)
+			return(mdoc_perr(mdoc, line, pos,
+					"invalid characters"));
+		if ('\\' != *p)
+			continue;
+		if ((c = mdoc_isescape(p))) {
+			p += (c - 1);
+			continue;
+		}
+		return(mdoc_perr(mdoc, line, pos,
+					"invalid escape sequence"));
+	}
 
-static int
-herr_eq0(struct mdoc *mdoc)
-{
-
-	if (MDOC_HEAD != mdoc->last->type)
-		return(1);
-	return(err_child_eq(mdoc, "line parameters", 0));
+	return(1);
 }
 
 
-static int
-herr_le1(struct mdoc *mdoc)
-{
-	if (MDOC_HEAD != mdoc->last->type)
-		return(1);
-	return(err_child_lt(mdoc, "line parameters", 2));
-}
 
 
 static int
-herr_ge1(struct mdoc *mdoc)
+check_parent(PRE_ARGS, int tok, enum mdoc_type t)
 {
 
-	if (MDOC_HEAD != mdoc->last->type)
+	assert(n->parent);
+	if ((MDOC_ROOT == t || tok == n->parent->tok) &&
+			(t == n->parent->type))
 		return(1);
-	return(err_child_gt(mdoc, "line parameters", 0));
+
+	return(mdoc_nerr(mdoc, n, "require parent %s",
+		MDOC_ROOT == t ? "<root>" : mdoc_macronames[tok]));
 }
 
 
+
 static int
-pre_display(struct mdoc *mdoc, struct mdoc_node *node)
+pre_display(PRE_ARGS)
 {
-	struct mdoc_node *n;
+	struct mdoc_node *node;
 
-	if (MDOC_BLOCK != node->type)
+	/* Display elements (`Bd', `D1'...) cannot be nested. */
+
+	if (MDOC_BLOCK != n->type)
 		return(1);
 
-	assert(mdoc->last);
 	/* LINTED */
-	for (n = mdoc->last->parent; n; n = n->parent) 
-		if (MDOC_BLOCK == n->type)
-			if (MDOC_Bd == n->tok)
+	for (node = mdoc->last->parent; node; node = node->parent) 
+		if (MDOC_BLOCK == node->type)
+			if (MDOC_Bd == node->tok)
 				break;
-	if (NULL == n)
+	if (NULL == node)
 		return(1);
-	return(mdoc_nerr(mdoc, node, "displays may not be nested"));
+
+	return(mdoc_nerr(mdoc, n, "displays may not be nested"));
 }
 
 
 static int
-pre_bl(struct mdoc *mdoc, struct mdoc_node *node)
+pre_bl(PRE_ARGS)
 {
-	int		 type, err;
+	int		 type, i, width, offset;
 	struct mdoc_arg	*argv;
-	size_t		 i, argc;
+	size_t		 argc;
 
-	if (MDOC_BLOCK != node->type)
+	if (MDOC_BLOCK != n->type)
 		return(1);
-	assert(MDOC_Bl == node->tok);
 
-	argv = NULL;
-	argc = node->data.block.argc; 
+	argc = n->data.block.argc; 
 
+	/* Make sure that only one type of list is specified.  */
+
+	type = offset = width = -1;
+
 	/* LINTED */
-	for (i = type = err = 0; i < argc; i++) {
-		argv = &node->data.block.argv[(int)i];
-		assert(argv);
+	for (i = 0; i < (int)argc; i++) {
+		argv = &n->data.block.argv[i];
+
 		switch (argv->arg) {
 		case (MDOC_Bullet):
 			/* FALLTHROUGH */
@@ -567,42 +581,81 @@ pre_bl(struct mdoc *mdoc, struct mdoc_node *node)
 		case (MDOC_Inset):
 			/* FALLTHROUGH */
 		case (MDOC_Column):
-			if (type)
-				err++;
-			type++;
-			break;
+			if (-1 == type) {
+				type = argv->arg;
+				break;
+			}
+			return(mdoc_perr(mdoc, argv->line, argv->pos, 
+					"multiple types specified"));
+		case (MDOC_Width):
+			if (-1 == width) {
+				width = argv->arg;
+				break;
+			}
+			return(mdoc_perr(mdoc, argv->line, argv->pos, 
+					"multiple -%s arguments",
+					mdoc_argnames[MDOC_Width]));
+		case (MDOC_Offset):
+			if (-1 == offset) {
+				offset = argv->arg;
+				break;
+			}
+			return(mdoc_perr(mdoc, argv->line, argv->pos, 
+					"multiple -%s arguments",
+					mdoc_argnames[MDOC_Offset]));
 		default:
 			break;
 		}
 	}
-	if (0 == type)
-		return(mdoc_err(mdoc, "no list type specified"));
-	if (0 == err)
-		return(1);
-	assert(argv);
-	return(mdoc_perr(mdoc, argv->line, 
-			argv->pos, "only one list type possible"));
+
+	if (-1 == type)
+		return(mdoc_err(mdoc, "no type specified"));
+
+	switch (type) {
+	case (MDOC_Column):
+		/* FALLTHROUGH */
+	case (MDOC_Diag):
+		/* FALLTHROUGH */
+	case (MDOC_Inset):
+		/* FALLTHROUGH */
+	case (MDOC_Item):
+		if (-1 == width)
+			break;
+		return(mdoc_nwarn(mdoc, n, WARN_SYNTAX,
+				"superfluous -%s argument",
+				mdoc_argnames[MDOC_Width]));
+	case (MDOC_Tag):
+		if (-1 != width)
+			break;
+		return(mdoc_nwarn(mdoc, n, WARN_SYNTAX,
+				"suggest -%s argument",
+				mdoc_argnames[MDOC_Width]));
+	default:
+		break;
+	}
+
+	return(1);
 }
 
 
 static int
-pre_bd(struct mdoc *mdoc, struct mdoc_node *node)
+pre_bd(PRE_ARGS)
 {
-	int		 type, err;
+	int		 type, err, i;
 	struct mdoc_arg	*argv;
-	size_t		 i, argc;
+	size_t		 argc;
 
-	if (MDOC_BLOCK != node->type)
+	if (MDOC_BLOCK != n->type)
 		return(1);
-	assert(MDOC_Bd == node->tok);
 
-	argv = NULL;
-	argc = node->data.block.argc;
+	argc = n->data.block.argc;
 
+	/* Make sure that only one type of display is specified.  */
+
 	/* LINTED */
-	for (err = i = type = 0; 0 == err && i < argc; i++) {
-		argv = &node->data.block.argv[(int)i];
-		assert(argv);
+	for (i = 0, err = type = 0; ! err && i < (int)argc; i++) {
+		argv = &n->data.block.argv[i];
+
 		switch (argv->arg) {
 		case (MDOC_Ragged):
 			/* FALLTHROUGH */
@@ -613,157 +666,135 @@ pre_bd(struct mdoc *mdoc, struct mdoc_node *node)
 		case (MDOC_Literal):
 			/* FALLTHROUGH */
 		case (MDOC_File):
-			if (type)
-				err++;
-			type++;
-			break;
+			if (0 == type++) 
+				break;
+			return(mdoc_perr(mdoc, argv->line, argv->pos, 
+					"multiple types specified"));
 		default:
 			break;
 		}
 	}
-	if (0 == type)
-		return(mdoc_err(mdoc, "no display type specified"));
-	if (0 == err)
+
+	if (type)
 		return(1);
-	assert(argv);
-	return(mdoc_perr(mdoc, argv->line, 
-			argv->pos, "only one display type possible"));
+	return(mdoc_err(mdoc, "no type specified"));
 }
 
 
 static int
-pre_ss(struct mdoc *mdoc, struct mdoc_node *node)
+pre_ss(PRE_ARGS)
 {
 
-	if (MDOC_BLOCK != node->type)
+	if (MDOC_BLOCK != n->type)
 		return(1);
-	return(check_parent(mdoc, node, MDOC_Sh, MDOC_BODY));
+	return(check_parent(mdoc, n, MDOC_Sh, MDOC_BODY));
 }
 
 
 static int
-pre_sh(struct mdoc *mdoc, struct mdoc_node *node)
+pre_sh(PRE_ARGS)
 {
 
-	if (MDOC_BLOCK != node->type)
+	if (MDOC_BLOCK != n->type)
 		return(1);
-	return(check_parent(mdoc, node, -1, MDOC_ROOT));
+	return(check_parent(mdoc, n, -1, MDOC_ROOT));
 }
 
 
 static int
-pre_st(struct mdoc *mdoc, struct mdoc_node *node)
+pre_it(PRE_ARGS)
 {
 
-	assert(MDOC_ELEM == node->type);
-	assert(MDOC_St == node->tok);
-	if (1 == node->data.elem.argc)
+	/* TODO: children too big for -width? */
+
+	if (MDOC_BLOCK != n->type)
 		return(1);
-	return(mdoc_nerr(mdoc, node, "macro must have one argument"));
+	return(check_parent(mdoc, n, MDOC_Bl, MDOC_BODY));
 }
 
 
 static int
-pre_an(struct mdoc *mdoc, struct mdoc_node *node)
+pre_st(PRE_ARGS)
 {
 
-	assert(MDOC_ELEM == node->type);
-	assert(MDOC_An == node->tok);
-	if (1 >= node->data.elem.argc)
+	if (1 == n->data.elem.argc)
 		return(1);
-	return(mdoc_nerr(mdoc, node, "macro may only have one argument"));
+	return(mdoc_nerr(mdoc, n, "one argument required"));
 }
 
 
 static int
-pre_rv(struct mdoc *mdoc, struct mdoc_node *node)
+pre_an(PRE_ARGS)
 {
-	enum mdoc_msec	 msecs[2];
 
-	assert(MDOC_ELEM == node->type);
-	assert(MDOC_Rv == node->tok);
-
-	msecs[0] = MSEC_2;
-	msecs[1] = MSEC_3;
-	if ( ! check_msec(mdoc, node, 2, msecs))
-		return(0);
-	return(check_stdarg(mdoc, node));
+	if (1 >= n->data.elem.argc)
+		return(1);
+	return(mdoc_nerr(mdoc, n, "one argument allowed"));
 }
 
 
 static int
-pre_ex(struct mdoc *mdoc, struct mdoc_node *node)
+pre_rv(PRE_ARGS)
 {
-	enum mdoc_msec	 msecs[3];
+	enum mdoc_msec msecs[] = { MSEC_2, MSEC_3 };
 
-	assert(MDOC_ELEM == node->type);
-	assert(MDOC_Ex == node->tok);
-
-	msecs[0] = MSEC_1;
-	msecs[1] = MSEC_6;
-	msecs[2] = MSEC_8;
-	if ( ! check_msec(mdoc, node, 3, msecs))
+	if ( ! check_msec(mdoc, n, 2, msecs))
 		return(0);
-	return(check_stdarg(mdoc, node));
+	return(check_stdarg(mdoc, n));
 }
 
 
 static int
-pre_er(struct mdoc *mdoc, struct mdoc_node *node)
+pre_ex(PRE_ARGS)
 {
-	enum mdoc_msec	 msecs[1];
+	enum mdoc_msec msecs[] = { MSEC_1, MSEC_6, MSEC_8 };
 
-	msecs[0] = MSEC_2;
-	return(check_msec(mdoc, node, 1, msecs));
+	if ( ! check_msec(mdoc, n, 3, msecs))
+		return(0);
+	return(check_stdarg(mdoc, n));
 }
 
 
 static int
-pre_cd(struct mdoc *mdoc, struct mdoc_node *node)
+pre_er(PRE_ARGS)
 {
-	enum mdoc_msec	 msecs[1];
+	enum mdoc_msec msecs[] = { MSEC_2 };
 
-	msecs[0] = MSEC_4;
-	return(check_msec(mdoc, node, 1, msecs));
+	return(check_msec(mdoc, n, 1, msecs));
 }
 
 
 static int
-pre_it(struct mdoc *mdoc, struct mdoc_node *node)
+pre_cd(PRE_ARGS)
 {
+	enum mdoc_msec msecs[] = { MSEC_4 };
 
-	/* TODO: -width attribute must be specified for -tag. */
-	/* TODO: children too big for -width? */
-
-	if (MDOC_BLOCK != node->type)
-		return(1);
-	return(check_parent(mdoc, node, MDOC_Bl, MDOC_BODY));
+	return(check_msec(mdoc, n, 1, msecs));
 }
 
 
 static int
-pre_prologue(struct mdoc *mdoc, struct mdoc_node *node)
+pre_prologue(PRE_ARGS)
 {
 
 	if (SEC_PROLOGUE != mdoc->lastnamed)
-		return(mdoc_nerr(mdoc, node, "macro may only be invoked in the prologue"));
-	assert(MDOC_ELEM == node->type);
+		return(mdoc_nerr(mdoc, n, "prologue only"));
 
 	/* Check for ordering. */
 
-	switch (node->tok) {
+	switch (n->tok) {
 	case (MDOC_Os):
 		if (mdoc->meta.title && mdoc->meta.date)
 			break;
-		return(mdoc_nerr(mdoc, node, "prologue macro out-of-order"));
+		return(mdoc_nerr(mdoc, n, "prologue out-of-order"));
 	case (MDOC_Dt):
 		if (NULL == mdoc->meta.title && mdoc->meta.date)
 			break;
-		return(mdoc_nerr(mdoc, node, "prologue macro out-of-order"));
+		return(mdoc_nerr(mdoc, n, "prologue out-of-order"));
 	case (MDOC_Dd):
 		if (NULL == mdoc->meta.title && 0 == mdoc->meta.date)
 			break;
-		return(mdoc_nerr(mdoc, node, "prologue macro out-of-order"));
+		return(mdoc_nerr(mdoc, n, "prologue out-of-order"));
 	default:
 		abort();
 		/* NOTREACHED */
@@ -771,7 +802,7 @@ pre_prologue(struct mdoc *mdoc, struct mdoc_node *node
 
 	/* Check for repetition. */
 
-	switch (node->tok) {
+	switch (n->tok) {
 	case (MDOC_Os):
 		if (NULL == mdoc->meta.os)
 			return(1);
@@ -789,72 +820,63 @@ pre_prologue(struct mdoc *mdoc, struct mdoc_node *node
 		/* NOTREACHED */
 	}
 
-	return(mdoc_nerr(mdoc, node, "prologue macro repeated"));
+	return(mdoc_nerr(mdoc, n, "prologue repetition"));
 }
 
 
 static int
-post_bf(struct mdoc *mdoc)
+post_bf(POST_ARGS)
 {
 	char		 *p;
 	struct mdoc_node *head;
 
 	if (MDOC_BLOCK != mdoc->last->type)
 		return(1);
-	assert(MDOC_Bf == mdoc->last->tok);
+
 	head = mdoc->last->data.block.head;
-	assert(head);
 
 	if (0 == mdoc->last->data.block.argc) {
-		if (head->child) {
-			assert(MDOC_TEXT == head->child->type);
-			p = head->child->data.text.string;
-			if (xstrcmp(p, "Em"))
-				return(1);
-			else if (xstrcmp(p, "Li"))
-				return(1);
-			else if (xstrcmp(p, "Sm"))
-				return(1);
-			return(mdoc_nerr(mdoc, head->child, "invalid font mode"));
-		}
-		return(mdoc_err(mdoc, "macro expects an argument or parameter"));
+		if (NULL == head->child)
+			return(mdoc_err(mdoc, "argument expected"));
+
+		p = head->child->data.text.string;
+		if (xstrcmp(p, "Em"))
+			return(1);
+		else if (xstrcmp(p, "Li"))
+			return(1);
+		else if (xstrcmp(p, "Sm"))
+			return(1);
+		return(mdoc_nerr(mdoc, head->child, "invalid font"));
 	}
+
 	if (head->child)
-		return(mdoc_err(mdoc, "macro expects an argument or parameter"));
+		return(mdoc_err(mdoc, "argument expected"));
+
 	if (1 == mdoc->last->data.block.argc)
 		return(1);
-	return(mdoc_err(mdoc, "macro expects an argument or parameter"));
+	return(mdoc_err(mdoc, "argument expected"));
 }
 
 
 static int
-post_nm(struct mdoc *mdoc)
+post_nm(POST_ARGS)
 {
 
-	assert(MDOC_ELEM == mdoc->last->type);
-	assert(MDOC_Nm == mdoc->last->tok);
 	if (mdoc->last->child)
 		return(1);
 	if (mdoc->meta.name)
 		return(1);
-	return(mdoc_err(mdoc, "macro `%s' has not been invoked with a name",
-				mdoc_macronames[MDOC_Nm]));
+	return(mdoc_err(mdoc, "not yet invoked with name"));
 }
 
 
 static int
-post_xr(struct mdoc *mdoc)
+post_xr(POST_ARGS)
 {
 	struct mdoc_node *n;
 
-	assert(MDOC_ELEM == mdoc->last->type);
-	assert(MDOC_Xr == mdoc->last->tok);
-	assert(mdoc->last->child);
-	assert(MDOC_TEXT == mdoc->last->child->type);
-
 	if (NULL == (n = mdoc->last->child->next))
 		return(1);
-	assert(MDOC_TEXT == n->type);
 	if (MSEC_DEFAULT != mdoc_atomsec(n->data.text.string))
 		return(1);
 	return(mdoc_nerr(mdoc, n, "invalid manual section"));
@@ -862,92 +884,69 @@ post_xr(struct mdoc *mdoc)
 
 
 static int
-post_at(struct mdoc *mdoc)
+post_at(POST_ARGS)
 {
 
-	assert(MDOC_ELEM == mdoc->last->type);
-	assert(MDOC_At == mdoc->last->tok);
-
 	if (NULL == mdoc->last->child)
 		return(1);
-	assert(MDOC_TEXT == mdoc->last->child->type);
-
 	if (ATT_DEFAULT != mdoc_atoatt(mdoc->last->child->data.text.string))
 		return(1);
-	return(mdoc_err(mdoc, "macro expects a valid AT&T version symbol"));
+	return(mdoc_err(mdoc, "require valid symbol"));
 }
 
 
 static int
-post_an(struct mdoc *mdoc)
+post_an(POST_ARGS)
 {
 
-	assert(MDOC_ELEM == mdoc->last->type);
-	assert(MDOC_An == mdoc->last->tok);
-
 	if (0 != mdoc->last->data.elem.argc) {
 		if (NULL == mdoc->last->child)
 			return(1);
-		return(mdoc_err(mdoc, "macro expects either argument or parameters"));
+		return(mdoc_err(mdoc, "argument(s) expected"));
 	}
 
 	if (mdoc->last->child)
 		return(1);
-	return(mdoc_err(mdoc, "macro expects either argument or parameters"));
+	return(mdoc_err(mdoc, "argument(s) expected"));
 }
 
 
 static int
-post_ex(struct mdoc *mdoc)
+post_ex(POST_ARGS)
 {
 
-	assert(MDOC_ELEM == mdoc->last->type);
-	assert(MDOC_Ex == mdoc->last->tok);
-
 	if (0 == mdoc->last->data.elem.argc) {
 		if (mdoc->last->child)
 			return(1);
-		return(mdoc_err(mdoc, "macro expects `%s' or a single child",
-					mdoc_argnames[MDOC_Std]));
+		return(mdoc_err(mdoc, "argument(s) expected"));
 	}
 	if (mdoc->last->child)
-		return(mdoc_err(mdoc, "macro expects `%s' or a single child",
-					mdoc_argnames[MDOC_Std]));
+		return(mdoc_err(mdoc, "argument(s) expected"));
 	if (1 != mdoc->last->data.elem.argc)
-		return(mdoc_err(mdoc, "macro expects `%s' or a single child",
-					mdoc_argnames[MDOC_Std]));
+		return(mdoc_err(mdoc, "argument(s) expected"));
 	if (MDOC_Std != mdoc->last->data.elem.argv[0].arg)
-		return(mdoc_err(mdoc, "macro expects `%s' or a single child",
-					mdoc_argnames[MDOC_Std]));
+		return(mdoc_err(mdoc, "argument(s) expected"));
+
 	return(1);
 }
 
 
-/* Warn if `Bl' type-specific syntax isn't reflected in items. */
 static int
-post_it(struct mdoc *mdoc)
+post_it(POST_ARGS)
 {
-	int		  type, sv;
+	int		  type, sv, i;
 #define	TYPE_NONE	 (0)
 #define	TYPE_BODY	 (1)
 #define	TYPE_HEAD	 (2)
 #define	TYPE_OHEAD	 (3)
-	size_t		  i, argc;
+	size_t		  argc;
 	struct mdoc_node *n;
 
 	if (MDOC_BLOCK != mdoc->last->type)
 		return(1);
 
-	assert(MDOC_It == mdoc->last->tok);
+	n = mdoc->last->parent->parent;
 
-	n = mdoc->last->parent;
-	assert(n);
-	assert(MDOC_Bl == n->tok);
-
-	n = n->parent;
-	assert(MDOC_BLOCK == n->type);
-	assert(MDOC_Bl == n->tok);
-
 	argc = n->data.block.argc;
 	type = TYPE_NONE;
 	sv = -1;
@@ -955,8 +954,8 @@ post_it(struct mdoc *mdoc)
 	/* Some types require block-head, some not. */
 
 	/* LINTED */
-	for (i = 0; TYPE_NONE == type && i < argc; i++)
-		switch (n->data.block.argv[(int)i].arg) {
+	for (i = 0; TYPE_NONE == type && i < (int)argc; i++)
+		switch (n->data.block.argv[i].arg) {
 		case (MDOC_Tag):
 			/* FALLTHROUGH */
 		case (MDOC_Diag):
@@ -967,7 +966,7 @@ post_it(struct mdoc *mdoc)
 			/* FALLTHROUGH */
 		case (MDOC_Inset):
 			type = TYPE_HEAD;
-			sv = n->data.block.argv[(int)i].arg;
+			sv = n->data.block.argv[i].arg;
 			break;
 		case (MDOC_Bullet):
 			/* FALLTHROUGH */
@@ -979,11 +978,11 @@ post_it(struct mdoc *mdoc)
 			/* FALLTHROUGH */
 		case (MDOC_Item):
 			type = TYPE_BODY;
-			sv = n->data.block.argv[(int)i].arg;
+			sv = n->data.block.argv[i].arg;
 			break;
 		case (MDOC_Column):
 			type = TYPE_OHEAD;
-			sv = n->data.block.argv[(int)i].arg;
+			sv = n->data.block.argv[i].arg;
 			break;
 		default:
 			break;
@@ -992,55 +991,56 @@ post_it(struct mdoc *mdoc)
 	assert(TYPE_NONE != type);
 
 	n = mdoc->last->data.block.head;
-	assert(n);
 
 	if (TYPE_HEAD == type) {
 		if (NULL == n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests line parameters"))
+			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
+					"argument(s) suggested"))
 				return(0);
 
 		n = mdoc->last->data.block.body;
-		assert(n);
 		if (NULL == n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests body children"))
+			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
+					"multiline body suggested"))
 				return(0);
 
 	} else if (TYPE_BODY == type) {
 		if (n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests no line parameters"))
+			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
+					"no argument suggested"))
 				return(0);
 	
 		n = mdoc->last->data.block.body;
-		assert(n);
 		if (NULL == n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests body children"))
+			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
+					"multiline body suggested"))
 				return(0);
 	} else {
 		if (NULL == n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests line parameters"))
+			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
+					"argument(s) suggested"))
 				return(0);
 	
 		n = mdoc->last->data.block.body;
-		assert(n);
 		if (n->child)
-			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests no body children"))
+			if ( ! mdoc_warn(mdoc, WARN_SYNTAX, 
+					"no multiline body suggested"))
 				return(0);
 	}
 
 	if (MDOC_Column != sv)
 		return(1);
 
-	/* Make sure the number of columns is sane. */
-
 	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 == argc)
+	if (i == (int)argc)
 		return(1);
-	return(mdoc_err(mdoc, "expected %zu list columns, have %zu", argc, i));
+
+	return(mdoc_err(mdoc, "need %zu columns (have %d)", argc, i));
 #undef	TYPE_NONE
 #undef	TYPE_BODY
 #undef	TYPE_HEAD
@@ -1049,13 +1049,12 @@ post_it(struct mdoc *mdoc)
 
 
 static int
-post_bl(struct mdoc *mdoc)
+post_bl(POST_ARGS)
 {
-	struct mdoc_node *n;
+	struct mdoc_node	*n;
 
 	if (MDOC_BODY != mdoc->last->type)
 		return(1);
-	assert(MDOC_Bl == mdoc->last->tok);
 
 	/* LINTED */
 	for (n = mdoc->last->child; n; n = n->next) {
@@ -1064,9 +1063,11 @@ post_bl(struct mdoc *mdoc)
 				continue;
 		break;
 	}
+
 	if (NULL == n)
 		return(1);
-	return(mdoc_nerr(mdoc, n, "invalid child of parent macro `Bl'"));
+
+	return(mdoc_nerr(mdoc, n, "bad child of parent list"));
 }
 
 
@@ -1075,7 +1076,6 @@ ebool(struct mdoc *mdoc)
 {
 	struct mdoc_node *n;
 
-	assert(MDOC_ELEM == mdoc->last->type);
 	/* LINTED */
 	for (n = mdoc->last->child; n; n = n->next) {
 		if (MDOC_TEXT != n->type)
@@ -1086,47 +1086,51 @@ ebool(struct mdoc *mdoc)
 			continue;
 		break;
 	}
+
 	if (NULL == n)
 		return(1);
-	return(mdoc_nerr(mdoc, n, "expected boolean value"));
+	return(mdoc_nerr(mdoc, n, "expected boolean"));
 }
 
 
 static int
-post_root(struct mdoc *mdoc)
+post_root(POST_ARGS)
 {
 
 	if (NULL == mdoc->first->child)
-		return(mdoc_err(mdoc, "document has no data"));
+		return(mdoc_err(mdoc, "document lacks data"));
 	if (SEC_PROLOGUE == mdoc->lastnamed)
-		return(mdoc_err(mdoc, "document has incomplete prologue"));
+		return(mdoc_err(mdoc, "document lacks prologue"));
+
 	if (MDOC_BLOCK != mdoc->first->child->type)
-		return(mdoc_err(mdoc, "document expects `%s' macro after prologue", mdoc_macronames[MDOC_Sh]));
+		return(mdoc_err(mdoc, "lacking post-prologue %s", 
+					mdoc_macronames[MDOC_Sh]));
 	if (MDOC_Sh != mdoc->first->child->tok)
-		return(mdoc_err(mdoc, "document expects `%s' macro after prologue", mdoc_macronames[MDOC_Sh]));
+		return(mdoc_err(mdoc, "lacking post-prologue %s", 
+					mdoc_macronames[MDOC_Sh]));
+
 	return(1);
 }
 
 
 static int
-post_sh(struct mdoc *mdoc)
+post_sh(POST_ARGS)
 {
 
 	if (MDOC_HEAD == mdoc->last->type)
 		return(post_sh_head(mdoc));
 	if (MDOC_BODY == mdoc->last->type)
 		return(post_sh_body(mdoc));
+
 	return(1);
 }
 
 
 static int
-post_sh_body(struct mdoc *mdoc)
+post_sh_body(POST_ARGS)
 {
 	struct mdoc_node *n;
 
-	assert(MDOC_Sh == mdoc->last->tok);
-	assert(MDOC_BODY == mdoc->last->type);
 	if (SEC_NAME != mdoc->lastnamed)
 		return(1);
 
@@ -1137,8 +1141,8 @@ post_sh_body(struct mdoc *mdoc)
 	 */
 
 	if (NULL == (n = mdoc->last->child))
-		return(mdoc_warn(mdoc, WARN_COMPAT, "section NAME "
-					"should contain %s and %s", 
+		return(mdoc_warn(mdoc, WARN_SYNTAX, 
+					"section should have %s and %s",
 					mdoc_macronames[MDOC_Nm],
 					mdoc_macronames[MDOC_Nd]));
 
@@ -1147,9 +1151,8 @@ post_sh_body(struct mdoc *mdoc)
 			continue;
 		if (MDOC_TEXT == n->type)
 			continue;
-		if ( ! (mdoc_nwarn(mdoc, n, WARN_COMPAT, "section "
-					"NAME should contain %s as "
-					"initial body child", 
+		if ( ! (mdoc_nwarn(mdoc, n, WARN_SYNTAX, 
+					"section should have %s first",
 					mdoc_macronames[MDOC_Nm])))
 			return(0);
 	}
@@ -1157,76 +1160,47 @@ post_sh_body(struct mdoc *mdoc)
 	if (MDOC_ELEM == n->type && MDOC_Nd == n->tok)
 		return(1);
 
-	return(mdoc_warn(mdoc, WARN_COMPAT, "section NAME should "
-				"contain %s as the last child",
+	return(mdoc_warn(mdoc, WARN_SYNTAX, 
+				"section should have %s last",
 				mdoc_macronames[MDOC_Nd]));
 }
 
 
 static int
-post_sh_head(struct mdoc *mdoc)
+post_sh_head(POST_ARGS)
 {
 	char		  buf[64];
 	enum mdoc_sec	  sec;
 
 	assert(MDOC_Sh == mdoc->last->tok);
 
-	if ( ! xstrlcats(buf, mdoc->last->child, 64))
-		return(mdoc_err(mdoc, "macro parameters too long"));
+	if ( ! xstrlcats(buf, mdoc->last->child, sizeof(buf)))
+		return(mdoc_err(mdoc, "argument too long"));
 
 	sec = mdoc_atosec(buf);
 
 	if (SEC_BODY == mdoc->lastnamed && SEC_NAME != sec)
-		return(mdoc_err(mdoc, "section NAME must be first"));
+		return(mdoc_warn(mdoc, WARN_SYNTAX, 
+				"section NAME should be first"));
 	if (SEC_CUSTOM == sec)
 		return(1);
 	if (sec == mdoc->lastnamed)
-		return(mdoc_warn(mdoc, WARN_SYNTAX, "section repeated"));
+		return(mdoc_warn(mdoc, WARN_SYNTAX, 
+				"section repeated"));
 	if (sec < mdoc->lastnamed)
-		return(mdoc_warn(mdoc, WARN_SYNTAX, "section out of conventional order"));
+		return(mdoc_warn(mdoc, WARN_SYNTAX, 
+				"section out of order"));
 
 	return(1);
 }
 
 
-int
-mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *node)
+static int
+post_fd(POST_ARGS)
 {
-	v_pre		*p;
 
-	if (MDOC_TEXT == node->type)
+	if (SEC_SYNOPSIS == mdoc->last->sec)
 		return(1);
-	assert(MDOC_ROOT != node->type);
-
-	if (NULL == mdoc_valids[node->tok].pre)
-		return(1);
-	for (p = mdoc_valids[node->tok].pre; *p; p++)
-		if ( ! (*p)(mdoc, node)) 
-			return(0);
-	return(1);
+	return(mdoc_warn(mdoc, WARN_COMPAT, 
+			"suggested only in section SYNOPSIS"));
 }
-
-
-int
-mdoc_valid_post(struct mdoc *mdoc)
-{
-	v_post		*p;
-
-	if (MDOC_VALID & mdoc->last->flags)
-		return(1);
-	mdoc->last->flags |= MDOC_VALID;
-
-	if (MDOC_TEXT == mdoc->last->type)
-		return(1);
-	if (MDOC_ROOT == mdoc->last->type)
-		return(post_root(mdoc));
-
-	if (NULL == mdoc_valids[mdoc->last->tok].post)
-		return(1);
-	for (p = mdoc_valids[mdoc->last->tok].post; *p; p++)
-		if ( ! (*p)(mdoc)) 
-			return(0);
-
-	return(1);
-}
-