===================================================================
RCS file: /cvs/mandoc/mdoc_macro.c,v
retrieving revision 1.152
retrieving revision 1.165
diff -u -p -r1.152 -r1.165
--- mandoc/mdoc_macro.c	2014/11/28 23:21:32	1.152
+++ mandoc/mdoc_macro.c	2015/02/02 04:04:45	1.165
@@ -1,7 +1,7 @@
-/*	$Id: mdoc_macro.c,v 1.152 2014/11/28 23:21:32 schwarze Exp $ */
+/*	$Id: mdoc_macro.c,v 1.165 2015/02/02 04:04:45 schwarze Exp $ */
 /*
  * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
- * Copyright (c) 2010, 2012, 2013, 2014 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2010, 2012-2015 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
@@ -53,11 +53,13 @@ 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	enum mdoct	lookup(enum mdoct, const char *);
-static	enum mdoct	lookup_raw(const char *);
+static	enum mdoct	lookup(struct mdoc *, enum mdoct,
+				int, int, const char *);
+static	int		macro_or_word(MACRO_PROT_ARGS, int);
 static	int		make_pending(struct mdoc_node *, enum mdoct,
 				struct mdoc *, int, int);
-static	void		phrase(struct mdoc *, int, int, char *);
+static	int		parse_rest(struct mdoc *, enum mdoct,
+				int, int *, char *);
 static	enum mdoct	rew_alt(enum mdoct);
 static	enum rew	rew_dohalt(enum mdoct, enum mdoc_type,
 				const struct mdoc_node *);
@@ -240,29 +242,24 @@ mdoc_macroend(struct mdoc *mdoc)
 }
 
 /*
- * Look up a macro from within a subsequent context.
+ * Look up the macro at *p called by "from",
+ * or as a line macro if from == MDOC_MAX.
  */
 static enum mdoct
