===================================================================
RCS file: /cvs/mandoc/mdoc_macro.c,v
retrieving revision 1.129
retrieving revision 1.150
diff -u -p -r1.129 -r1.150
--- mandoc/mdoc_macro.c	2014/01/21 10:26:53	1.129
+++ mandoc/mdoc_macro.c	2014/11/28 03:14:18	1.150
@@ -1,7 +1,7 @@
-/*	$Id: mdoc_macro.c,v 1.129 2014/01/21 10:26:53 schwarze Exp $ */
+/*	$Id: mdoc_macro.c,v 1.150 2014/11/28 03:14:18 schwarze Exp $ */
 /*
  * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
- * Copyright (c) 2010, 2012, 2013 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2010, 2012, 2013, 2014 Ingo Schwarze <schwarze@openbsd.org>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -15,10 +15,10 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
+#include <sys/types.h>
+
 #include <assert.h>
 #include <ctype.h>
 #include <stdlib.h>
@@ -40,33 +40,30 @@ enum	rew {	/* see rew_dohalt() */
 	REWIND_ERROR
 };
 
-static	int	  	blk_full(MACRO_PROT_ARGS);
-static	int	  	blk_exp_close(MACRO_PROT_ARGS);
-static	int	  	blk_part_exp(MACRO_PROT_ARGS);
-static	int	  	blk_part_imp(MACRO_PROT_ARGS);
-static	int	  	ctx_synopsis(MACRO_PROT_ARGS);
-static	int	  	in_line_eoln(MACRO_PROT_ARGS);
-static	int	  	in_line_argn(MACRO_PROT_ARGS);
-static	int	  	in_line(MACRO_PROT_ARGS);
-static	int	  	obsolete(MACRO_PROT_ARGS);
-static	int	  	phrase_ta(MACRO_PROT_ARGS);
+static	int		blk_full(MACRO_PROT_ARGS);
+static	int		blk_exp_close(MACRO_PROT_ARGS);
+static	int		blk_part_exp(MACRO_PROT_ARGS);
+static	int		blk_part_imp(MACRO_PROT_ARGS);
+static	int		ctx_synopsis(MACRO_PROT_ARGS);
+static	int		in_line_eoln(MACRO_PROT_ARGS);
+static	int		in_line_argn(MACRO_PROT_ARGS);
+static	int		in_line(MACRO_PROT_ARGS);
+static	int		phrase_ta(MACRO_PROT_ARGS);
 
