===================================================================
RCS file: /cvs/mandoc/mdoc_macro.c,v
retrieving revision 1.186
retrieving revision 1.205
diff -u -p -r1.186 -r1.205
--- mandoc/mdoc_macro.c	2015/04/05 14:43:36	1.186
+++ mandoc/mdoc_macro.c	2015/10/17 00:21:07	1.205
@@ -1,4 +1,4 @@
-/*	$Id: mdoc_macro.c,v 1.186 2015/04/05 14:43:36 schwarze Exp $ */
+/*	$Id: mdoc_macro.c,v 1.205 2015/10/17 00:21:07 schwarze Exp $ */
 /*
  * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010, 2012-2015 Ingo Schwarze <schwarze@openbsd.org>
@@ -30,6 +30,7 @@
 #include "roff.h"
 #include "mdoc.h"
 #include "libmandoc.h"
+#include "roff_int.h"
 #include "libmdoc.h"
 
 static	void		blk_full(MACRO_PROT_ARGS);
@@ -42,16 +43,19 @@ static	void		in_line_argn(MACRO_PROT_ARGS);
 static	void		in_line(MACRO_PROT_ARGS);
 static	void		phrase_ta(MACRO_PROT_ARGS);
 
-static	void		dword(struct mdoc *, int, int, const char *,
-				 enum mdelim, int);
-static	void		append_delims(struct mdoc *, int, int *, char *);
-static	int		lookup(struct mdoc *, int, int, int, const char *);
+static	void		append_delims(struct roff_man *, int, int *, char *);
+static	void		dword(struct roff_man *, int, int, const char *,
+				enum mdelim, int);
+static	int		find_pending(struct roff_man *, int, int, int,
+				struct roff_node *);
+static	int		lookup(struct roff_man *, int, int, int, const char *);
 static	int		macro_or_word(MACRO_PROT_ARGS, int);
-static	int		parse_rest(struct mdoc *, int, int, int *, char *);
+static	int		parse_rest(struct roff_man *, int, int, int *, char *);
 static	int		rew_alt(int);
-static	void		rew_elem(struct mdoc *, int);
-static	void		rew_last(struct mdoc *, const struct roff_node *);
-static	void		rew_pending(struct mdoc *, const struct roff_node *);
+static	void		rew_elem(struct roff_man *, int);
+static	void		rew_last(struct roff_man *, const struct roff_node *);
+static	void		rew_pending(struct roff_man *,
+				const struct roff_node *);
 
 const	struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
 	{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Ap */
@@ -206,7 +210,7 @@ const	struct mdoc_macro * const mdoc_macros = __mdoc_m
  * are errors.
  */
 void