-lookup(enum mdoct from, const char *p)
+lookup(struct mdoc *mdoc, enum mdoct from, int line, int ppos, const char *p)
 {
-
-	if ( ! (MDOC_PARSED & mdoc_macros[from].flags))
-		return(MDOC_MAX);
-	return(lookup_raw(p));
-}
-
-/*
- * Lookup a macro following the initial line macro.
- */
-static enum mdoct
-lookup_raw(const char *p)
-{
 	enum mdoct	 res;
 
-	if (MDOC_MAX == (res = mdoc_hash_find(p)))
-		return(MDOC_MAX);
-	if (MDOC_CALLABLE & mdoc_macros[res].flags)
-		return(res);
+	if (from == MDOC_MAX || mdoc_macros[from].flags & MDOC_PARSED) {
+		res = mdoc_hash_find(p);
+		if (res != MDOC_MAX) {
+			if (mdoc_macros[res].flags & MDOC_CALLABLE)
+				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);
 }
 
@@ -366,7 +363,7 @@ rew_dohalt(enum mdoct tok, enum mdoc_type type,
 	 * When starting to rewind, skip plain text
 	 * and nodes that have already been rewound.
 	 */
-	if (MDOC_TEXT == p->type || MDOC_VALID & p->flags)
+	if (p->type == MDOC_TEXT || p->flags & (MDOC_VALID | MDOC_BREAK))
 		return(REWIND_MORE);
 
 	/*
@@ -481,12 +478,16 @@ make_pending(struct mdoc_node *broken, enum mdoct tok,
 	for (breaker = broken->parent; breaker; breaker = breaker->parent) {
 
 		/*
-		 * If the *broken block had already been broken before
-		 * and we encounter its breaker, make the tok block
-		 * pending on the inner breaker.
-		 * Graphically, "[A breaker=[B broken=[C->B B] tok=A] C]"
-		 * becomes "[A broken=[B [C->B B] tok=A] C]"
-		 * and finally "[A [B->A [C->B B] A] C]".
+		 * If the *broken block (Z) is already broken and we
+		 * encounter its breaker (B), make the tok block (A)
+		 * pending on that inner breaker (B).
+		 * Graphically, [A breaker=[B! broken=[Z->B B] tok=A] Z]
+		 * becomes breaker=[A broken=[B! [Z->B B] tok=A] Z]
+		 * and finally [A! [B!->A [Z->B B] A] Z].
+		 * In these graphics, "->" indicates the "pending"
+		 * pointer and "!" indicates the MDOC_BREAK flag.
+		 * Each of the cases gets one additional pointer (B->A)
+		 * and one additional flag (A!).
 		 */
 		if (breaker == broken->pending) {
 			broken = breaker;
@@ -500,31 +501,38 @@ make_pending(struct mdoc_node *broken, enum mdoct tok,
 
 		/*
 		 * Found the breaker.
-		 * If another, outer breaker is already pending on
-		 * the *broken block, we must not clobber the link
+		 * If another, outer breaker (X) is already pending on
+		 * the *broken block (B), we must not clobber the link
 		 * to the outer breaker, but make it pending on the
-		 * new, now inner breaker.
-		 * Graphically, "[A breaker=[B broken=[C->A A] tok=B] C]"
-		 * becomes "[A breaker=[B->A broken=[C A] tok=B] C]"
-		 * and finally "[A [B->A [C->B A] B] C]".
+		 * new, now inner breaker (A).
+		 * Graphically, [X! breaker=[A broken=[B->X X] tok=A] B]
+		 * becomes [X! breaker=[A->X broken=[B X] tok=A] B]
+		 * and finally [X! [A!->X [B->A X] A] B].
 		 */
 		if (broken->pending) {
 			struct mdoc_node *taker;
 
 			/*
-			 * If the breaker had also been broken before,
-			 * it cannot take on the outer breaker itself,
-			 * but must hand it on to its own breakers.
-			 * Graphically, this is the following situation:
-			 * "[A [B breaker=[C->B B] broken=[D->A A] tok=C] D]"
-			 * "[A taker=[B->A breaker=[C->B B] [D->C A] C] D]"
+			 * If the inner breaker (A) is already broken,
+			 * too, it cannot take on the outer breaker (X)
+			 * but must hand it on to its own breakers (Y):
+			 * [X! [Y! breaker=[A->Y Y] broken=[B->X X] tok=A] B]
+			 * [X! take=[Y!->X brea=[A->Y Y] brok=[B X] tok=A] B]
+			 * and finally [X! [Y!->X [A!->Y Y] [B->A X] A] B].
 			 */
 			taker = breaker;
 			while (taker->pending)
 				taker = taker->pending;
 			taker->pending = broken->pending;
 		}
+
+		/*
+		 * Now we have reduced the situation to the simplest
+		 * case, which is just breaker=[A broken=[B tok=A] B]
+		 * and becomes [A! [B->A A] B].
+		 */
 		broken->pending = breaker;
+		breaker->flags |= MDOC_BREAK;
 		mandoc_vmsg(MANDOCERR_BLK_NEST, mdoc->parse, line, ppos,
 		    "%s breaks %s", mdoc_macronames[tok],
 		    mdoc_macronames[broken->tok]);
@@ -542,13 +550,17 @@ static void
 rew_sub(enum mdoc_type t, struct mdoc *mdoc,
 		enum mdoct tok, int line, int ppos)
 {
-	struct mdoc_node *n;
+	struct mdoc_node *n, *to;
 
+	to = NULL;
 	n = mdoc->last;
 	while (n) {
 		switch (rew_dohalt(tok, t, n)) {
 		case REWIND_NONE:
-			return;
+			if (to == NULL)
+				return;
+			n = to;
+			break;
 		case REWIND_THIS:
 			n->lastline = line -
 			    (mdoc->flags & MDOC_NEWLINE &&
@@ -563,6 +575,7 @@ rew_sub(enum mdoc_type t, struct mdoc *mdoc,
 		case REWIND_MORE:
 			n->lastline = line -
 			    (mdoc->flags & MDOC_NEWLINE ? 1 : 0);
+			to = n;
 			n = n->parent;
 			continue;
 		case REWIND_LATER:
@@ -633,17 +646,15 @@ dword(struct mdoc *mdoc, int line, int col, const char
 static void
 append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)
 {
-	int		 la;
-	enum margserr	 ac;
 	char		*p;
+	int		 la;
 
 	if (buf[*pos] == '\0')
 		return;
 
 	for (;;) {
 		la = *pos;
-		ac = mdoc_zargs(mdoc, line, pos, buf, &p);
-		if (ac == ARGS_EOLN)
+		if (mdoc_args(mdoc, line, pos, buf, MDOC_MAX, &p) == ARGS_EOLN)
 			break;
 		dword(mdoc, line, la, p, DELIM_MAX, 1);
 
@@ -665,6 +676,38 @@ append_delims(struct mdoc *mdoc, int line, int *pos, c
 }
 
 /*
+ * Parse one word.
+ * If it is a macro, call it and return 1.
+ * Otherwise, allocate it and return 0.
+ */
+static int
+macro_or_word(MACRO_PROT_ARGS, int parsed)
+{
+	char		*p;
+	enum mdoct	 ntok;
+
+	p = buf + ppos;
+	ntok = MDOC_MAX;
+	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 ||
+		    mdoc_macros[tok].flags & MDOC_JOIN);
+		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)
+			append_delims(mdoc, line, pos, buf);
+		return(1);
+	}
+}
+
+/*
  * Close out block partial/full explicit.
  */
 static void
@@ -675,7 +718,7 @@ blk_exp_close(MACRO_PROT_ARGS)
 	struct mdoc_node *later;	/* A sub-block starting later. */
 	struct mdoc_node *n;		/* For searching backwards. */
 
-	int		 j, lastarg, maxargs, flushed, nl;
+	int		 flushed, have_it, j, lastarg, maxargs, nl;
 	enum margserr	 ac;
 	enum mdoct	 atok, ntok;
 	char		*p;
@@ -699,10 +742,11 @@ blk_exp_close(MACRO_PROT_ARGS)
 	 * both of our own and of pending sub-blocks.
 	 */
 
+	have_it = 0;
 	atok = rew_alt(tok);
 	body = endbody = later = NULL;
 	for (n = mdoc->last; n; n = n->parent) {
-		if (n->flags & MDOC_VALID)
+		if (n->flags & (MDOC_VALID | MDOC_BREAK))
 			continue;
 
 		/* Remember the start of our own body. */
@@ -715,6 +759,12 @@ blk_exp_close(MACRO_PROT_ARGS)
 
 		if (n->type != MDOC_BLOCK || n->tok == MDOC_Nm)
 			continue;
+
+		if (n->tok == MDOC_It) {
+			have_it = 1;
+			continue;
+		}
+
 		if (atok == n->tok) {
 			assert(body);
 
@@ -724,7 +774,8 @@ blk_exp_close(MACRO_PROT_ARGS)
 			 * just proceed to closing out.
 			 */
 
-			if (later == NULL)
+			if (later == NULL ||
+			    (tok == MDOC_El && !have_it))
 				break;
 
 			/*
@@ -763,10 +814,8 @@ blk_exp_close(MACRO_PROT_ARGS)
 		 * implicit ones, the first open implicit block.
 		 */
 
-		if (later &&
-		    mdoc_macros[later->tok].flags & MDOC_EXPLICIT)
-			continue;
-		if (n->tok != MDOC_It)
+		if (later == NULL ||
+		    ! (mdoc_macros[later->tok].flags & MDOC_EXPLICIT))
 			later = n;
 	}
 	rew_sub(MDOC_BODY, mdoc, tok, line, ppos);
@@ -809,7 +858,8 @@ blk_exp_close(MACRO_PROT_ARGS)
 		if (ac == ARGS_PUNCT || ac == ARGS_EOLN)
 			break;
 
-		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);
+		ntok = ac == ARGS_QWORD ? MDOC_MAX :
+		    lookup(mdoc, tok, line, lastarg, p);
 
 		if (ntok == MDOC_MAX) {
 			dword(mdoc, line, lastarg, p, DELIM_MAX,
@@ -910,7 +960,7 @@ in_line(MACRO_PROT_ARGS)
 		}
 
 		ntok = (ac == ARGS_QWORD || (tok == MDOC_Fn && !cnt)) ?
-		    MDOC_MAX : lookup(tok, p);
+		    MDOC_MAX : lookup(mdoc, tok, line, la, p);
 
 		/*
 		 * In this case, we've located a submacro and must
@@ -1025,12 +1075,12 @@ in_line(MACRO_PROT_ARGS)
 static void
 blk_full(MACRO_PROT_ARGS)
 {
-	int		  la, nl, nparsed;
+	int		  la, nl, parsed;
 	struct mdoc_arg	 *arg;
-	struct mdoc_node *head; /* save of head macro */
-	struct mdoc_node *body; /* save of body macro */
+	struct mdoc_node *blk; /* Our own block. */
+	struct mdoc_node *head; /* Our own head. */
+	struct mdoc_node *body; /* Our own body. */
 	struct mdoc_node *n;
-	enum mdoct	  ntok;
 	enum margserr	  ac, lac;
 	char		 *p;
 
@@ -1040,8 +1090,8 @@ blk_full(MACRO_PROT_ARGS)
 
 	if (tok == MDOC_It) {
 		for (n = mdoc->last; n; n = n->parent)
-			if (n->tok == MDOC_Bl &&
-			    ! (n->flags & MDOC_VALID))
+			if (n->tok == MDOC_Bl && n->type == MDOC_BLOCK &&
+			    ! (n->flags & (MDOC_VALID | MDOC_BREAK)))
 				break;
 		if (n == NULL) {
 			mandoc_vmsg(MANDOCERR_IT_STRAY, mdoc->parse,
@@ -1069,7 +1119,7 @@ blk_full(MACRO_PROT_ARGS)
 	 */
 
 	mdoc_argv(mdoc, line, tok, &arg, pos, buf);
-	mdoc_block_alloc(mdoc, line, ppos, tok, arg);
+	blk = mdoc_block_alloc(mdoc, line, ppos, tok, arg);
 	head = body = NULL;
 
 	/*
@@ -1077,9 +1127,9 @@ blk_full(MACRO_PROT_ARGS)
 	 * parsed, even though `It' macros in general are parsed.
 	 */
 
-	nparsed = tok == MDOC_It &&
-	    mdoc->last->parent->tok == MDOC_Bl &&
-	    mdoc->last->parent->norm->Bl.type == LIST_diag;
+	parsed = 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
@@ -1088,7 +1138,7 @@ blk_full(MACRO_PROT_ARGS)
 
 	if (tok == MDOC_Nd) {
 		head = mdoc_head_alloc(mdoc, line, ppos, tok);
-		rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);
+		rew_last(mdoc, head);
 		body = mdoc_body_alloc(mdoc, line, ppos, tok);
 	}
 
@@ -1160,22 +1210,17 @@ blk_full(MACRO_PROT_ARGS)
 				mdoc->flags |= MDOC_PPHRASE;
 			if (ac == ARGS_PEND && lac == ARGS_PPHRASE)
 				mdoc->flags |= MDOC_PPHRASE;
-			phrase(mdoc, line, la, buf);
+			parse_rest(mdoc, MDOC_MAX, line, &la, buf);
 			mdoc->flags &= ~MDOC_PPHRASE;
 			continue;
 		}
 
-		ntok = nparsed || ac == ARGS_QWORD ?
-		    MDOC_MAX : lookup(tok, p);
-
-		if (ntok != MDOC_MAX) {
-			mdoc_macro(mdoc, ntok, line, la, pos, buf);
+		if (macro_or_word(mdoc, tok, line, la, pos, buf, parsed))
 			break;
-		}
-		dword(mdoc, line, la, p, DELIM_MAX,
-		    MDOC_JOIN & mdoc_macros[tok].flags);
 	}
 
+	if (blk->flags & MDOC_VALID)
+		return;
 	if (head == NULL)
 		head = mdoc_head_alloc(mdoc, line, ppos, tok);
 	if (nl)
@@ -1214,7 +1259,6 @@ static void
 blk_part_imp(MACRO_PROT_ARGS)
 {
 	int		  la, nl;
-	enum mdoct	  ntok;
 	enum margserr	  ac;
 	char		 *p;
 	struct mdoc_node *blk; /* saved block context */
@@ -1233,8 +1277,7 @@ blk_part_imp(MACRO_PROT_ARGS)
 	 */
 
 	blk = mdoc_block_alloc(mdoc, line, ppos, tok, NULL);
-	mdoc_head_alloc(mdoc, line, ppos, tok);
-	rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);
+	rew_last(mdoc, mdoc_head_alloc(mdoc, line, ppos, tok));
 
 	/*
 	 * Open the body scope "on-demand", that is, after we've
@@ -1257,14 +1300,8 @@ blk_part_imp(MACRO_PROT_ARGS)
 		if (body == NULL)
 			body = mdoc_body_alloc(mdoc, line, ppos, tok);
 
-		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);
-
-		if (ntok != MDOC_MAX) {
-			mdoc_macro(mdoc, ntok, line, la, pos, buf);
+		if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))
 			break;
-		}
-		dword(mdoc, line, la, p, DELIM_MAX,
-		    MDOC_JOIN & mdoc_macros[tok].flags);
 	}
 	if (body == NULL)
 		body = mdoc_body_alloc(mdoc, line, ppos, tok);
@@ -1287,11 +1324,22 @@ blk_part_imp(MACRO_PROT_ARGS)
 		}
 	}
 	assert(n == body);
-	rew_sub(MDOC_BODY, mdoc, tok, line, ppos);
+	rew_last(mdoc, body);
 	if (nl)
 		append_delims(mdoc, line, pos, buf);
-	rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);
+	rew_last(mdoc, blk);
 
+	/*
+	 * The current block extends an enclosing block.
+	 * Now that the current block ends, close the enclosing block, too.
+	 */
+
+	while ((blk = blk->pending) != NULL) {
+		rew_last(mdoc, blk);
+		if (blk->type == MDOC_HEAD)
+			mdoc_body_alloc(mdoc, blk->line, blk->pos, blk->tok);
+	}
+
 	/* Move trailing .Ns out of scope. */
 
 	for (n = body->child; n && n->next; n = n->next)
@@ -1306,9 +1354,7 @@ blk_part_exp(MACRO_PROT_ARGS)
 	int		  la, nl;
 	enum margserr	  ac;
 	struct mdoc_node *head; /* keep track of head */
-	struct mdoc_node *body; /* keep track of body */
 	char		 *p;
-	enum mdoct	  ntok;
 
 	nl = MDOC_NEWLINE & mdoc->flags;
 
@@ -1319,7 +1365,8 @@ blk_part_exp(MACRO_PROT_ARGS)
 	 */
 
 	mdoc_block_alloc(mdoc, line, ppos, tok, NULL);
-	for (head = body = NULL; ; ) {
+	head = NULL;
+	for (;;) {
 		la = *pos;
 		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
 		if (ac == ARGS_PUNCT || ac == ARGS_EOLN)
@@ -1329,49 +1376,28 @@ blk_part_exp(MACRO_PROT_ARGS)
 
 		if (head == NULL && ac != ARGS_QWORD &&
 		    mdoc_isdelim(p) == DELIM_OPEN) {
-			assert(NULL == body);
 			dword(mdoc, line, la, p, DELIM_OPEN, 0);
 			continue;
 		}
 
 		if (head == NULL) {
-			assert(body == NULL);
 			head = mdoc_head_alloc(mdoc, line, ppos, tok);
-		}
-
-		/*
-		 * `Eo' gobbles any data into the head, but most other
-		 * macros just immediately close out and begin the body.
-		 */
-
-		if (body == NULL) {
-			assert(head);
-			/* No check whether it's a macro! */
-			if (tok == MDOC_Eo)
+			if (tok == MDOC_Eo)  /* Not parsed. */
 				dword(mdoc, line, la, p, DELIM_MAX, 0);
-			rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);
-			body = mdoc_body_alloc(mdoc, line, ppos, tok);
+			rew_last(mdoc, head);
+			mdoc_body_alloc(mdoc, line, ppos, tok);
 			if (tok == MDOC_Eo)
 				continue;
 		}
-		assert(head != NULL && body != NULL);
 
-		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);
-		if (ntok != MDOC_MAX) {
-			mdoc_macro(mdoc, ntok, line, la, pos, buf);
+		if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))
 			break;
-		}
-		dword(mdoc, line, la, p, DELIM_MAX,
-		    MDOC_JOIN & mdoc_macros[tok].flags);
 	}
 
 	/* Clean-up to leave in a consistent state. */
 
-	if (head == NULL)
-		mdoc_head_alloc(mdoc, line, ppos, tok);
-
-	if (body == NULL) {
-		rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);
+	if (head == NULL) {
+		rew_last(mdoc, mdoc_head_alloc(mdoc, line, ppos, tok));
 		mdoc_body_alloc(mdoc, line, ppos, tok);
 	}
 	if (nl)
@@ -1387,7 +1413,7 @@ in_line_argn(MACRO_PROT_ARGS)
 	char		*p;
 	enum mdoct	 ntok;
 
-	nl = MDOC_NEWLINE & mdoc->flags;
+	nl = mdoc->flags & MDOC_NEWLINE;
 
 	/*
 	 * A line macro that has a fixed number of arguments (maxargs).
@@ -1419,11 +1445,18 @@ in_line_argn(MACRO_PROT_ARGS)
 
 	mdoc_argv(mdoc, line, tok, &arg, pos, buf);
 
-	for (flushed = j = 0; ; ) {
+	p = NULL;
+	flushed = j = 0;
+	for (;;) {
 		la = *pos;
 		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
-		if (ac == ARGS_PUNCT || ac == ARGS_EOLN)
+		if (ac == ARGS_PUNCT || ac == ARGS_EOLN) {
+			if (j < 2 && tok == MDOC_Pf)
+				mandoc_vmsg(MANDOCERR_PF_SKIP,
+				    mdoc->parse, line, ppos, "Pf %s",
+				    p == NULL ? "at eol" : p);
 			break;
+		}
 
 		if ( ! (mdoc_macros[tok].flags & MDOC_IGNDELIM) &&
 		    ac != ARGS_QWORD && j == 0 &&
@@ -1438,7 +1471,8 @@ in_line_argn(MACRO_PROT_ARGS)
 			flushed = 1;
 		}
 
-		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);
+		ntok = (ac == ARGS_QWORD || (tok == MDOC_Pf && j == 0)) ?
+		    MDOC_MAX : lookup(mdoc, tok, line, la, p);
 
 		if (ntok != MDOC_MAX) {
 			if ( ! flushed)
@@ -1461,8 +1495,11 @@ in_line_argn(MACRO_PROT_ARGS)
 		j++;
 	}
 
-	if (j == 0)
+	if (j == 0) {
 		mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
+		if (ac == ARGS_PUNCT && tok == MDOC_Pf)
+			append_delims(mdoc, line, pos, buf);
+	}
 	if ( ! flushed)
 		rew_elem(mdoc, tok);
 	if (nl)
@@ -1472,42 +1509,35 @@ in_line_argn(MACRO_PROT_ARGS)
 static void
 in_line_eoln(MACRO_PROT_ARGS)
 {
-	int		 la;
-	enum margserr	 ac;
 	struct mdoc_arg	*arg;
-	char		*p;
-	enum mdoct	 ntok;
 
-	assert( ! (MDOC_PARSED & mdoc_macros[tok].flags));
-
 	if (tok == MDOC_Pp)
 		rew_sub(MDOC_BLOCK, mdoc, MDOC_Nm, line, ppos);
 
 	mdoc_argv(mdoc, line, tok, &arg, pos, buf);
 	mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
+	if (parse_rest(mdoc, tok, line, pos, buf))
+		return;
+	rew_elem(mdoc, tok);
+}
 
-	/* Parse argument terms. */
+/*
+ * The simplest argument parser available: Parse the remaining
+ * words until the end of the phrase or line and return 0
+ * or until the next macro, call that macro, and return 1.
+ */
+static int
+parse_rest(struct mdoc *mdoc, enum mdoct tok, int line, int *pos, char *buf)
+{
+	int		 la;
 
 	for (;;) {
 		la = *pos;
-		ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
-		if (ac == ARGS_EOLN)
-			break;
-
-		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);
-
-		if (ntok != MDOC_MAX) {
-			rew_elem(mdoc, tok);
-			mdoc_macro(mdoc, ntok, line, la, pos, buf);
-			return;
-		}
-		dword(mdoc, line, la, p, DELIM_MAX,
-		    MDOC_JOIN & mdoc_macros[tok].flags);
+		if (mdoc_args(mdoc, line, pos, buf, tok, NULL) == ARGS_EOLN)
+			return(0);
+		if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))
+			return(1);
 	}
-
-	/* Close out (no delimiters). */
-
-	rew_elem(mdoc, tok);
 }
 
 static void
@@ -1530,44 +1560,15 @@ ctx_synopsis(MACRO_PROT_ARGS)
  * macro is encountered.
  */
 static void
-phrase(struct mdoc *mdoc, int line, int ppos, char *buf)
-{
-	int		 la, pos;
-	enum margserr	 ac;
-	enum mdoct	 ntok;
-	char		*p;
-
-	for (pos = ppos; ; ) {
-		la = pos;
-
-		ac = mdoc_zargs(mdoc, line, &pos, buf, &p);
-		if (ac == ARGS_EOLN)
-			break;
-
-		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup_raw(p);
-
-		if (ntok != MDOC_MAX) {
-			mdoc_macro(mdoc, ntok, line, la, &pos, buf);
-			append_delims(mdoc, line, &pos, buf);
-			return;
-		}
-		dword(mdoc, line, la, p, DELIM_MAX, 1);
-	}
-}
-
-static void
 phrase_ta(MACRO_PROT_ARGS)
 {
 	struct mdoc_node *n;
-	int		  la;
-	enum mdoct	  ntok;
-	enum margserr	  ac;
-	char		 *p;
 
 	/* Make sure we are in a column list or ignore this macro. */
 
 	n = mdoc->last;
-	while (n != NULL && n->tok != MDOC_Bl)
+	while (n != NULL &&
+	    (n->tok != MDOC_Bl || n->flags & (MDOC_VALID | MDOC_BREAK)))
 		n = n->parent;
 	if (n == NULL || n->norm->Bl.type != LIST_column) {
 		mandoc_msg(MANDOCERR_TA_STRAY, mdoc->parse,
@@ -1579,21 +1580,5 @@ phrase_ta(MACRO_PROT_ARGS)
 
 	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 (ac == ARGS_EOLN)
-			break;
-
-		ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup_raw(p);
-
-		if (ntok != MDOC_MAX) {
-			mdoc_macro(mdoc, ntok, line, la, pos, buf);
-			append_delims(mdoc, line, pos, buf);
-			return;
-		}
-		dword(mdoc, line, la, p, DELIM_MAX,
-		    MDOC_JOIN & mdoc_macros[tok].flags);
-	}
+	parse_rest(mdoc, MDOC_MAX, line, pos, buf);
 }