-static	int		dword(struct mdoc *, int, int, const char *,
+static	void		dword(struct mdoc *, int, int, const char *,
 				 enum mdelim, int);
-static	int	  	append_delims(struct mdoc *, 
-				int, int *, char *);
+static	void		append_delims(struct mdoc *, int, int *, char *);
 static	enum mdoct	lookup(enum mdoct, const char *);
 static	enum mdoct	lookup_raw(const char *);
 static	int		make_pending(struct mdoc_node *, enum mdoct,
 				struct mdoc *, int, int);
-static	int	  	phrase(struct mdoc *, int, int, char *);
-static	enum mdoct 	rew_alt(enum mdoct);
-static	enum rew  	rew_dohalt(enum mdoct, enum mdoc_type, 
+static	int		phrase(struct mdoc *, int, int, char *);
+static	enum mdoct	rew_alt(enum mdoct);
+static	enum rew	rew_dohalt(enum mdoct, enum mdoc_type,
 				const struct mdoc_node *);
-static	int	  	rew_elem(struct mdoc *, enum mdoct);
-static	int	  	rew_last(struct mdoc *, 
-				const struct mdoc_node *);
-static	int	  	rew_sub(enum mdoc_type, struct mdoc *, 
+static	void		rew_elem(struct mdoc *, enum mdoct);
+static	void		rew_last(struct mdoc *, const struct mdoc_node *);
+static	void		rew_sub(enum mdoc_type, struct mdoc *,
 				enum mdoct, int, int);
 
 const	struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
@@ -104,7 +101,7 @@ const	struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
 	{ blk_full, MDOC_JOIN }, /* Nd */
 	{ ctx_synopsis, MDOC_CALLABLE | MDOC_PARSED }, /* Nm */
 	{ blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Op */
-	{ obsolete, 0 }, /* Ot */
+	{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ot */
 	{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Pa */
 	{ in_line_eoln, 0 }, /* Rv */
 	{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* St */
@@ -148,9 +145,8 @@ const	struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
 	{ blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Eo */
 	{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Fx */
 	{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ms */
+	{ in_line, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* No */
 	{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED |
-			MDOC_IGNDELIM | MDOC_JOIN }, /* No */
-	{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED |
 			MDOC_IGNDELIM | MDOC_JOIN }, /* Ns */
 	{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Nx */
 	{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Ox */
@@ -173,7 +169,7 @@ const	struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
 	{ blk_part_exp, MDOC_CALLABLE | MDOC_PARSED |
 			MDOC_EXPLICIT | MDOC_JOIN }, /* So */
 	{ blk_part_imp, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Sq */
-	{ in_line_eoln, 0 }, /* Sm */
+	{ in_line_argn, 0 }, /* Sm */
 	{ in_line, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Sx */
 	{ in_line, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Sy */
 	{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Tn */
@@ -191,7 +187,7 @@ const	struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
 	{ blk_exp_close, MDOC_EXPLICIT | MDOC_JOIN }, /* Ek */
 	{ in_line_eoln, 0 }, /* Bt */
 	{ in_line_eoln, 0 }, /* Hf */
-	{ obsolete, 0 }, /* Fr */
+	{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Fr */
 	{ in_line_eoln, 0 }, /* Ud */
 	{ in_line, 0 }, /* Lb */
 	{ in_line_eoln, 0 }, /* Lp */
@@ -203,14 +199,15 @@ const	struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
 	{ blk_exp_close, MDOC_CALLABLE | MDOC_PARSED |
 			 MDOC_EXPLICIT | MDOC_JOIN }, /* Brc */
 	{ in_line_eoln, MDOC_JOIN }, /* %C */
-	{ obsolete, 0 }, /* Es */
-	{ obsolete, 0 }, /* En */
+	{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Es */
+	{ blk_part_imp, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* En */
 	{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Dx */
 	{ in_line_eoln, MDOC_JOIN }, /* %Q */
 	{ in_line_eoln, 0 }, /* br */
 	{ in_line_eoln, 0 }, /* sp */
 	{ in_line_eoln, 0 }, /* %U */
 	{ phrase_ta, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Ta */
+	{ in_line_eoln, MDOC_PROLOGUE }, /* ll */
 };
 
 const	struct mdoc_macro * const mdoc_macros = __mdoc_macros;
@@ -229,19 +226,20 @@ mdoc_macroend(struct mdoc *mdoc)
 	/* Scan for open explicit scopes. */
 
 	n = MDOC_VALID & mdoc->last->flags ?
-			mdoc->last->parent : mdoc->last;
+	    mdoc->last->parent : mdoc->last;
 
 	for ( ; n; n = n->parent)
 		if (MDOC_BLOCK == n->type &&
 		    MDOC_EXPLICIT & mdoc_macros[n->tok].flags)
-			mdoc_nmsg(mdoc, n, MANDOCERR_SCOPEEXIT);
+			mandoc_msg(MANDOCERR_BLK_NOEND, mdoc->parse,
+			    n->line, n->pos, mdoc_macronames[n->tok]);
 
 	/* Rewind to the first. */
 
-	return(rew_last(mdoc, mdoc->first));
+	rew_last(mdoc, mdoc->first);
+	return(1);
 }
 
-
 /*
  * Look up a macro from within a subsequent context.
  */
@@ -254,7 +252,6 @@ lookup(enum mdoct from, const char *p)
 	return(lookup_raw(p));
 }
 
-
 /*
  * Lookup a macro following the initial line macro.
  */
@@ -270,16 +267,13 @@ lookup_raw(const char *p)
 	return(MDOC_MAX);
 }
 
-
-static int
+static void
 rew_last(struct mdoc *mdoc, const struct mdoc_node *to)
 {
 	struct mdoc_node *n, *np;
 
 	assert(to);
 	mdoc->next = MDOC_NEXT_SIBLING;
-
-	/* LINTED */
 	while (mdoc->last != to) {
 		/*
 		 * Save the parent here, because we may delete the
@@ -288,18 +282,15 @@ rew_last(struct mdoc *mdoc, const struct mdoc_node *to
 		 * out to be lost.
 		 */
 		np = mdoc->last->parent;
-		if ( ! mdoc_valid_post(mdoc))
-			return(0);
+		mdoc_valid_post(mdoc);
 		n = mdoc->last;
 		mdoc->last = np;
 		assert(mdoc->last);
 		mdoc->last->last = n;
 	}
-
-	return(mdoc_valid_post(mdoc));
+	mdoc_valid_post(mdoc);
 }
 
-
 /*
  * For a block closing macro, return the corresponding opening one.
  * Otherwise, return the macro itself.
@@ -308,37 +299,37 @@ static enum mdoct
 rew_alt(enum mdoct tok)
 {
 	switch (tok) {
-	case (MDOC_Ac):
+	case MDOC_Ac:
 		return(MDOC_Ao);
-	case (MDOC_Bc):
+	case MDOC_Bc:
 		return(MDOC_Bo);
-	case (MDOC_Brc):
+	case MDOC_Brc:
 		return(MDOC_Bro);
-	case (MDOC_Dc):
+	case MDOC_Dc:
 		return(MDOC_Do);
-	case (MDOC_Ec):
+	case MDOC_Ec:
 		return(MDOC_Eo);
-	case (MDOC_Ed):
+	case MDOC_Ed:
 		return(MDOC_Bd);
-	case (MDOC_Ef):
+	case MDOC_Ef:
 		return(MDOC_Bf);
-	case (MDOC_Ek):
+	case MDOC_Ek:
 		return(MDOC_Bk);
-	case (MDOC_El):
+	case MDOC_El:
 		return(MDOC_Bl);
-	case (MDOC_Fc):
+	case MDOC_Fc:
 		return(MDOC_Fo);
-	case (MDOC_Oc):
+	case MDOC_Oc:
 		return(MDOC_Oo);
-	case (MDOC_Pc):
+	case MDOC_Pc:
 		return(MDOC_Po);
-	case (MDOC_Qc):
+	case MDOC_Qc:
 		return(MDOC_Qo);
-	case (MDOC_Re):
+	case MDOC_Re:
 		return(MDOC_Rs);
-	case (MDOC_Sc):
+	case MDOC_Sc:
 		return(MDOC_So);
-	case (MDOC_Xc):
+	case MDOC_Xc:
 		return(MDOC_Xo);
 	default:
 		return(tok);
@@ -346,7 +337,6 @@ rew_alt(enum mdoct tok)
 	/* NOTREACHED */
 }
 
-
 /*
  * Rewinding to tok, how do we have to handle *p?
  * REWIND_NONE: *p would delimit tok, but no tok scope is open
@@ -358,7 +348,7 @@ rew_alt(enum mdoct tok)
  * REWIND_ERROR: No tok block is open at all.
  */
 static enum rew
-rew_dohalt(enum mdoct tok, enum mdoc_type type, 
+rew_dohalt(enum mdoct tok, enum mdoc_type type,
 		const struct mdoc_node *p)
 {
 
@@ -374,7 +364,7 @@ rew_dohalt(enum mdoct tok, enum mdoc_type type, 
 		    REWIND_ERROR : REWIND_NONE);
 
 	/*
-	 * When starting to rewind, skip plain text 
+	 * When starting to rewind, skip plain text
 	 * and nodes that have already been rewound.
 	 */
 	if (MDOC_TEXT == p->type || MDOC_VALID & p->flags)
@@ -398,14 +388,14 @@ rew_dohalt(enum mdoct tok, enum mdoc_type type, 
 
 	/*
 	 * Blocks delimited by our target token get REWIND_MORE.
-	 * Blocks delimiting our target token get REWIND_NONE. 
+	 * Blocks delimiting our target token get REWIND_NONE.
 	 */
 	switch (tok) {
-	case (MDOC_Bl):
+	case MDOC_Bl:
 		if (MDOC_It == p->tok)
 			return(REWIND_MORE);
 		break;
-	case (MDOC_It):
+	case MDOC_It:
 		if (MDOC_BODY == p->type && MDOC_Bl == p->tok)
 			return(REWIND_NONE);
 		break;
@@ -415,19 +405,21 @@ rew_dohalt(enum mdoct tok, enum mdoc_type type, 
 	 * This is an incomplete and extremely ugly workaround,
 	 * required to let the OpenBSD tree build.
 	 */
-	case (MDOC_Oo):
+	case MDOC_Oo:
 		if (MDOC_Op == p->tok)
 			return(REWIND_MORE);
 		break;
-	case (MDOC_Nm):
+	case MDOC_Nm:
 		return(REWIND_NONE);
-	case (MDOC_Nd):
+	case MDOC_Nd:
 		/* FALLTHROUGH */
-	case (MDOC_Ss):
+	case MDOC_Ss:
 		if (MDOC_BODY == p->type && MDOC_Sh == p->tok)
 			return(REWIND_NONE);
 		/* FALLTHROUGH */
-	case (MDOC_Sh):
+	case MDOC_Sh:
+		if (MDOC_ROOT == p->parent->type)
+			return(REWIND_THIS);
 		if (MDOC_Nd == p->tok || MDOC_Ss == p->tok ||
 		    MDOC_Sh == p->tok)
 			return(REWIND_MORE);
@@ -440,9 +432,11 @@ rew_dohalt(enum mdoct tok, enum mdoc_type type, 
 	 * Default block rewinding rules.
 	 * In particular, always skip block end markers,
 	 * and let all blocks rewind Nm children.
+	 * Do not warn again when closing a block,
+	 * since closing the body already warned.
 	 */
 	if (ENDBODY_NOT != p->end || MDOC_Nm == p->tok ||
-	    (MDOC_BLOCK == p->type &&
+	    MDOC_BLOCK == type || (MDOC_BLOCK == p->type &&
 	    ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)))
 		return(REWIND_MORE);
 
@@ -456,8 +450,7 @@ rew_dohalt(enum mdoct tok, enum mdoc_type type, 
 	    REWIND_FORCE : REWIND_LATER);
 }
 
-
-static int
+static void
 rew_elem(struct mdoc *mdoc, enum mdoct tok)
 {
 	struct mdoc_node *n;
@@ -467,11 +460,9 @@ rew_elem(struct mdoc *mdoc, enum mdoct tok)
 		n = n->parent;
 	assert(MDOC_ELEM == n->type);
 	assert(tok == n->tok);
-
-	return(rew_last(mdoc, n));
+	rew_last(mdoc, n);
 }
 
-
 /*
  * We are trying to close a block identified by tok,
  * but the child block *broken is still open.
@@ -535,9 +526,9 @@ make_pending(struct mdoc_node *broken, enum mdoct tok,
 			taker->pending = broken->pending;
 		}
 		broken->pending = breaker;
-		mandoc_vmsg(MANDOCERR_SCOPENEST, mdoc->parse, line, ppos,
-				"%s breaks %s", mdoc_macronames[tok],
-				mdoc_macronames[broken->tok]);
+		mandoc_vmsg(MANDOCERR_BLK_NEST, mdoc->parse, line, ppos,
+		    "%s breaks %s", mdoc_macronames[tok],
+		    mdoc_macronames[broken->tok]);
 		return(1);
 	}
 
@@ -548,9 +539,8 @@ make_pending(struct mdoc_node *broken, enum mdoct tok,
 	return(0);
 }
 
-
-static int
-rew_sub(enum mdoc_type t, struct mdoc *mdoc, 
+static void
+rew_sub(enum mdoc_type t, struct mdoc *mdoc,
 		enum mdoct tok, int line, int ppos)
 {
 	struct mdoc_node *n;
@@ -558,118 +548,104 @@ rew_sub(enum mdoc_type t, struct mdoc *mdoc, 
 	n = mdoc->last;
 	while (n) {
 		switch (rew_dohalt(tok, t, n)) {
-		case (REWIND_NONE):
-			return(1);
-		case (REWIND_THIS):
+		case REWIND_NONE:
+			return;
+		case REWIND_THIS:
 			n->lastline = line -
-			    (MDOC_NEWLINE & mdoc->flags &&
-			     ! (MDOC_EXPLICIT & mdoc_macros[tok].flags));
+			    (mdoc->flags & MDOC_NEWLINE &&
+			     ! (mdoc_macros[tok].flags & MDOC_EXPLICIT));
 			break;
-		case (REWIND_FORCE):
-			mandoc_vmsg(MANDOCERR_SCOPEBROKEN, mdoc->parse, 
-					line, ppos, "%s breaks %s", 
-					mdoc_macronames[tok],
-					mdoc_macronames[n->tok]);
+		case REWIND_FORCE:
+			mandoc_vmsg(MANDOCERR_BLK_BROKEN, mdoc->parse,
+			    line, ppos, "%s breaks %s",
+			    mdoc_macronames[tok],
+			    mdoc_macronames[n->tok]);
 			/* FALLTHROUGH */
-		case (REWIND_MORE):
+		case REWIND_MORE:
 			n->lastline = line -
-			    (MDOC_NEWLINE & mdoc->flags ? 1 : 0);
+			    (mdoc->flags & MDOC_NEWLINE ? 1 : 0);
 			n = n->parent;
 			continue;
-		case (REWIND_LATER):
+		case REWIND_LATER:
 			if (make_pending(n, tok, mdoc, line, ppos) ||
-			    MDOC_BLOCK != t)
-				return(1);
+			    t != MDOC_BLOCK)
+				return;
 			/* FALLTHROUGH */
-		case (REWIND_ERROR):
-			mdoc_pmsg(mdoc, line, ppos, MANDOCERR_NOSCOPE);
-			return(1);
+		case REWIND_ERROR:
+			mandoc_msg(MANDOCERR_BLK_NOTOPEN,
+			    mdoc->parse, line, ppos,
+			    mdoc_macronames[tok]);
+			return;
 		}
 		break;
 	}
-
 	assert(n);
-	if ( ! rew_last(mdoc, n))
-		return(0);
+	rew_last(mdoc, n);
 
 	/*
 	 * The current block extends an enclosing block.
 	 * Now that the current block ends, close the enclosing block, too.
 	 */
-	while (NULL != (n = n->pending)) {
-		if ( ! rew_last(mdoc, n))
-			return(0);
-		if (MDOC_HEAD == n->type &&
-		    ! mdoc_body_alloc(mdoc, n->line, n->pos, n->tok))
-			return(0);
+	while ((n = n->pending) != NULL) {
+		rew_last(mdoc, n);
+		if (n->type == MDOC_HEAD)
+			mdoc_body_alloc(mdoc, n->line, n->pos, n->tok);
 	}
-
-	return(1);
 }
 
 /*
  * Allocate a word and check whether it's punctuation or not.
  * Punctuation consists of those tokens found in mdoc_isdelim().
  */
-static int
+static void
 dword(struct mdoc *mdoc, int line, int col, const char *p,
 		enum mdelim d, int may_append)
 {
-	
-	if (DELIM_MAX == d)
+
+	if (d == DELIM_MAX)
 		d = mdoc_isdelim(p);
 
 	if (may_append &&
-	    ! ((MDOC_SYNOPSIS | MDOC_KEEP | MDOC_SMOFF) & mdoc->flags) &&
-	    DELIM_NONE == d && MDOC_TEXT == mdoc->last->type &&
-	    DELIM_NONE == mdoc_isdelim(mdoc->last->string)) {
+	    ! (mdoc->flags & (MDOC_SYNOPSIS | MDOC_KEEP | MDOC_SMOFF)) &&
+	    d == DELIM_NONE && mdoc->last->type == MDOC_TEXT &&
+	    mdoc_isdelim(mdoc->last->string) == DELIM_NONE) {
 		mdoc_word_append(mdoc, p);
-		return(1);
+		return;
 	}
 
-	if ( ! mdoc_word_alloc(mdoc, line, col, p))
-		return(0);
+	mdoc_word_alloc(mdoc, line, col, p);
 
-	if (DELIM_OPEN == d)
-		mdoc->last->flags |= MDOC_DELIMO;
-
 	/*
-	 * Closing delimiters only suppress the preceding space
-	 * when they follow something, not when they start a new
-	 * block or element, and not when they follow `No'.
-	 *
-	 * XXX	Explicitly special-casing MDOC_No here feels
-	 *	like a layering violation.  Find a better way
-	 *	and solve this in the code related to `No'!
+	 * If the word consists of a bare delimiter,
+	 * flag the new node accordingly,
+	 * unless doing so was vetoed by the invoking macro.
+	 * Always clear the veto, it is only valid for one word.
 	 */
 
-	else if (DELIM_CLOSE == d && mdoc->last->prev &&
-			mdoc->last->prev->tok != MDOC_No &&
-			mdoc->last->parent->tok != MDOC_Fd)
+	if (d == DELIM_OPEN)
+		mdoc->last->flags |= MDOC_DELIMO;
+	else if (d == DELIM_CLOSE &&
+	    ! (mdoc->flags & MDOC_NODELIMC) &&
+	    mdoc->last->parent->tok != MDOC_Fd)
 		mdoc->last->flags |= MDOC_DELIMC;
-
-	return(1);
+	mdoc->flags &= ~MDOC_NODELIMC;
 }
 
-static int
+static void
 append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)
 {
 	int		 la;
 	enum margserr	 ac;
 	char		*p;
 
-	if ('\0' == buf[*pos])
-		return(1);
+	if (buf[*pos] == '\0')
+		return;
 
 	for (;;) {
 		la = *pos;
 		ac = mdoc_zargs(mdoc, line, pos, buf, &p);
-
-		if (ARGS_ERROR == ac)
-			return(0);
-		else if (ARGS_EOLN == ac)
+		if (ac == ARGS_EOLN)
 			break;
-
 		dword(mdoc, line, la, p, DELIM_MAX, 1);
 
 		/*
@@ -683,25 +659,24 @@ append_delims(struct mdoc *mdoc, int line, int *pos, c
 		 * knowing which symbols break this behaviour, for
 		 * example, `.  ;' shouldn't propagate the double-space.
 		 */
+
 		if (mandoc_eos(p, strlen(p)))
 			mdoc->last->flags |= MDOC_EOS;
 	}
-
-	return(1);
 }
 
-
 /*
- * Close out block partial/full explicit.  
+ * Close out block partial/full explicit.
  */
 static int
 blk_exp_close(MACRO_PROT_ARGS)
 {
 	struct mdoc_node *body;		/* Our own body. */
+	struct mdoc_node *endbody;	/* Our own end marker. */
 	struct mdoc_node *later;	/* A sub-block starting later. */
 	struct mdoc_node *n;		/* For searching backwards. */
 
-	int	 	 j, lastarg, maxargs, flushed, nl;
+	int		 j, lastarg, maxargs, flushed, nl;
 	enum margserr	 ac;
 	enum mdoct	 atok, ntok;
 	char		*p;
@@ -709,10 +684,10 @@ blk_exp_close(MACRO_PROT_ARGS)
 	nl = MDOC_NEWLINE & mdoc->flags;
 
 	switch (tok) {
-	case (MDOC_Ec):
+	case MDOC_Ec:
 		maxargs = 1;
 		break;
-	case (MDOC_Ek):
+	case MDOC_Ek:
 		mdoc->flags &= ~MDOC_KEEP;
 	default:
 		maxargs = 0;
@@ -724,19 +699,19 @@ blk_exp_close(MACRO_PROT_ARGS)
 	 * both of our own and of pending sub-blocks.
 	 */
 	atok = rew_alt(tok);
-	body = later = NULL;
+	body = endbody = later = NULL;
 	for (n = mdoc->last; n; n = n->parent) {
-		if (MDOC_VALID & n->flags)
+		if (n->flags & MDOC_VALID)
 			continue;
 
 		/* Remember the start of our own body. */
-		if (MDOC_BODY == n->type && atok == n->tok) {
-			if (ENDBODY_NOT == n->end)
+		if (n->type == MDOC_BODY && atok == n->tok) {
+			if (n->end == ENDBODY_NOT)
 				body = n;
 			continue;
 		}
 
-		if (MDOC_BLOCK != n->type || MDOC_Nm == n->tok)
+		if (n->type != MDOC_BLOCK || n->tok == MDOC_Nm)
 			continue;
 		if (atok == n->tok) {
 			assert(body);
@@ -746,10 +721,10 @@ blk_exp_close(MACRO_PROT_ARGS)
 			 * When there is no pending sub block,
 			 * just proceed to closing out.
 			 */
-			if (NULL == later)
+			if (later == NULL)
 				break;
 
-			/* 
+			/*
 			 * When there is a pending sub block,
 			 * postpone closing out the current block
 			 * until the rew_sub() closing out the sub-block.
@@ -760,9 +735,12 @@ blk_exp_close(MACRO_PROT_ARGS)
 			 * Mark the place where the formatting - but not
 			 * the scope - of the current block ends.
 			 */
-			if ( ! mdoc_endbody_alloc(mdoc, line, ppos,
-			    atok, body, ENDBODY_SPACE))
-				return(0);
+			mdoc_endbody_alloc(mdoc, line, ppos,
+			    atok, body, ENDBODY_SPACE);
+			if (maxargs) {
+				endbody = mdoc->last;
+				mdoc->next = MDOC_NEXT_CHILD;
+			}
 			break;
 		}
 
@@ -772,59 +750,65 @@ blk_exp_close(MACRO_PROT_ARGS)
 		 * implicit ones, the first open implicit block.
 		 */
 		if (later &&
-		    MDOC_EXPLICIT & mdoc_macros[later->tok].flags)
+		    mdoc_macros[later->tok].flags & MDOC_EXPLICIT)
 			continue;
-		if (MDOC_It != n->tok)
+		if (n->tok != MDOC_It)
 			later = n;
 	}
 
-	if ( ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) {
-		/* FIXME: do this in validate */
-		if (buf[*pos]) 
-			mdoc_pmsg(mdoc, line, ppos, MANDOCERR_ARGSLOST);
+	if ( ! (mdoc_macros[tok].flags & MDOC_PARSED)) {
+		if (buf[*pos] != '\0')
+			mandoc_vmsg(MANDOCERR_ARG_SKIP,
+			    mdoc->parse, line, ppos,
+			    "%s %s", mdoc_macronames[tok],
+			    buf + *pos);
+		rew_sub(MDOC_BODY, mdoc, tok, line, ppos);
+		rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);
+		return(1);
+	}
+	rew_sub(MDOC_BODY, mdoc, tok, line, ppos);
 
-		if ( ! rew_sub(MDOC_BODY, mdoc, tok, line, ppos))
-			return(0);
-		return(rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos));
+	if (maxargs && endbody == NULL) {
+		if (n == NULL) {
+			/*
+			 * Stray .Ec without previous .Eo:
+			 * Break the output line, ignore any arguments.
+			 */
+			mdoc_elem_alloc(mdoc, line, ppos, MDOC_br, NULL);
+			rew_elem(mdoc, MDOC_br);
+		} else
+			mdoc_tail_alloc(mdoc, line, ppos, atok);
 	}
 
-	if ( ! rew_sub(MDOC_BODY, mdoc, tok, line, ppos))
-		return(0);
-
-	if (NULL == later && maxargs > 0) 
-		if ( ! mdoc_tail_alloc(mdoc, line, ppos, rew_alt(tok)))
-			return(0);
-
-	for (flushed = j = 0; ; j++) {
+	flushed = n == NULL;
+	for (j = 0; ; j++) {
 		lastarg = *pos;
 
 		if (j == maxargs && ! flushed) {
-			if ( ! rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos))
-				return(0);
+			if (endbody == NULL)
+				rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);
+			else
+				rew_last(mdoc, endbody);
 			flushed = 1;
 		}
 
 		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
-
-		if (ARGS_ERROR == ac)
-			return(0);
-		if (ARGS_PUNCT == ac)
+		if (ac == ARGS_PUNCT || ac == ARGS_EOLN)
 			break;
-		if (ARGS_EOLN == ac)
-			break;
 
-		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
+		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);
 
-		if (MDOC_MAX == ntok) {
-			if ( ! dword(mdoc, line, lastarg, p, DELIM_MAX,
-			    MDOC_JOIN & mdoc_macros[tok].flags))
-				return(0);
+		if (ntok == MDOC_MAX) {
+			dword(mdoc, line, lastarg, p, DELIM_MAX,
+			    MDOC_JOIN & mdoc_macros[tok].flags);
 			continue;
 		}
 
 		if ( ! flushed) {
-			if ( ! rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos))
-				return(0);
+			if (endbody == NULL)
+				rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);
+			else
+				rew_last(mdoc, endbody);
 			flushed = 1;
 		}
 
@@ -835,19 +819,21 @@ blk_exp_close(MACRO_PROT_ARGS)
 		break;
 	}
 
-	if ( ! flushed && ! rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos))
-		return(0);
-
-	if ( ! nl)
-		return(1);
-	return(append_delims(mdoc, line, pos, buf));
+	if ( ! flushed) {
+		if (endbody == NULL)
+			rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);
+		else
+			rew_last(mdoc, endbody);
+	}
+	if (nl)
+		append_delims(mdoc, line, pos, buf);
+	return(1);
 }
 
-
 static int
 in_line(MACRO_PROT_ARGS)
 {
-	int		 la, scope, cnt, nc, nl;
+	int		 la, scope, cnt, firstarg, mayopen, nc, nl;
 	enum margverr	 av;
 	enum mdoct	 ntok;
 	enum margserr	 ac;
@@ -863,17 +849,17 @@ in_line(MACRO_PROT_ARGS)
 	 */
 
 	switch (tok) {
-	case (MDOC_An):
+	case MDOC_An:
 		/* FALLTHROUGH */
-	case (MDOC_Ar):
+	case MDOC_Ar:
 		/* FALLTHROUGH */
-	case (MDOC_Fl):
+	case MDOC_Fl:
 		/* FALLTHROUGH */
-	case (MDOC_Mt):
+	case MDOC_Mt:
 		/* FALLTHROUGH */
-	case (MDOC_Nm):
+	case MDOC_Nm:
 		/* FALLTHROUGH */
-	case (MDOC_Pa):
+	case MDOC_Pa:
 		nc = 1;
 		break;
 	default:
@@ -888,7 +874,7 @@ in_line(MACRO_PROT_ARGS)
 		if (ARGV_WORD == av) {
 			*pos = la;
 			break;
-		} 
+		}
 		if (ARGV_EOLN == av)
 			break;
 		if (ARGV_ARG == av)
@@ -898,109 +884,132 @@ in_line(MACRO_PROT_ARGS)
 		return(0);
 	}
 
+	d = DELIM_NONE;
+	firstarg = 1;
+	mayopen = 1;
 	for (cnt = scope = 0;; ) {
 		la = *pos;
 		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
 
-		if (ARGS_ERROR == ac)
-			return(0);
-		if (ARGS_EOLN == ac)
+		/*
+		 * At the end of a macro line,
+		 * opening delimiters do not suppress spacing.
+		 */
+
+		if (ac == ARGS_EOLN) {
+			if (d == DELIM_OPEN)
+				mdoc->last->flags &= ~MDOC_DELIMO;
 			break;
-		if (ARGS_PUNCT == ac)
+		}
+
+		/*
+		 * The rest of the macro line is only punctuation,
+		 * to be handled by append_delims().
+		 * If there were no other arguments,
+		 * do not allow the first one to suppress spacing,
+		 * even if it turns out to be a closing one.
+		 */
+
+		if (ac == ARGS_PUNCT) {
+			if (cnt == 0 && nc == 0)
+				mdoc->flags |= MDOC_NODELIMC;
 			break;
+		}
 
-		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
+		ntok = (ac == ARGS_QWORD || (tok == MDOC_Fn && !cnt)) ?
+		    MDOC_MAX : lookup(tok, p);
 
-		/* 
+		/*
 		 * In this case, we've located a submacro and must
 		 * execute it.  Close out scope, if open.  If no
 		 * elements have been generated, either create one (nc)
 		 * or raise a warning.
 		 */
 
-		if (MDOC_MAX != ntok) {
-			if (scope && ! rew_elem(mdoc, tok))
-				return(0);
-			if (nc && 0 == cnt) {
-				if ( ! mdoc_elem_alloc(mdoc, line,
-						ppos, tok, arg))
-					return(0);
-				if ( ! rew_last(mdoc, mdoc->last))
-					return(0);
-			} else if ( ! nc && 0 == cnt) {
+		if (ntok != MDOC_MAX) {
+			if (scope)
+				rew_elem(mdoc, tok);
+			if (nc && ! cnt) {
+				mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
+				rew_last(mdoc, mdoc->last);
+			} else if ( ! nc && ! cnt) {
 				mdoc_argv_free(arg);
-				mdoc_pmsg(mdoc, line, ppos,
-					MANDOCERR_MACROEMPTY);
+				mandoc_msg(MANDOCERR_MACRO_EMPTY,
+				    mdoc->parse, line, ppos,
+				    mdoc_macronames[tok]);
 			}
 
 			if ( ! mdoc_macro(mdoc, ntok, line, la, pos, buf))
 				return(0);
-			if ( ! nl)
-				return(1);
-			return(append_delims(mdoc, line, pos, buf));
-		} 
+			if (nl)
+				append_delims(mdoc, line, pos, buf);
+			return(1);
+		}
 
-		/* 
+		/*
 		 * Non-quote-enclosed punctuation.  Set up our scope, if
 		 * a word; rewind the scope, if a delimiter; then append
-		 * the word. 
+		 * the word.
 		 */
 
-		d = ARGS_QWORD == ac ? DELIM_NONE : mdoc_isdelim(p);
+		d = ac == ARGS_QWORD ? DELIM_NONE : mdoc_isdelim(p);
 
 		if (DELIM_NONE != d) {
 			/*
 			 * If we encounter closing punctuation, no word
-			 * has been omitted, no scope is open, and we're
+			 * has been emitted, no scope is open, and we're
 			 * allowed to have an empty element, then start
-			 * a new scope.  `Ar', `Fl', and `Li', only do
-			 * this once per invocation.  There may be more
-			 * of these (all of them?).
+			 * a new scope.
 			 */
-			if (0 == cnt && (nc || MDOC_Li == tok) && 
-					DELIM_CLOSE == d && ! scope) {
-				if ( ! mdoc_elem_alloc(mdoc, line,
-						ppos, tok, arg))
-					return(0);
-				if (MDOC_Ar == tok || MDOC_Li == tok || 
-						MDOC_Fl == tok)
-					cnt++;
+			if ((d == DELIM_CLOSE ||
+			     (d == DELIM_MIDDLE && tok == MDOC_Fl)) &&
+			    !cnt && !scope && nc && mayopen) {
+				mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
 				scope = 1;
+				cnt++;
+				if (tok == MDOC_Nm)
+					mayopen = 0;
 			}
 			/*
 			 * Close out our scope, if one is open, before
 			 * any punctuation.
 			 */
-			if (scope && ! rew_elem(mdoc, tok))
-				return(0);
+			if (scope)
+				rew_elem(mdoc, tok);
 			scope = 0;
-		} else if ( ! scope) {
-			if ( ! mdoc_elem_alloc(mdoc, line, ppos, tok, arg))
-				return(0);
+			if (tok == MDOC_Fn)
+				mayopen = 0;
+		} else if (mayopen && !scope) {
+			mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
 			scope = 1;
+			cnt++;
 		}
 
-		if (DELIM_NONE == d)
-			cnt++;
+		dword(mdoc, line, la, p, d,
+		    MDOC_JOIN & mdoc_macros[tok].flags);
 
-		if ( ! dword(mdoc, line, la, p, d,
-		    MDOC_JOIN & mdoc_macros[tok].flags))
-			return(0);
+		/*
+		 * If the first argument is a closing delimiter,
+		 * do not suppress spacing before it.
+		 */
 
+		if (firstarg && d == DELIM_CLOSE && !nc)
+			mdoc->last->flags &= ~MDOC_DELIMC;
+		firstarg = 0;
+
 		/*
 		 * `Fl' macros have their scope re-opened with each new
 		 * word so that the `-' can be added to each one without
 		 * having to parse out spaces.
 		 */
-		if (scope && MDOC_Fl == tok) {
-			if ( ! rew_elem(mdoc, tok))
-				return(0);
+		if (scope && tok == MDOC_Fl) {
+			rew_elem(mdoc, tok);
 			scope = 0;
 		}
 	}
 
-	if (scope && ! rew_elem(mdoc, tok))
-		return(0);
+	if (scope)
+		rew_elem(mdoc, tok);
 
 	/*
 	 * If no elements have been collected and we're allowed to have
@@ -1008,22 +1017,21 @@ in_line(MACRO_PROT_ARGS)
 	 * raise a warning.
 	 */
 
-	if (nc && 0 == cnt) {
-		if ( ! mdoc_elem_alloc(mdoc, line, ppos, tok, arg))
-			return(0);
-		if ( ! rew_last(mdoc, mdoc->last))
-			return(0);
-	} else if ( ! nc && 0 == cnt) {
-		mdoc_argv_free(arg);
-		mdoc_pmsg(mdoc, line, ppos, MANDOCERR_MACROEMPTY);
+	if ( ! cnt) {
+		if (nc) {
+			mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
+			rew_last(mdoc, mdoc->last);
+		} else {
+			mdoc_argv_free(arg);
+			mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
+			    line, ppos, mdoc_macronames[tok]);
+		}
 	}
-
-	if ( ! nl)
-		return(1);
-	return(append_delims(mdoc, line, pos, buf));
+	if (nl)
+		append_delims(mdoc, line, pos, buf);
+	return(1);
 }
 
-
 static int
 blk_full(MACRO_PROT_ARGS)
 {
@@ -1032,7 +1040,6 @@ blk_full(MACRO_PROT_ARGS)
 	struct mdoc_node *head; /* save of head macro */
 	struct mdoc_node *body; /* save of body macro */
 	struct mdoc_node *n;
-	enum mdoc_type	  mtt;
 	enum mdoct	  ntok;
 	enum margserr	  ac, lac;
 	enum margverr	  av;
@@ -1040,13 +1047,27 @@ blk_full(MACRO_PROT_ARGS)
 
 	nl = MDOC_NEWLINE & mdoc->flags;
 
+	/* Skip items outside lists. */
+
+	if (tok == MDOC_It) {
+		for (n = mdoc->last; n; n = n->parent)
+			if (n->tok == MDOC_Bl &&
+			    ! (n->flags & MDOC_VALID))
+				break;
+		if (n == NULL) {
+			mandoc_vmsg(MANDOCERR_IT_STRAY, mdoc->parse,
+			    line, ppos, "It %s", buf + *pos);
+			mdoc_elem_alloc(mdoc, line, ppos, MDOC_br, NULL);
+			rew_elem(mdoc, MDOC_br);
+			return(1);
+		}
+	}
+
 	/* Close out prior implicit scope. */
 
-	if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)) {
-		if ( ! rew_sub(MDOC_BODY, mdoc, tok, line, ppos))
-			return(0);
-		if ( ! rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos))
-			return(0);
+	if ( ! (mdoc_macros[tok].flags & MDOC_EXPLICIT)) {
+		rew_sub(MDOC_BODY, mdoc, tok, line, ppos);
+		rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);
 	}
 
 	/*
@@ -1065,7 +1086,7 @@ blk_full(MACRO_PROT_ARGS)
 		if (ARGV_WORD == av) {
 			*pos = la;
 			break;
-		} 
+		}
 
 		if (ARGV_EOLN == av)
 			break;
@@ -1076,54 +1097,40 @@ blk_full(MACRO_PROT_ARGS)
 		return(0);
 	}
 
-	if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, arg))
-		return(0);
-
+	mdoc_block_alloc(mdoc, line, ppos, tok, arg);
 	head = body = NULL;
 
 	/*
 	 * Exception: Heads of `It' macros in `-diag' lists are not
 	 * parsed, even though `It' macros in general are parsed.
 	 */
-	nparsed = MDOC_It == tok &&
-		MDOC_Bl == mdoc->last->parent->tok &&
-		LIST_diag == mdoc->last->parent->norm->Bl.type;
+	nparsed = tok == MDOC_It &&
+	    mdoc->last->parent->tok == MDOC_Bl &&
+	    mdoc->last->parent->norm->Bl.type == LIST_diag;
 
 	/*
 	 * The `Nd' macro has all arguments in its body: it's a hybrid
 	 * of block partial-explicit and full-implicit.  Stupid.
 	 */
 
-	if (MDOC_Nd == tok) {
-		if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
-			return(0);
-		head = mdoc->last;
-		if ( ! rew_sub(MDOC_HEAD, mdoc, tok, line, ppos))
-			return(0);
-		if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
-			return(0);
-		body = mdoc->last;
+	if (tok == MDOC_Nd) {
+		head = mdoc_head_alloc(mdoc, line, ppos, tok);
+		rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);
+		body = mdoc_body_alloc(mdoc, line, ppos, tok);
 	}
 
-	if (MDOC_Bk == tok)
+	if (tok == MDOC_Bk)
 		mdoc->flags |= MDOC_KEEP;
 
-	ac = ARGS_ERROR;
-
-	for ( ; ; ) {
+	ac = ARGS_PEND;
+	for (;;) {
 		la = *pos;
-		/* Initialise last-phrase-type with ARGS_PEND. */
-		lac = ARGS_ERROR == ac ? ARGS_PEND : ac;
+		lac = ac;
 		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
-
-		if (ARGS_PUNCT == ac)
+		if (ac == ARGS_PUNCT)
 			break;
-
-		if (ARGS_ERROR == ac)
-			return(0);
-
-		if (ARGS_EOLN == ac) {
-			if (ARGS_PPHRASE != lac && ARGS_PHRASE != lac)
+		if (ac == ARGS_EOLN) {
+			if (lac != ARGS_PPHRASE && lac != ARGS_PHRASE)
 				break;
 			/*
 			 * This is necessary: if the last token on a
@@ -1132,55 +1139,45 @@ blk_full(MACRO_PROT_ARGS)
 			 * reopen our scope if the last parse was a
 			 * phrase or partial phrase.
 			 */
-			if ( ! rew_sub(MDOC_BODY, mdoc, tok, line, ppos))
-				return(0);
-			if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
-				return(0);
-			body = mdoc->last;
+			rew_sub(MDOC_BODY, mdoc, tok, line, ppos);
+			body = mdoc_body_alloc(mdoc, line, ppos, tok);
 			break;
 		}
 
-		/* 
+		/*
 		 * Emit leading punctuation (i.e., punctuation before
 		 * the MDOC_HEAD) for non-phrase types.
 		 */
 
-		if (NULL == head && 
-				ARGS_PEND != ac &&
-				ARGS_PHRASE != ac &&
-				ARGS_PPHRASE != ac &&
-				ARGS_QWORD != ac &&
-				DELIM_OPEN == mdoc_isdelim(p)) {
-			if ( ! dword(mdoc, line, la, p, DELIM_OPEN, 0))
-				return(0);
+		if (head == NULL &&
+		    ac != ARGS_PEND &&
+		    ac != ARGS_PHRASE &&
+		    ac != ARGS_PPHRASE &&
+		    ac != ARGS_QWORD &&
+		    mdoc_isdelim(p) == DELIM_OPEN) {
+			dword(mdoc, line, la, p, DELIM_OPEN, 0);
 			continue;
 		}
 
 		/* Open a head if one hasn't been opened. */
 
-		if (NULL == head) {
-			if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
-				return(0);
-			head = mdoc->last;
-		}
+		if (head == NULL)
+			head = mdoc_head_alloc(mdoc, line, ppos, tok);
 
-		if (ARGS_PHRASE == ac || 
-				ARGS_PEND == ac ||
-				ARGS_PPHRASE == ac) {
+		if (ac == ARGS_PHRASE ||
+		    ac == ARGS_PEND ||
+		    ac == ARGS_PPHRASE) {
 			/*
 			 * If we haven't opened a body yet, rewind the
 			 * head; if we have, rewind that instead.
 			 */
 
-			mtt = body ? MDOC_BODY : MDOC_HEAD;
-			if ( ! rew_sub(mtt, mdoc, tok, line, ppos))
-				return(0);
-			
+			rew_sub(body ? MDOC_BODY : MDOC_HEAD,
+			    mdoc, tok, line, ppos);
+
 			/* Then allocate our body context. */
 
-			if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
-				return(0);
-			body = mdoc->last;
+			body = mdoc_body_alloc(mdoc, line, ppos, tok);
 
 			/*
 			 * Process phrases: set whether we're in a
@@ -1188,9 +1185,9 @@ blk_full(MACRO_PROT_ARGS)
 			 * then call down into the phrase parser.
 			 */
 
-			if (ARGS_PPHRASE == ac)
+			if (ac == ARGS_PPHRASE)
 				mdoc->flags |= MDOC_PPHRASE;
-			if (ARGS_PEND == ac && ARGS_PPHRASE == lac)
+			if (ac == ARGS_PEND && lac == ARGS_PPHRASE)
 				mdoc->flags |= MDOC_PPHRASE;
 
 			if ( ! phrase(mdoc, line, la, buf))
@@ -1200,13 +1197,12 @@ blk_full(MACRO_PROT_ARGS)
 			continue;
 		}
 
-		ntok = nparsed || ARGS_QWORD == ac ? 
-			MDOC_MAX : lookup(tok, p);
+		ntok = nparsed || ac == ARGS_QWORD ?
+		    MDOC_MAX : lookup(tok, p);
 
-		if (MDOC_MAX == ntok) {
-			if ( ! dword(mdoc, line, la, p, DELIM_MAX,
-			    MDOC_JOIN & mdoc_macros[tok].flags))
-				return(0);
+		if (ntok == MDOC_MAX) {
+			dword(mdoc, line, la, p, DELIM_MAX,
+			    MDOC_JOIN & mdoc_macros[tok].flags);
 			continue;
 		}
 
@@ -1215,14 +1211,10 @@ blk_full(MACRO_PROT_ARGS)
 		break;
 	}
 
-	if (NULL == head) {
-		if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
-			return(0);
-		head = mdoc->last;
-	}
-	
-	if (nl && ! append_delims(mdoc, line, pos, buf))
-		return(0);
+	if (head == NULL)
+		head = mdoc_head_alloc(mdoc, line, ppos, tok);
+	if (nl)
+		append_delims(mdoc, line, pos, buf);
 
 	/* If we've already opened our body, exit now. */
 
@@ -1236,9 +1228,9 @@ blk_full(MACRO_PROT_ARGS)
 	 * sub-block.
 	 */
 	for (n = mdoc->last; n && n != head; n = n->parent) {
-		if (MDOC_BLOCK == n->type && 
-				MDOC_EXPLICIT & mdoc_macros[n->tok].flags &&
-				! (MDOC_VALID & n->flags)) {
+		if (MDOC_BLOCK == n->type &&
+		    MDOC_EXPLICIT & mdoc_macros[n->tok].flags &&
+		    ! (MDOC_VALID & n->flags)) {
 			n->pending = head;
 			return(1);
 		}
@@ -1246,25 +1238,18 @@ blk_full(MACRO_PROT_ARGS)
 
 	/* Close out scopes to remain in a consistent state. */
 
-	if ( ! rew_sub(MDOC_HEAD, mdoc, tok, line, ppos))
-		return(0);
-	if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
-		return(0);
+	rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);
+	mdoc_body_alloc(mdoc, line, ppos, tok);
 
 out:
-	if ( ! (MDOC_FREECOL & mdoc->flags))
-		return(1);
-
-	if ( ! rew_sub(MDOC_BODY, mdoc, tok, line, ppos))
-		return(0);
-	if ( ! rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos))
-		return(0);
-
-	mdoc->flags &= ~MDOC_FREECOL;
+	if (mdoc->flags & MDOC_FREECOL) {
+		rew_sub(MDOC_BODY, mdoc, tok, line, ppos);
+		rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);
+		mdoc->flags &= ~MDOC_FREECOL;
+	}
 	return(1);
 }
 
-
 static int
 blk_part_imp(MACRO_PROT_ARGS)
 {
@@ -1287,16 +1272,10 @@ blk_part_imp(MACRO_PROT_ARGS)
 	 * or more closing punctuation nodes.
 	 */
 
-	if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, NULL))
-		return(0);
+	blk = mdoc_block_alloc(mdoc, line, ppos, tok, NULL);
+	mdoc_head_alloc(mdoc, line, ppos, tok);
+	rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);
 
-	blk = mdoc->last;
-
-	if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
-		return(0);
-	if ( ! rew_sub(MDOC_HEAD, mdoc, tok, line, ppos))
-		return(0);
-
 	/*
 	 * Open the body scope "on-demand", that is, after we've
 	 * processed all our the leading delimiters (open parenthesis,
@@ -1306,33 +1285,23 @@ blk_part_imp(MACRO_PROT_ARGS)
 	for (body = NULL; ; ) {
 		la = *pos;
 		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
-
-		if (ARGS_ERROR == ac)
-			return(0);
-		if (ARGS_EOLN == ac)
+		if (ac == ARGS_EOLN || ac == ARGS_PUNCT)
 			break;
-		if (ARGS_PUNCT == ac)
-			break;
 
-		if (NULL == body && ARGS_QWORD != ac &&
-				DELIM_OPEN == mdoc_isdelim(p)) {
-			if ( ! dword(mdoc, line, la, p, DELIM_OPEN, 0))
-				return(0);
+		if (body == NULL && ac != ARGS_QWORD &&
+		    mdoc_isdelim(p) == DELIM_OPEN) {
+			dword(mdoc, line, la, p, DELIM_OPEN, 0);
 			continue;
 		}
 
-		if (NULL == body) {
-		       if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
-			       return(0);
-			body = mdoc->last;
-		}
+		if (body == NULL)
+			body = mdoc_body_alloc(mdoc, line, ppos, tok);
 
-		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
+		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);
 
-		if (MDOC_MAX == ntok) {
-			if ( ! dword(mdoc, line, la, p, DELIM_MAX,
-			    MDOC_JOIN & mdoc_macros[tok].flags))
-				return(0);
+		if (ntok == MDOC_MAX) {
+			dword(mdoc, line, la, p, DELIM_MAX,
+			    MDOC_JOIN & mdoc_macros[tok].flags);
 			continue;
 		}
 
@@ -1343,11 +1312,8 @@ blk_part_imp(MACRO_PROT_ARGS)
 
 	/* Clean-ups to leave in a consistent state. */
 
-	if (NULL == body) {
-		if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
-			return(0);
-		body = mdoc->last;
-	}
+	if (body == NULL)
+		body = mdoc_body_alloc(mdoc, line, ppos, tok);
 
 	/*
 	 * If there is an open sub-block requiring explicit close-out,
@@ -1355,52 +1321,38 @@ blk_part_imp(MACRO_PROT_ARGS)
 	 * until the rew_sub() call closing out the sub-block.
 	 */
 	for (n = mdoc->last; n && n != body && n != blk->parent;
-			n = n->parent) {
-		if (MDOC_BLOCK == n->type &&
-		    MDOC_EXPLICIT & mdoc_macros[n->tok].flags &&
-		    ! (MDOC_VALID & n->flags)) {
+	     n = n->parent) {
+		if (n->type == MDOC_BLOCK &&
+		    mdoc_macros[n->tok].flags & MDOC_EXPLICIT &&
+		    ! (n->flags & MDOC_VALID)) {
 			make_pending(n, tok, mdoc, line, ppos);
-			if ( ! mdoc_endbody_alloc(mdoc, line, ppos,
-			    tok, body, ENDBODY_NOSPACE))
-				return(0);
+			mdoc_endbody_alloc(mdoc, line, ppos,
+			    tok, body, ENDBODY_NOSPACE);
 			return(1);
 		}
 	}
+	assert(n == body);
+	rew_sub(MDOC_BODY, mdoc, tok, line, ppos);
 
-	/* 
-	 * If we can't rewind to our body, then our scope has already
-	 * been closed by another macro (like `Oc' closing `Op').  This
-	 * is ugly behaviour nodding its head to OpenBSD's overwhelming
-	 * crufty use of `Op' breakage.
-	 */
-	if (n != body)
-		mandoc_vmsg(MANDOCERR_SCOPENEST, mdoc->parse, line, ppos, 
-				"%s broken", mdoc_macronames[tok]);
-
-	if (n && ! rew_sub(MDOC_BODY, mdoc, tok, line, ppos))
-		return(0);
-
 	/* Standard appending of delimiters. */
 
-	if (nl && ! append_delims(mdoc, line, pos, buf))
-		return(0);
+	if (nl)
+		append_delims(mdoc, line, pos, buf);
 
 	/* Rewind scope, if applicable. */
 
-	if (n && ! rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos))
-		return(0);
+	rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);
 
 	/* Move trailing .Ns out of scope. */
 
 	for (n = body->child; n && n->next; n = n->next)
 		/* Do nothing. */ ;
-	if (n && MDOC_Ns == n->tok)
+	if (n && n->tok == MDOC_Ns)
 		mdoc_node_relink(mdoc, n);
 
 	return(1);
 }
 
-
 static int
 blk_part_exp(MACRO_PROT_ARGS)
 {
@@ -1419,35 +1371,25 @@ blk_part_exp(MACRO_PROT_ARGS)
 	 * case of `Eo'); and a body that may be empty.
 	 */
 
-	if ( ! mdoc_block_alloc(mdoc, line, ppos, tok, NULL))
-		return(0); 
-
+	mdoc_block_alloc(mdoc, line, ppos, tok, NULL);
 	for (head = body = NULL; ; ) {
 		la = *pos;
 		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
-
-		if (ARGS_ERROR == ac)
-			return(0);
-		if (ARGS_PUNCT == ac)
+		if (ac == ARGS_PUNCT || ac == ARGS_EOLN)
 			break;
-		if (ARGS_EOLN == ac)
-			break;
 
 		/* Flush out leading punctuation. */
 
-		if (NULL == head && ARGS_QWORD != ac &&
-				DELIM_OPEN == mdoc_isdelim(p)) {
+		if (head == NULL && ac != ARGS_QWORD &&
+		    mdoc_isdelim(p) == DELIM_OPEN) {
 			assert(NULL == body);
-			if ( ! dword(mdoc, line, la, p, DELIM_OPEN, 0))
-				return(0);
+			dword(mdoc, line, la, p, DELIM_OPEN, 0);
 			continue;
 		}
 
-		if (NULL == head) {
-			assert(NULL == body);
-			if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
-				return(0);
-			head = mdoc->last;
+		if (head == NULL) {
+			assert(body == NULL);
+			head = mdoc_head_alloc(mdoc, line, ppos, tok);
 		}
 
 		/*
@@ -1455,34 +1397,24 @@ blk_part_exp(MACRO_PROT_ARGS)
 		 * macros just immediately close out and begin the body.
 		 */
 
-		if (NULL == body) {
+		if (body == NULL) {
 			assert(head);
 			/* No check whether it's a macro! */
-			if (MDOC_Eo == tok)
-				if ( ! dword(mdoc, line, la, p, DELIM_MAX, 0))
-					return(0);
-
-			if ( ! rew_sub(MDOC_HEAD, mdoc, tok, line, ppos))
-				return(0);
-			if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
-				return(0);
-			body = mdoc->last;
-
-			if (MDOC_Eo == tok)
+			if (tok == MDOC_Eo)
+				dword(mdoc, line, la, p, DELIM_MAX, 0);
+			rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);
+			body = mdoc_body_alloc(mdoc, line, ppos, tok);
+			if (tok == MDOC_Eo)
 				continue;
 		}
+		assert(head != NULL && body != NULL);
 
-		assert(NULL != head && NULL != body);
-
-		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
-
-		if (MDOC_MAX == ntok) {
-			if ( ! dword(mdoc, line, la, p, DELIM_MAX,
-			    MDOC_JOIN & mdoc_macros[tok].flags))
-				return(0);
+		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);
+		if (ntok == MDOC_MAX) {
+			dword(mdoc, line, la, p, DELIM_MAX,
+			    MDOC_JOIN & mdoc_macros[tok].flags);
 			continue;
 		}
-
 		if ( ! mdoc_macro(mdoc, ntok, line, la, pos, buf))
 			return(0);
 		break;
@@ -1490,26 +1422,21 @@ blk_part_exp(MACRO_PROT_ARGS)
 
 	/* Clean-up to leave in a consistent state. */
 
-	if (NULL == head)
-		if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
-			return(0);
+	if (head == NULL)
+		mdoc_head_alloc(mdoc, line, ppos, tok);
 
-	if (NULL == body) {
-		if ( ! rew_sub(MDOC_HEAD, mdoc, tok, line, ppos))
-			return(0);
-		if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
-			return(0);
+	if (body == NULL) {
+		rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);
+		mdoc_body_alloc(mdoc, line, ppos, tok);
 	}
 
 	/* Standard appending of delimiters. */
 
-	if ( ! nl)
-		return(1);
-	return(append_delims(mdoc, line, pos, buf));
+	if (nl)
+		append_delims(mdoc, line, pos, buf);
+	return(1);
 }
 
-
-/* ARGSUSED */
 static int
 in_line_argn(MACRO_PROT_ARGS)
 {
@@ -1531,18 +1458,18 @@ in_line_argn(MACRO_PROT_ARGS)
 	 */
 
 	switch (tok) {
-	case (MDOC_Ap):
+	case MDOC_Ap:
 		/* FALLTHROUGH */
-	case (MDOC_No):
+	case MDOC_Ns:
 		/* FALLTHROUGH */
-	case (MDOC_Ns):
-		/* FALLTHROUGH */
-	case (MDOC_Ux):
+	case MDOC_Ux:
 		maxargs = 0;
 		break;
-	case (MDOC_Bx):
+	case MDOC_Bx:
 		/* FALLTHROUGH */
-	case (MDOC_Xr):
+	case MDOC_Es:
+		/* FALLTHROUGH */
+	case MDOC_Xr:
 		maxargs = 2;
 		break;
 	default:
@@ -1557,7 +1484,7 @@ in_line_argn(MACRO_PROT_ARGS)
 		if (ARGV_WORD == av) {
 			*pos = la;
 			break;
-		} 
+		}
 
 		if (ARGV_EOLN == av)
 			break;
@@ -1571,35 +1498,27 @@ in_line_argn(MACRO_PROT_ARGS)
 	for (flushed = j = 0; ; ) {
 		la = *pos;
 		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
-
-		if (ARGS_ERROR == ac)
-			return(0);
-		if (ARGS_PUNCT == ac)
+		if (ac == ARGS_PUNCT || ac == ARGS_EOLN)
 			break;
-		if (ARGS_EOLN == ac)
-			break;
 
-		if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) && 
-				ARGS_QWORD != ac && 0 == j && 
-				DELIM_OPEN == mdoc_isdelim(p)) {
-			if ( ! dword(mdoc, line, la, p, DELIM_OPEN, 0))
-				return(0);
+		if ( ! (mdoc_macros[tok].flags & MDOC_IGNDELIM) &&
+		    ac != ARGS_QWORD && j == 0 &&
+		    mdoc_isdelim(p) == DELIM_OPEN) {
+			dword(mdoc, line, la, p, DELIM_OPEN, 0);
 			continue;
-		} else if (0 == j)
-		       if ( ! mdoc_elem_alloc(mdoc, line, la, tok, arg))
-			       return(0);
+		} else if (j == 0)
+		       mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
 
 		if (j == maxargs && ! flushed) {
-			if ( ! rew_elem(mdoc, tok))
-				return(0);
+			rew_elem(mdoc, tok);
 			flushed = 1;
 		}
 
-		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
+		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);
 
-		if (MDOC_MAX != ntok) {
-			if ( ! flushed && ! rew_elem(mdoc, tok))
-				return(0);
+		if (ntok != MDOC_MAX) {
+			if ( ! flushed)
+				rew_elem(mdoc, tok);
 			flushed = 1;
 			if ( ! mdoc_macro(mdoc, ntok, line, la, pos, buf))
 				return(0);
@@ -1607,34 +1526,30 @@ in_line_argn(MACRO_PROT_ARGS)
 			break;
 		}
 
-		if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) &&
-				ARGS_QWORD != ac &&
-				! flushed &&
-				DELIM_NONE != mdoc_isdelim(p)) {
-			if ( ! rew_elem(mdoc, tok))
-				return(0);
+		if ( ! (mdoc_macros[tok].flags & MDOC_IGNDELIM) &&
+		    ac != ARGS_QWORD && ! flushed &&
+		    mdoc_isdelim(p) != DELIM_NONE) {
+			rew_elem(mdoc, tok);
 			flushed = 1;
 		}
 
-		if ( ! dword(mdoc, line, la, p, DELIM_MAX,
-		    MDOC_JOIN & mdoc_macros[tok].flags))
-			return(0);
+		dword(mdoc, line, la, p, DELIM_MAX,
+		    MDOC_JOIN & mdoc_macros[tok].flags);
 		j++;
 	}
 
-	if (0 == j && ! mdoc_elem_alloc(mdoc, line, la, tok, arg))
-	       return(0);
+	if (j == 0)
+		mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
 
 	/* Close out in a consistent state. */
 
-	if ( ! flushed && ! rew_elem(mdoc, tok))
-		return(0);
-	if ( ! nl)
-		return(1);
-	return(append_delims(mdoc, line, pos, buf));
+	if ( ! flushed)
+		rew_elem(mdoc, tok);
+	if (nl)
+		append_delims(mdoc, line, pos, buf);
+	return(1);
 }
 
-
 static int
 in_line_eoln(MACRO_PROT_ARGS)
 {
@@ -1660,7 +1575,7 @@ in_line_eoln(MACRO_PROT_ARGS)
 			*pos = la;
 			break;
 		}
-		if (ARGV_EOLN == av) 
+		if (ARGV_EOLN == av)
 			break;
 		if (ARGV_ARG == av)
 			continue;
@@ -1671,41 +1586,33 @@ in_line_eoln(MACRO_PROT_ARGS)
 
 	/* Open element scope. */
 
-	if ( ! mdoc_elem_alloc(mdoc, line, ppos, tok, arg))
-		return(0);
+	mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
 
 	/* Parse argument terms. */
 
 	for (;;) {
 		la = *pos;
 		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
-
-		if (ARGS_ERROR == ac)
-			return(0);
-		if (ARGS_EOLN == ac)
+		if (ac == ARGS_EOLN)
 			break;
 
-		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
+		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);
 
-		if (MDOC_MAX == ntok) {
-			if ( ! dword(mdoc, line, la, p, DELIM_MAX,
-			    MDOC_JOIN & mdoc_macros[tok].flags))
-				return(0);
+		if (ntok == MDOC_MAX) {
+			dword(mdoc, line, la, p, DELIM_MAX,
+			    MDOC_JOIN & mdoc_macros[tok].flags);
 			continue;
 		}
-
-		if ( ! rew_elem(mdoc, tok))
-			return(0);
+		rew_elem(mdoc, tok);
 		return(mdoc_macro(mdoc, ntok, line, la, pos, buf));
 	}
 
 	/* Close out (no delimiters). */
 
-	return(rew_elem(mdoc, tok));
+	rew_elem(mdoc, tok);
+	return(1);
 }
 
-
-/* ARGSUSED */
 static int
 ctx_synopsis(MACRO_PROT_ARGS)
 {
@@ -1732,17 +1639,6 @@ ctx_synopsis(MACRO_PROT_ARGS)
 	return(blk_part_imp(mdoc, tok, line, ppos, pos, buf));
 }
 
-
-/* ARGSUSED */
-static int
-obsolete(MACRO_PROT_ARGS)
-{
-
-	mdoc_pmsg(mdoc, line, ppos, MANDOCERR_MACROOBS);
-	return(1);
-}
-
-
 /*
  * Phrases occur within `Bl -column' entries, separated by `Ta' or tabs.
  * They're unusual because they're basically free-form text until a
@@ -1760,30 +1656,25 @@ phrase(struct mdoc *mdoc, int line, int ppos, char *bu
 		la = pos;
 
 		ac = mdoc_zargs(mdoc, line, &pos, buf, &p);
-
-		if (ARGS_ERROR == ac)
-			return(0);
-		if (ARGS_EOLN == ac)
+		if (ac == ARGS_EOLN)
 			break;
 
-		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup_raw(p);
+		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup_raw(p);
 
-		if (MDOC_MAX == ntok) {
-			if ( ! dword(mdoc, line, la, p, DELIM_MAX, 1))
-				return(0);
+		if (ntok == MDOC_MAX) {
+			dword(mdoc, line, la, p, DELIM_MAX, 1);
 			continue;
 		}
 
 		if ( ! mdoc_macro(mdoc, ntok, line, la, &pos, buf))
 			return(0);
-		return(append_delims(mdoc, line, &pos, buf));
+		append_delims(mdoc, line, &pos, buf);
+		return(1);
 	}
 
 	return(1);
 }
 
-
-/* ARGSUSED */
 static int
 phrase_ta(MACRO_PROT_ARGS)
 {
@@ -1798,37 +1689,34 @@ phrase_ta(MACRO_PROT_ARGS)
 	while (NULL != n && MDOC_Bl != n->tok)
 		n = n->parent;
 	if (NULL == n || LIST_column != n->norm->Bl.type) {
-		mdoc_pmsg(mdoc, line, ppos, MANDOCERR_STRAYTA);
+		mandoc_msg(MANDOCERR_TA_STRAY, mdoc->parse,
+		    line, ppos, "Ta");
 		return(1);
 	}
 
 	/* Advance to the next column. */
-	if ( ! rew_sub(MDOC_BODY, mdoc, MDOC_It, line, ppos))
-		return(0);
-	if ( ! mdoc_body_alloc(mdoc, line, ppos, MDOC_It))
-		return(0);
 
+	rew_sub(MDOC_BODY, mdoc, MDOC_It, line, ppos);
+	mdoc_body_alloc(mdoc, line, ppos, MDOC_It);
+
 	for (;;) {
 		la = *pos;
 		ac = mdoc_zargs(mdoc, line, pos, buf, &p);
-
-		if (ARGS_ERROR == ac)
-			return(0);
-		if (ARGS_EOLN == ac)
+		if (ac == ARGS_EOLN)
 			break;
 
-		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup_raw(p);
+		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup_raw(p);
 
-		if (MDOC_MAX == ntok) {
-			if ( ! dword(mdoc, line, la, p, DELIM_MAX,
-			    MDOC_JOIN & mdoc_macros[tok].flags))
-				return(0);
+		if (ntok == MDOC_MAX) {
+			dword(mdoc, line, la, p, DELIM_MAX,
+			    MDOC_JOIN & mdoc_macros[tok].flags);
 			continue;
 		}
 
 		if ( ! mdoc_macro(mdoc, ntok, line, la, pos, buf))
 			return(0);
-		return(append_delims(mdoc, line, pos, buf));
+		append_delims(mdoc, line, pos, buf);
+		return(1);
 	}
 
 	return(1);