-mdoc_macroend(struct mdoc *mdoc)
+mdoc_endparse(struct roff_man *mdoc)
 {
 	struct roff_node *n;
 
@@ -228,38 +232,41 @@ mdoc_macroend(struct mdoc *mdoc)
 
 /*
  * Look up the macro at *p called by "from",
- * or as a line macro if from == MDOC_MAX.
+ * or as a line macro if from == TOKEN_NONE.
  */
 static int
-lookup(struct mdoc *mdoc, int from, int line, int ppos, const char *p)
+lookup(struct roff_man *mdoc, int from, int line, int ppos, const char *p)
 {
 	int	 res;
 
-	if (from == MDOC_MAX || mdoc_macros[from].flags & MDOC_PARSED) {
+	if (mdoc->flags & MDOC_PHRASEQF) {
+		mdoc->flags &= ~MDOC_PHRASEQF;
+		return TOKEN_NONE;
+	}
+	if (from == TOKEN_NONE || mdoc_macros[from].flags & MDOC_PARSED) {
 		res = mdoc_hash_find(p);
-		if (res != MDOC_MAX) {
+		if (res != TOKEN_NONE) {
 			if (mdoc_macros[res].flags & MDOC_CALLABLE)
-				return(res);
+				return res;
 			if (res != MDOC_br && res != MDOC_sp && res != MDOC_ll)
 				mandoc_msg(MANDOCERR_MACRO_CALL,
 				    mdoc->parse, line, ppos, p);
 		}
 	}
-	return(MDOC_MAX);
+	return TOKEN_NONE;
 }
 
 /*
  * Rewind up to and including a specific node.
  */
 static void
-rew_last(struct mdoc *mdoc, const struct roff_node *to)
+rew_last(struct roff_man *mdoc, const struct roff_node *to)
 {
-	struct roff_node *n, *np;
+	struct roff_node	*np;
 
 	if (to->flags & MDOC_VALID)
 		return;
 
-	mdoc->next = MDOC_NEXT_SIBLING;
 	while (mdoc->last != to) {
 		/*
 		 * Save the parent here, because we may delete the
@@ -269,11 +276,10 @@ rew_last(struct mdoc *mdoc, const struct roff_node *to
 		 */
 		np = mdoc->last->parent;
 		mdoc_valid_post(mdoc);
-		n = mdoc->last;
 		mdoc->last = np;
 		assert(mdoc->last);
-		mdoc->last->last = n;
 	}
+	mdoc->next = ROFF_NEXT_SIBLING;
 	mdoc_valid_post(mdoc);
 }
 
@@ -281,25 +287,28 @@ rew_last(struct mdoc *mdoc, const struct roff_node *to
  * Rewind up to a specific block, including all blocks that broke it.
  */
 static void
-rew_pending(struct mdoc *mdoc, const struct roff_node *n)
+rew_pending(struct roff_man *mdoc, const struct roff_node *n)
 {
 
 	for (;;) {
 		rew_last(mdoc, n);
 
-		switch (n->type) {
-		case ROFFT_HEAD:
-			mdoc_body_alloc(mdoc, n->line, n->pos, n->tok);
-			return;
-		case ROFFT_BLOCK:
-			break;
-		default:
-			return;
-		}
+		if (mdoc->last == n) {
+			switch (n->type) {
+			case ROFFT_HEAD:
+				roff_body_alloc(mdoc, n->line, n->pos,
+				    n->tok);
+				return;
+			case ROFFT_BLOCK:
+				break;
+			default:
+				return;
+			}
+			if ( ! (n->flags & MDOC_BROKEN))
+				return;
+		} else
+			n = mdoc->last;
 
-		if ( ! (n->flags & MDOC_BROKEN))
-			return;
-
 		for (;;) {
 			if ((n = n->parent) == NULL)
 				return;
@@ -324,45 +333,44 @@ rew_alt(int tok)
 {
 	switch (tok) {
 	case MDOC_Ac:
-		return(MDOC_Ao);
+		return MDOC_Ao;
 	case MDOC_Bc:
-		return(MDOC_Bo);
+		return MDOC_Bo;
 	case MDOC_Brc:
-		return(MDOC_Bro);
+		return MDOC_Bro;
 	case MDOC_Dc:
-		return(MDOC_Do);
+		return MDOC_Do;
 	case MDOC_Ec:
-		return(MDOC_Eo);
+		return MDOC_Eo;
 	case MDOC_Ed:
-		return(MDOC_Bd);
+		return MDOC_Bd;
 	case MDOC_Ef:
-		return(MDOC_Bf);
+		return MDOC_Bf;
 	case MDOC_Ek:
-		return(MDOC_Bk);
+		return MDOC_Bk;
 	case MDOC_El:
-		return(MDOC_Bl);
+		return MDOC_Bl;
 	case MDOC_Fc:
-		return(MDOC_Fo);
+		return MDOC_Fo;
 	case MDOC_Oc:
-		return(MDOC_Oo);
+		return MDOC_Oo;
 	case MDOC_Pc:
-		return(MDOC_Po);
+		return MDOC_Po;
 	case MDOC_Qc:
-		return(MDOC_Qo);
+		return MDOC_Qo;
 	case MDOC_Re:
-		return(MDOC_Rs);
+		return MDOC_Rs;
 	case MDOC_Sc:
-		return(MDOC_So);
+		return MDOC_So;
 	case MDOC_Xc:
-		return(MDOC_Xo);
+		return MDOC_Xo;
 	default:
-		return(tok);
+		return tok;
 	}
-	/* NOTREACHED */
 }
 
 static void
-rew_elem(struct mdoc *mdoc, int tok)
+rew_elem(struct roff_man *mdoc, int tok)
 {
 	struct roff_node *n;
 
@@ -375,11 +383,49 @@ rew_elem(struct mdoc *mdoc, int tok)
 }
 
 /*
+ * If there is an open sub-block of the target requiring
+ * explicit close-out, postpone closing out the target until
+ * the rew_pending() call closing out the sub-block.
+ */
+static int
+find_pending(struct roff_man *mdoc, int tok, int line, int ppos,
+	struct roff_node *target)
+{
+	struct roff_node	*n;
+	int			 irc;
+
+	irc = 0;
+	for (n = mdoc->last; n != NULL && n != target; n = n->parent) {
+		if (n->flags & MDOC_ENDED) {
+			if ( ! (n->flags & MDOC_VALID))
+				n->flags |= MDOC_BROKEN;
+			continue;
+		}
+		if (n->type == ROFFT_BLOCK &&
+		    mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {
+			irc = 1;
+			n->flags = MDOC_BROKEN;
+			if (target->type == ROFFT_HEAD)
+				target->flags = MDOC_ENDED;
+			else if ( ! (target->flags & MDOC_ENDED)) {
+				mandoc_vmsg(MANDOCERR_BLK_NEST,
+				    mdoc->parse, line, ppos,
+				    "%s breaks %s", mdoc_macronames[tok],
+				    mdoc_macronames[n->tok]);
+				mdoc_endbody_alloc(mdoc, line, ppos,
+				    tok, target, ENDBODY_NOSPACE);
+			}
+		}
+	}
+	return irc;
+}
+
+/*
  * Allocate a word and check whether it's punctuation or not.
  * Punctuation consists of those tokens found in mdoc_isdelim().
  */
 static void
-dword(struct mdoc *mdoc, int line, int col, const char *p,
+dword(struct roff_man *mdoc, int line, int col, const char *p,
 		enum mdelim d, int may_append)
 {
 
@@ -390,11 +436,11 @@ dword(struct mdoc *mdoc, int line, int col, const char
 	    ! (mdoc->flags & (MDOC_SYNOPSIS | MDOC_KEEP | MDOC_SMOFF)) &&
 	    d == DELIM_NONE && mdoc->last->type == ROFFT_TEXT &&
 	    mdoc_isdelim(mdoc->last->string) == DELIM_NONE) {
-		mdoc_word_append(mdoc, p);
+		roff_word_append(mdoc, p);
 		return;
 	}
 
-	mdoc_word_alloc(mdoc, line, col, p);
+	roff_word_alloc(mdoc, line, col, p);
 
 	/*
 	 * If the word consists of a bare delimiter,
@@ -413,7 +459,7 @@ dword(struct mdoc *mdoc, int line, int col, const char
 }
 
 static void
-append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)
+append_delims(struct roff_man *mdoc, int line, int *pos, char *buf)
 {
 	char		*p;
 	int		 la;
@@ -423,7 +469,8 @@ append_delims(struct mdoc *mdoc, int line, int *pos, c
 
 	for (;;) {
 		la = *pos;
-		if (mdoc_args(mdoc, line, pos, buf, MDOC_MAX, &p) == ARGS_EOLN)
+		if (mdoc_args(mdoc, line, pos, buf, TOKEN_NONE, &p) ==
+		    ARGS_EOLN)
 			break;
 		dword(mdoc, line, la, p, DELIM_MAX, 1);
 
@@ -456,23 +503,23 @@ macro_or_word(MACRO_PROT_ARGS, int parsed)
 	int		 ntok;
 
 	p = buf + ppos;
-	ntok = MDOC_MAX;
+	ntok = TOKEN_NONE;
 	if (*p == '"')
 		p++;
 	else if (parsed && ! (mdoc->flags & MDOC_PHRASELIT))
 		ntok = lookup(mdoc, tok, line, ppos, p);
 
-	if (ntok == MDOC_MAX) {
-		dword(mdoc, line, ppos, p, DELIM_MAX, tok == MDOC_MAX ||
+	if (ntok == TOKEN_NONE) {
+		dword(mdoc, line, ppos, p, DELIM_MAX, tok == TOKEN_NONE ||
 		    mdoc_macros[tok].flags & MDOC_JOIN);
-		return(0);
+		return 0;
 	} else {
 		if (mdoc_macros[tok].fp == in_line_eoln)
 			rew_elem(mdoc, tok);
 		mdoc_macro(mdoc, ntok, line, ppos, pos, buf);
-		if (tok == MDOC_MAX)
+		if (tok == TOKEN_NONE)
 			append_delims(mdoc, line, pos, buf);
-		return(1);
+		return 1;
 	}
 }
 
@@ -487,8 +534,9 @@ blk_exp_close(MACRO_PROT_ARGS)
 	struct roff_node *itblk;	/* An It block starting later. */
 	struct roff_node *later;	/* A sub-block starting later. */
 	struct roff_node *n;		/* Search back to our block. */
+	struct roff_node *target;	/* For find_pending(). */
 
-	int		 j, lastarg, maxargs, nl;
+	int		 j, lastarg, maxargs, nl, pending;
 	enum margserr	 ac;
 	int		 atok, ntok;
 	char		*p;
@@ -576,7 +624,7 @@ blk_exp_close(MACRO_PROT_ARGS)
 			 */
 
 			if (maxargs)
-				mdoc->next = MDOC_NEXT_CHILD;
+				mdoc->next = ROFF_NEXT_CHILD;
 			break;
 		}
 
@@ -597,12 +645,14 @@ blk_exp_close(MACRO_PROT_ARGS)
 	if (body == NULL) {
 		mandoc_msg(MANDOCERR_BLK_NOTOPEN, mdoc->parse,
 		    line, ppos, mdoc_macronames[tok]);
+		if (later != NULL)
+			later->flags &= ~MDOC_BROKEN;
 		if (maxargs && endbody == NULL) {
 			/*
 			 * Stray .Ec without previous .Eo:
 			 * Break the output line, keep the arguments.
 			 */
-			mdoc_elem_alloc(mdoc, line, ppos, MDOC_br, NULL);
+			roff_elem_alloc(mdoc, line, ppos, MDOC_br);
 			rew_elem(mdoc, MDOC_br);
 		}
 	} else if (endbody == NULL) {
@@ -624,6 +674,8 @@ blk_exp_close(MACRO_PROT_ARGS)
 
 	if (endbody != NULL)
 		n = endbody;
+
+	ntok = TOKEN_NONE;
 	for (j = 0; ; j++) {
 		lastarg = *pos;
 
@@ -634,10 +686,10 @@ blk_exp_close(MACRO_PROT_ARGS)
 		if (ac == ARGS_PUNCT || ac == ARGS_EOLN)
 			break;
 
-		ntok = ac == ARGS_QWORD ? MDOC_MAX :
+		ntok = ac == ARGS_QWORD ? TOKEN_NONE :
 		    lookup(mdoc, tok, line, lastarg, p);
 
-		if (ntok == MDOC_MAX) {
+		if (ntok == TOKEN_NONE) {
 			dword(mdoc, line, lastarg, p, DELIM_MAX,
 			    MDOC_JOIN & mdoc_macros[tok].flags);
 			continue;
@@ -650,8 +702,19 @@ blk_exp_close(MACRO_PROT_ARGS)
 		break;
 	}
 
-	if (n != NULL)
-		rew_pending(mdoc, n);
+	if (n != NULL) {
+		if (ntok != TOKEN_NONE && n->flags & MDOC_BROKEN) {
+			target = n;
+			do
+				target = target->parent;
+			while ( ! (target->flags & MDOC_ENDED));
+			pending = find_pending(mdoc, ntok, line, ppos,
+			    target);
+		} else
+			pending = 0;
+		if ( ! pending)
+			rew_pending(mdoc, n);
+	}
 	if (nl)
 		append_delims(mdoc, line, pos, buf);
 }
@@ -675,15 +738,10 @@ in_line(MACRO_PROT_ARGS)
 
 	switch (tok) {
 	case MDOC_An:
-		/* FALLTHROUGH */
 	case MDOC_Ar:
-		/* FALLTHROUGH */
 	case MDOC_Fl:
-		/* FALLTHROUGH */
 	case MDOC_Mt:
-		/* FALLTHROUGH */
 	case MDOC_Nm:
-		/* FALLTHROUGH */
 	case MDOC_Pa:
 		nc = 1;
 		break;
@@ -727,7 +785,7 @@ in_line(MACRO_PROT_ARGS)
 		}
 
 		ntok = (ac == ARGS_QWORD || (tok == MDOC_Fn && !cnt)) ?
-		    MDOC_MAX : lookup(mdoc, tok, line, la, p);
+		    TOKEN_NONE : lookup(mdoc, tok, line, la, p);
 
 		/*
 		 * In this case, we've located a submacro and must
@@ -736,7 +794,7 @@ in_line(MACRO_PROT_ARGS)
 		 * or raise a warning.
 		 */
 
-		if (ntok != MDOC_MAX) {
+		if (ntok != TOKEN_NONE) {
 			if (scope)
 				rew_elem(mdoc, tok);
 			if (nc && ! cnt) {
@@ -887,7 +945,6 @@ blk_full(MACRO_PROT_ARGS)
 			if (mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {
 				switch (tok) {
 				case MDOC_Sh:
-					/* FALLTHROUGH */
 				case MDOC_Ss:
 					mandoc_vmsg(MANDOCERR_BLK_BROKEN,
 					    mdoc->parse, line, ppos,
@@ -935,7 +992,7 @@ blk_full(MACRO_PROT_ARGS)
 		if (tok == MDOC_It && (n == NULL || n->tok != MDOC_Bl)) {
 			mandoc_vmsg(MANDOCERR_IT_STRAY, mdoc->parse,
 			    line, ppos, "It %s", buf + *pos);
-			mdoc_elem_alloc(mdoc, line, ppos, MDOC_br, NULL);
+			roff_elem_alloc(mdoc, line, ppos, MDOC_br);
 			rew_elem(mdoc, MDOC_br);
 			return;
 		}
@@ -969,34 +1026,47 @@ blk_full(MACRO_PROT_ARGS)
 	 */
 
 	if (tok == MDOC_Nd) {
-		head = mdoc_head_alloc(mdoc, line, ppos, tok);
+		head = roff_head_alloc(mdoc, line, ppos, tok);
 		rew_last(mdoc, head);
-		body = mdoc_body_alloc(mdoc, line, ppos, tok);
+		body = roff_body_alloc(mdoc, line, ppos, tok);
 	}
 
 	if (tok == MDOC_Bk)
 		mdoc->flags |= MDOC_KEEP;
 
-	ac = ARGS_PEND;
+	ac = ARGS_EOLN;
 	for (;;) {
+
+		/*
+		 * If we are right after a tab character,
+		 * do not parse the first word for macros.
+		 */
+
+		if (mdoc->flags & MDOC_PHRASEQN) {
+			mdoc->flags &= ~MDOC_PHRASEQN;
+			mdoc->flags |= MDOC_PHRASEQF;
+		}
+
 		la = *pos;
 		lac = ac;
 		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
 		if (ac == ARGS_EOLN) {
-			if (lac != ARGS_PPHRASE && lac != ARGS_PHRASE)
+			if (lac != ARGS_PHRASE ||
+			    ! (mdoc->flags & MDOC_PHRASEQF))
 				break;
+
 			/*
-			 * This is necessary: if the last token on a
-			 * line is a `Ta' or tab, then we'll get
-			 * ARGS_EOLN, so we must be smart enough to
-			 * reopen our scope if the last parse was a
-			 * phrase or partial phrase.
+			 * This line ends in a tab; start the next
+			 * column now, with a leading blank.
 			 */
+
 			if (body != NULL)
 				rew_last(mdoc, body);
-			body = mdoc_body_alloc(mdoc, line, ppos, tok);
+			body = roff_body_alloc(mdoc, line, ppos, tok);
+			roff_word_alloc(mdoc, line, ppos, "\\&");
 			break;
 		}
+
 		if (tok == MDOC_Bd || tok == MDOC_Bk) {
 			mandoc_vmsg(MANDOCERR_ARG_EXCESS,
 			    mdoc->parse, line, la, "%s ... %s",
@@ -1017,9 +1087,7 @@ blk_full(MACRO_PROT_ARGS)
 		 */
 
 		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);
@@ -1029,11 +1097,9 @@ blk_full(MACRO_PROT_ARGS)
 		/* Open a head if one hasn't been opened. */
 
 		if (head == NULL)
-			head = mdoc_head_alloc(mdoc, line, ppos, tok);
+			head = roff_head_alloc(mdoc, line, ppos, tok);
 
-		if (ac == ARGS_PHRASE ||
-		    ac == ARGS_PEND ||
-		    ac == ARGS_PPHRASE) {
+		if (ac == ARGS_PHRASE) {
 
 			/*
 			 * If we haven't opened a body yet, rewind the
@@ -1041,20 +1107,18 @@ blk_full(MACRO_PROT_ARGS)
 			 */
 
 			rew_last(mdoc, body == NULL ? head : body);
-			body = mdoc_body_alloc(mdoc, line, ppos, tok);
+			body = roff_body_alloc(mdoc, line, ppos, tok);
 
-			/*
-			 * Process phrases: set whether we're in a
-			 * partial-phrase (this effects line handling)
-			 * then call down into the phrase parser.
-			 */
+			/* Process to the tab or to the end of the line. */
 
-			if (ac == ARGS_PPHRASE)
-				mdoc->flags |= MDOC_PPHRASE;
-			if (ac == ARGS_PEND && lac == ARGS_PPHRASE)
-				mdoc->flags |= MDOC_PPHRASE;
-			parse_rest(mdoc, MDOC_MAX, line, &la, buf);
-			mdoc->flags &= ~MDOC_PPHRASE;
+			mdoc->flags |= MDOC_PHRASE;
+			parse_rest(mdoc, TOKEN_NONE, line, &la, buf);
+			mdoc->flags &= ~MDOC_PHRASE;
+
+			/* There may have been `Ta' macros. */
+
+			while (body->next != NULL)
+				body = body->next;
 			continue;
 		}
 
@@ -1065,37 +1129,18 @@ blk_full(MACRO_PROT_ARGS)
 	if (blk->flags & MDOC_VALID)
 		return;
 	if (head == NULL)
-		head = mdoc_head_alloc(mdoc, line, ppos, tok);
+		head = roff_head_alloc(mdoc, line, ppos, tok);
 	if (nl && tok != MDOC_Bd && tok != MDOC_Bl && tok != MDOC_Rs)
 		append_delims(mdoc, line, pos, buf);
 	if (body != NULL)
 		goto out;
-
-	/*
-	 * If there is an open (i.e., unvalidated) sub-block requiring
-	 * explicit close-out, postpone switching the current block from
-	 * head to body until the rew_pending() call closing out that
-	 * sub-block.
-	 */
-	for (n = mdoc->last; n && n != head; n = n->parent) {
-		if (n->flags & MDOC_ENDED) {
-			if ( ! (n->flags & MDOC_VALID))
-				n->flags |= MDOC_BROKEN;
-			continue;
-		}
-		if (n->type == ROFFT_BLOCK &&
-		    mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {
-			n->flags = MDOC_BROKEN;
-			head->flags = MDOC_ENDED;
-		}
-	}
-	if (head->flags & MDOC_ENDED)
+	if (find_pending(mdoc, tok, line, ppos, head))
 		return;
 
 	/* Close out scopes to remain in a consistent state. */
 
 	rew_last(mdoc, head);
-	body = mdoc_body_alloc(mdoc, line, ppos, tok);
+	body = roff_body_alloc(mdoc, line, ppos, tok);
 out:
 	if (mdoc->flags & MDOC_FREECOL) {
 		rew_last(mdoc, body);
@@ -1126,7 +1171,7 @@ blk_part_imp(MACRO_PROT_ARGS)
 	 */
 
 	blk = mdoc_block_alloc(mdoc, line, ppos, tok, NULL);
-	rew_last(mdoc, mdoc_head_alloc(mdoc, line, ppos, tok));
+	rew_last(mdoc, roff_head_alloc(mdoc, line, ppos, tok));
 
 	/*
 	 * Open the body scope "on-demand", that is, after we've
@@ -1147,42 +1192,15 @@ blk_part_imp(MACRO_PROT_ARGS)
 		}
 
 		if (body == NULL)
-			body = mdoc_body_alloc(mdoc, line, ppos, tok);
+			body = roff_body_alloc(mdoc, line, ppos, tok);
 
 		if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))
 			break;
 	}
 	if (body == NULL)
-		body = mdoc_body_alloc(mdoc, line, ppos, tok);
+		body = roff_body_alloc(mdoc, line, ppos, tok);
 
-	/*
-	 * If there is an open sub-block requiring explicit close-out,
-	 * postpone closing out the current block until the
-	 * rew_pending() call closing out the sub-block.
-	 */
-
-	for (n = mdoc->last; n && n != body && n != blk->parent;
-	     n = n->parent) {
-		if (n->flags & MDOC_ENDED) {
-			if ( ! (n->flags & MDOC_VALID))
-				n->flags |= MDOC_BROKEN;
-			continue;
-		}
-		if (n->type == ROFFT_BLOCK &&
-		    mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {
-			n->flags |= MDOC_BROKEN;
-			if ( ! (body->flags & MDOC_ENDED)) {
-				mandoc_vmsg(MANDOCERR_BLK_NEST,
-				    mdoc->parse, line, ppos,
-				    "%s breaks %s", mdoc_macronames[tok],
-				    mdoc_macronames[n->tok]);
-				mdoc_endbody_alloc(mdoc, line, ppos,
-				    tok, body, ENDBODY_NOSPACE);
-			}
-		}
-	}
-	assert(n == body);
-	if (body->flags & MDOC_ENDED)
+	if (find_pending(mdoc, tok, line, ppos, body))
 		return;
 
 	rew_last(mdoc, body);
@@ -1214,7 +1232,7 @@ blk_part_exp(MACRO_PROT_ARGS)
 	 * case of `Eo'); and a body that may be empty.
 	 */
 
-	mdoc_block_alloc(mdoc, line, ppos, tok, NULL);
+	roff_block_alloc(mdoc, line, ppos, tok);
 	head = NULL;
 	for (;;) {
 		la = *pos;
@@ -1231,11 +1249,11 @@ blk_part_exp(MACRO_PROT_ARGS)
 		}
 
 		if (head == NULL) {
-			head = mdoc_head_alloc(mdoc, line, ppos, tok);
+			head = roff_head_alloc(mdoc, line, ppos, tok);
 			if (tok == MDOC_Eo)  /* Not parsed. */
 				dword(mdoc, line, la, p, DELIM_MAX, 0);
 			rew_last(mdoc, head);
-			mdoc_body_alloc(mdoc, line, ppos, tok);
+			roff_body_alloc(mdoc, line, ppos, tok);
 			if (tok == MDOC_Eo)
 				continue;
 		}
@@ -1247,8 +1265,8 @@ blk_part_exp(MACRO_PROT_ARGS)
 	/* Clean-up to leave in a consistent state. */
 
 	if (head == NULL) {
-		rew_last(mdoc, mdoc_head_alloc(mdoc, line, ppos, tok));
-		mdoc_body_alloc(mdoc, line, ppos, tok);
+		rew_last(mdoc, roff_head_alloc(mdoc, line, ppos, tok));
+		roff_body_alloc(mdoc, line, ppos, tok);
 	}
 	if (nl)
 		append_delims(mdoc, line, pos, buf);
@@ -1276,16 +1294,12 @@ in_line_argn(MACRO_PROT_ARGS)
 
 	switch (tok) {
 	case MDOC_Ap:
-		/* FALLTHROUGH */
 	case MDOC_Ns:
-		/* FALLTHROUGH */
 	case MDOC_Ux:
 		maxargs = 0;
 		break;
 	case MDOC_Bx:
-		/* FALLTHROUGH */
 	case MDOC_Es:
-		/* FALLTHROUGH */
 	case MDOC_Xr:
 		maxargs = 2;
 		break;
@@ -1329,9 +1343,9 @@ in_line_argn(MACRO_PROT_ARGS)
 		}
 
 		ntok = (ac == ARGS_QWORD || (tok == MDOC_Pf && state == 0)) ?
-		    MDOC_MAX : lookup(mdoc, tok, line, la, p);
+		    TOKEN_NONE : lookup(mdoc, tok, line, la, p);
 
-		if (ntok != MDOC_MAX) {
+		if (ntok != TOKEN_NONE) {
 			if (state >= 0) {
 				rew_elem(mdoc, tok);
 				state = -2;
@@ -1380,10 +1394,10 @@ in_line_eoln(MACRO_PROT_ARGS)
 	if ((tok == MDOC_Pp || tok == MDOC_Lp) &&
 	    ! (mdoc->flags & MDOC_SYNOPSIS)) {
 		n = mdoc->last;
-		if (mdoc->next == MDOC_NEXT_SIBLING)
+		if (mdoc->next == ROFF_NEXT_SIBLING)
 			n = n->parent;
 		if (n->tok == MDOC_Nm)
-			rew_last(mdoc, mdoc->last->parent);
+			rew_last(mdoc, n->parent);
 	}
 
 	if (buf[*pos] == '\0' &&
@@ -1406,16 +1420,16 @@ in_line_eoln(MACRO_PROT_ARGS)
  * or until the next macro, call that macro, and return 1.
  */
 static int
-parse_rest(struct mdoc *mdoc, int tok, int line, int *pos, char *buf)
+parse_rest(struct roff_man *mdoc, int tok, int line, int *pos, char *buf)
 {
 	int		 la;
 
 	for (;;) {
 		la = *pos;
 		if (mdoc_args(mdoc, line, pos, buf, tok, NULL) == ARGS_EOLN)
-			return(0);
+			return 0;
 		if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))
-			return(1);
+			return 1;
 	}
 }
 
@@ -1464,6 +1478,6 @@ phrase_ta(MACRO_PROT_ARGS)
 	/* Advance to the next column. */
 
 	rew_last(mdoc, body);
-	mdoc_body_alloc(mdoc, line, ppos, MDOC_It);
-	parse_rest(mdoc, MDOC_MAX, line, pos, buf);
+	roff_body_alloc(mdoc, line, ppos, MDOC_It);
+	parse_rest(mdoc, TOKEN_NONE, line, pos, buf);
 }