===================================================================
RCS file: /cvs/mandoc/mdoc_macro.c,v
retrieving revision 1.53
retrieving revision 1.71
diff -u -p -r1.53 -r1.71
--- mandoc/mdoc_macro.c	2010/05/07 05:34:56	1.53
+++ mandoc/mdoc_macro.c	2010/05/30 21:28:30	1.71
@@ -1,4 +1,4 @@
-/*	$Id: mdoc_macro.c,v 1.53 2010/05/07 05:34:56 kristaps Exp $ */
+/*	$Id: mdoc_macro.c,v 1.71 2010/05/30 21:28:30 kristaps Exp $ */
 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -25,7 +25,9 @@
 #include <string.h>
 #include <time.h>
 
+#include "mandoc.h"
 #include "libmdoc.h"
+#include "libmandoc.h"
 
 enum	rew {
 	REWIND_REWIND,
@@ -45,9 +47,10 @@ static	int	  	obsolete(MACRO_PROT_ARGS);
 
 static	int	  	append_delims(struct mdoc *, 
 				int, int *, char *);
-static	enum mdoct	lookup(int, const char *);
+static	enum mdoct	lookup(enum mdoct, const char *);
 static	enum mdoct	lookup_raw(const char *);
-static	int	  	phrase(struct mdoc *, int, int, char *);
+static	int	  	phrase(struct mdoc *, int, int, 
+				char *, enum margserr);
 static	enum mdoct 	rew_alt(enum mdoct);
 static	int	  	rew_dobreak(enum mdoct, 
 				const struct mdoc_node *);
@@ -168,7 +171,7 @@ const	struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
 	{ in_line_eoln, 0 }, /* Hf */
 	{ obsolete, 0 }, /* Fr */
 	{ in_line_eoln, 0 }, /* Ud */
-	{ in_line_eoln, 0 }, /* Lb */
+	{ in_line, 0 }, /* Lb */
 	{ in_line_eoln, 0 }, /* Lp */ 
 	{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Lk */ 
 	{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Mt */ 
@@ -193,6 +196,7 @@ swarn(struct mdoc *mdoc, enum mdoc_type type, 
 		int line, int pos, const struct mdoc_node *p)
 {
 	const char	*n, *t, *tt;
+	int		 rc;
 
 	n = t = "<root>";
 	tt = "block";
@@ -225,13 +229,11 @@ swarn(struct mdoc *mdoc, enum mdoc_type type, 
 		break;
 	}
 
-	if ( ! (MDOC_IGN_SCOPE & mdoc->pflags))
-		return(mdoc_verr(mdoc, line, pos, 
-				"%s scope breaks %s scope of %s", 
-				tt, t, n));
-	return(mdoc_vwarn(mdoc, line, pos, 
-				"%s scope breaks %s scope of %s", 
-				tt, t, n));
+	rc = mdoc_vmsg(mdoc, MANDOCERR_SCOPE, line, pos,
+			"%s scope breaks %s of %s", tt, t, n);
+
+	/* FIXME: logic should be in driver. */
+	return(MDOC_IGN_SCOPE & mdoc->pflags ? rc : 0);
 }
 
 
@@ -254,7 +256,8 @@ mdoc_macroend(struct mdoc *m)
 			continue;
 		if ( ! (MDOC_EXPLICIT & mdoc_macros[n->tok].flags))
 			continue;
-		return(mdoc_nerr(m, n, EOPEN));
+		mdoc_nmsg(m, n, MANDOCERR_SYNTSCOPE);
+		return(0);
 	}
 
 	/* Rewind to the first. */
@@ -267,7 +270,7 @@ mdoc_macroend(struct mdoc *m)
  * Look up a macro from within a subsequent context.
  */
 static enum mdoct
-lookup(int from, const char *p)
+lookup(enum mdoct from, const char *p)
 {
 	/* FIXME: make -diag lists be un-PARSED. */
 
@@ -283,7 +286,7 @@ lookup(int from, const char *p)
 static enum mdoct
 lookup_raw(const char *p)
 {
-	int		 res;
+	enum mdoct	 res;
 
 	if (MDOC_MAX == (res = mdoc_hash_find(p)))
 		return(MDOC_MAX);
@@ -586,7 +589,9 @@ rew_sub(enum mdoc_type t, struct mdoc *m, 
 				return(1);
 			if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags))
 				return(1);
-			return(mdoc_perr(m, line, ppos, ENOCTX));
+			/* FIXME: shouldn't raise an error */
+			mdoc_pmsg(m, line, ppos, MANDOCERR_SYNTNOSCOPE);
+			return(0);
 		}
 		if (REWIND_REWIND == c)
 			break;
@@ -620,27 +625,41 @@ rew_sub(enum mdoc_type t, struct mdoc *m, 
 
 
 static int
-append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)
+append_delims(struct mdoc *m, int line, int *pos, char *buf)
 {
-	int		 lastarg;
-	enum margerr	 ac;
+	int		 la;
+	enum margserr	 ac;
 	char		*p;
 
-	if (0 == buf[*pos])
+	if ('\0' == buf[*pos])
 		return(1);
 
 	for (;;) {
-		lastarg = *pos;
-		ac = mdoc_zargs(mdoc, line, pos, buf, ARGS_NOWARN, &p);
-		assert(ARGS_PHRASE != ac);
+		la = *pos;
+		ac = mdoc_zargs(m, line, pos, buf, ARGS_NOWARN, &p);
 
 		if (ARGS_ERROR == ac)
 			return(0);
 		else if (ARGS_EOLN == ac)
 			break;
-		assert(mdoc_isdelim(p));
-		if ( ! mdoc_word_alloc(mdoc, line, lastarg, p))
+
+		assert(DELIM_NONE != mdoc_isdelim(p));
+		if ( ! mdoc_word_alloc(m, line, la, p))
 			return(0);
+
+		/*
+		 * If we encounter end-of-sentence symbols, then trigger
+		 * the double-space.
+		 *
+		 * XXX: it's easy to allow this to propogate outward to
+		 * the last symbol, such that `. )' will cause the
+		 * correct double-spacing.  However, (1) groff isn't
+		 * smart enough to do this and (2) it would require
+		 * knowing which symbols break this behaviour, for
+		 * example, `.  ;' shouldn't propogate the double-space.
+		 */
+		if (mandoc_eos(p, strlen(p)))
+			m->last->flags |= MDOC_EOS;
 	}
 
 	return(1);
@@ -653,11 +672,13 @@ append_delims(struct mdoc *mdoc, int line, int *pos, c
 static int
 blk_exp_close(MACRO_PROT_ARGS)
 {
-	int	 	 j, lastarg, maxargs, flushed;
-	enum margerr	 ac;
+	int	 	 j, lastarg, maxargs, flushed, nl;
+	enum margserr	 ac;
 	enum mdoct	 ntok;
 	char		*p;
 
+	nl = MDOC_NEWLINE & m->flags;
+
 	switch (tok) {
 	case (MDOC_Ec):
 		maxargs = 1;
@@ -668,8 +689,9 @@ blk_exp_close(MACRO_PROT_ARGS)
 	}
 
 	if ( ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) {
+		/* FIXME: do this in validate */
 		if (buf[*pos]) 
-			if ( ! mdoc_pwarn(m, line, ppos, ENOLINE))
+			if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_ARGSLOST))
 				return(0);
 
 		if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))
@@ -702,25 +724,28 @@ blk_exp_close(MACRO_PROT_ARGS)
 		if (ARGS_EOLN == ac)
 			break;
 
-		if (MDOC_MAX != (ntok = lookup(tok, p))) {
-			if ( ! flushed) {
-				if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
-					return(0);
-				flushed = 1;
-			}
-			if ( ! mdoc_macro(m, ntok, line, lastarg, pos, buf))
+		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
+
+		if (MDOC_MAX == ntok) {
+			if ( ! mdoc_word_alloc(m, line, lastarg, p))
 				return(0);
-			break;
-		} 
+			continue;
+		}
 
-		if ( ! mdoc_word_alloc(m, line, lastarg, p))
+		if ( ! flushed) {
+			if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
+				return(0);
+			flushed = 1;
+		}
+		if ( ! mdoc_macro(m, ntok, line, lastarg, pos, buf))
 			return(0);
+		break;
 	}
 
 	if ( ! flushed && ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
 		return(0);
 
-	if (ppos > 1)
+	if ( ! nl)
 		return(1);
 	return(append_delims(m, line, pos, buf));
 }
@@ -729,12 +754,16 @@ blk_exp_close(MACRO_PROT_ARGS)
 static int
 in_line(MACRO_PROT_ARGS)
 {
-	int		 la, lastpunct, c, cnt, d, nc;
+	int		 la, scope, cnt, nc, nl;
+	enum margverr	 av;
 	enum mdoct	 ntok;
-	enum margerr	 ac;
+	enum margserr	 ac;
+	enum mdelim	 d;
 	struct mdoc_arg	*arg;
 	char		*p;
 
+	nl = MDOC_NEWLINE & m->flags;
+
 	/*
 	 * Whether we allow ignored elements (those without content,
 	 * usually because of reserved words) to squeak by.
@@ -761,22 +790,22 @@ in_line(MACRO_PROT_ARGS)
 
 	for (arg = NULL;; ) {
 		la = *pos;
-		c = mdoc_argv(m, line, tok, &arg, pos, buf);
+		av = mdoc_argv(m, line, tok, &arg, pos, buf);
 
-		if (ARGV_WORD == c) {
+		if (ARGV_WORD == av) {
 			*pos = la;
 			break;
 		} 
-		if (ARGV_EOLN == c)
+		if (ARGV_EOLN == av)
 			break;
-		if (ARGV_ARG == c)
+		if (ARGV_ARG == av)
 			continue;
 
 		mdoc_argv_free(arg);
 		return(0);
 	}
 
-	for (cnt = 0, lastpunct = 1;; ) {
+	for (cnt = scope = 0;; ) {
 		la = *pos;
 		ac = mdoc_args(m, line, pos, buf, tok, &p);
 
@@ -787,8 +816,6 @@ in_line(MACRO_PROT_ARGS)
 		if (ARGS_PUNCT == ac)
 			break;
 
-		/* Quoted words shouldn't be looked-up. */
-
 		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
 
 		/* 
@@ -799,7 +826,7 @@ in_line(MACRO_PROT_ARGS)
 		 */
 
 		if (MDOC_MAX != ntok) {
-			if (0 == lastpunct && ! rew_elem(m, tok))
+			if (scope && ! rew_elem(m, tok))
 				return(0);
 			if (nc && 0 == cnt) {
 				if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
@@ -808,12 +835,12 @@ in_line(MACRO_PROT_ARGS)
 					return(0);
 			} else if ( ! nc && 0 == cnt) {
 				mdoc_argv_free(arg);
-				if ( ! mdoc_pwarn(m, line, ppos, EIGNE))
+				if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_MACROEMPTY))
 					return(0);
 			}
 			if ( ! mdoc_macro(m, ntok, line, la, pos, buf))
 				return(0);
-			if (ppos > 1)
+			if ( ! nl)
 				return(1);
 			return(append_delims(m, line, pos, buf));
 		} 
@@ -824,19 +851,40 @@ in_line(MACRO_PROT_ARGS)
 		 * the word. 
 		 */
 
-		d = ARGS_QWORD == ac ? 0 : mdoc_isdelim(p);
+		d = ARGS_QWORD == ac ? DELIM_NONE : mdoc_isdelim(p);
 
-		if (ARGS_QWORD != ac && d) {
-			if (0 == lastpunct && ! rew_elem(m, tok))
+		if (DELIM_NONE != d) {
+			/*
+			 * If we encounter closing punctuation, no word
+			 * has been omitted, 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?).
+			 */
+			if (0 == cnt && (nc || MDOC_Li == tok) && 
+					DELIM_CLOSE == d && ! scope) {
+				if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
+					return(0);
+				if (MDOC_Ar == tok || MDOC_Li == tok || 
+						MDOC_Fl == tok)
+					cnt++;
+				scope = 1;
+			}
+			/*
+			 * Close out our scope, if one is open, before
+			 * any punctuation.
+			 */
+			if (scope && ! rew_elem(m, tok))
 				return(0);
-			lastpunct = 1;
-		} else if (lastpunct) {
+			scope = 0;
+		} else if ( ! scope) {
 			if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
 				return(0);
-			lastpunct = 0;
+			scope = 1;
 		}
 
-		if ( ! d)
+		if (DELIM_NONE == d)
 			cnt++;
 		if ( ! mdoc_word_alloc(m, line, la, p))
 			return(0);
@@ -846,14 +894,14 @@ in_line(MACRO_PROT_ARGS)
 		 * word so that the `-' can be added to each one without
 		 * having to parse out spaces.
 		 */
-		if (0 == lastpunct && MDOC_Fl == tok) {
+		if (scope && MDOC_Fl == tok) {
 			if ( ! rew_elem(m, tok))
 				return(0);
-			lastpunct = 1;
+			scope = 0;
 		}
 	}
 
-	if (0 == lastpunct && ! rew_elem(m, tok))
+	if (scope && ! rew_elem(m, tok))
 		return(0);
 
 	/*
@@ -869,11 +917,11 @@ in_line(MACRO_PROT_ARGS)
 			return(0);
 	} else if ( ! nc && 0 == cnt) {
 		mdoc_argv_free(arg);
-		if ( ! mdoc_pwarn(m, line, ppos, EIGNE))
+		if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_MACROEMPTY))
 			return(0);
 	}
 
-	if (ppos > 1)
+	if ( ! nl)
 		return(1);
 	return(append_delims(m, line, pos, buf));
 }
@@ -882,7 +930,7 @@ in_line(MACRO_PROT_ARGS)
 static int
 blk_full(MACRO_PROT_ARGS)
 {
-	int		  c, la;
+	int		  la, nl;
 	struct mdoc_arg	 *arg;
 	struct mdoc_node *head; /* save of head macro */
 	struct mdoc_node *body; /* save of body macro */
@@ -890,9 +938,12 @@ blk_full(MACRO_PROT_ARGS)
 	struct mdoc_node *n;
 #endif
 	enum mdoct	  ntok;
-	enum margerr	  ac;
+	enum margserr	  ac, lac;
+	enum margverr	  av;
 	char		 *p;
 
+	nl = MDOC_NEWLINE & m->flags;
+
 	/* Close out prior implicit scope. */
 
 	if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)) {
@@ -913,16 +964,16 @@ blk_full(MACRO_PROT_ARGS)
 
 	for (arg = NULL;; ) {
 		la = *pos;
-		c = mdoc_argv(m, line, tok, &arg, pos, buf);
+		av = mdoc_argv(m, line, tok, &arg, pos, buf);
 
-		if (ARGV_WORD == c) {
+		if (ARGV_WORD == av) {
 			*pos = la;
 			break;
 		} 
 
-		if (ARGV_EOLN == c)
+		if (ARGV_EOLN == av)
 			break;
-		if (ARGV_ARG == c)
+		if (ARGV_ARG == av)
 			continue;
 
 		mdoc_argv_free(arg);
@@ -950,8 +1001,12 @@ blk_full(MACRO_PROT_ARGS)
 		body = m->last;
 	} 
 
-	for (;;) {
+	ac = ARGS_ERROR;
+	lac = ARGS_PHRASE;
+
+	for ( ; ; ) {
 		la = *pos;
+		lac = ac;
 		ac = mdoc_args(m, line, pos, buf, tok, &p);
 
 		if (ARGS_ERROR == ac)
@@ -961,9 +1016,12 @@ blk_full(MACRO_PROT_ARGS)
 
 		/* Don't emit leading punct. for phrases. */
 
-		if (NULL == head && ARGS_PHRASE != ac &&
+		if (NULL == head && 
+				ARGS_PEND != ac &&
+				ARGS_PHRASE != ac &&
+				ARGS_PPHRASE != ac &&
 				ARGS_QWORD != ac &&
-				1 == mdoc_isdelim(p)) {
+				DELIM_OPEN == mdoc_isdelim(p)) {
 			if ( ! mdoc_word_alloc(m, line, la, p))
 				return(0);
 			continue;
@@ -971,21 +1029,37 @@ blk_full(MACRO_PROT_ARGS)
 
 		/* Always re-open head for phrases. */
 
-		if (NULL == head || ARGS_PHRASE == ac) {
+		if (NULL == head || 
+				ARGS_PEND == ac ||
+				ARGS_PHRASE == ac || 
+				ARGS_PPHRASE == ac) {
 			if ( ! mdoc_head_alloc(m, line, ppos, tok))
 				return(0);
 			head = m->last;
 		}
 
-		if (ARGS_PHRASE == ac) {
-			if ( ! phrase(m, line, la, buf))
+		if (ARGS_PHRASE == ac || ARGS_PPHRASE == ac) {
+			if (ARGS_PPHRASE == ac)
+				m->flags |= MDOC_PPHRASE;
+			if (ARGS_PEND == ac && ARGS_PPHRASE == lac)
+				m->flags |= MDOC_PPHRASE;
+
+			if (ARGS_PEND == ac) {
+				if ( ! phrase(m, line, la, buf, lac))
+					return(0);
+			} else if ( ! phrase(m, line, la, buf, ac))
 				return(0);
+
+			m->flags &= ~MDOC_PPHRASE;
+
 			if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
 				return(0);
 			continue;
 		}
 
-		if (MDOC_MAX == (ntok = lookup(tok, p))) {
+		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
+
+		if (MDOC_MAX == ntok) {
 			if ( ! mdoc_word_alloc(m, line, la, p))
 				return(0);
 			continue;
@@ -1002,7 +1076,7 @@ blk_full(MACRO_PROT_ARGS)
 		head = m->last;
 	}
 	
-	if (1 == ppos && ! append_delims(m, line, pos, buf))
+	if (nl && ! append_delims(m, line, pos, buf))
 		return(0);
 
 	/* If we've already opened our body, exit now. */
@@ -1042,14 +1116,16 @@ blk_full(MACRO_PROT_ARGS)
 static int
 blk_part_imp(MACRO_PROT_ARGS)
 {
-	int		  la;
+	int		  la, nl;
 	enum mdoct	  ntok;
-	enum margerr	  ac;
+	enum margserr	  ac;
 	char		 *p;
 	struct mdoc_node *blk; /* saved block context */
 	struct mdoc_node *body; /* saved body context */
 	struct mdoc_node *n;
 
+	nl = MDOC_NEWLINE & m->flags;
+
 	/*
 	 * A macro that spans to the end of the line.  This is generally
 	 * (but not necessarily) called as the first macro.  The block
@@ -1079,8 +1155,6 @@ blk_part_imp(MACRO_PROT_ARGS)
 		la = *pos;
 		ac = mdoc_args(m, line, pos, buf, tok, &p);
 
-		assert(ARGS_PHRASE != ac);
-
 		if (ARGS_ERROR == ac)
 			return(0);
 		if (ARGS_EOLN == ac)
@@ -1089,7 +1163,7 @@ blk_part_imp(MACRO_PROT_ARGS)
 			break;
 
 		if (NULL == body && ARGS_QWORD != ac &&
-				1 == mdoc_isdelim(p)) {
+		    DELIM_OPEN == mdoc_isdelim(p)) {
 			if ( ! mdoc_word_alloc(m, line, la, p))
 				return(0);
 			continue;
@@ -1101,7 +1175,9 @@ blk_part_imp(MACRO_PROT_ARGS)
 			body = m->last;
 		}
 
-		if (MDOC_MAX == (ntok = lookup(tok, p))) {
+		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
+
+		if (MDOC_MAX == ntok) {
 			if ( ! mdoc_word_alloc(m, line, la, p))
 				return(0);
 			continue;
@@ -1120,17 +1196,38 @@ blk_part_imp(MACRO_PROT_ARGS)
 		body = m->last;
 	}
 
+	for (n = body->child; n && n->next; n = n->next)
+		/* Do nothing. */ ;
+	
 	/* 
+	 * End of sentence spacing: if the last node is a text node and
+	 * has a trailing period, then mark it as being end-of-sentence.
+	 */
+
+	if (n && MDOC_TEXT == n->type && n->string)
+		if (mandoc_eos(n->string, strlen(n->string)))
+			n->flags |= MDOC_EOS;
+
+	/* Up-propogate the end-of-space flag. */
+
+	if (n && (MDOC_EOS & n->flags)) {
+		body->flags |= MDOC_EOS;
+		body->parent->flags |= MDOC_EOS;
+	}
+
+	/* 
 	 * 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.
+	 *
+	 * FIXME - this should be ifdef'd OpenBSD?
 	 */
 	for (n = m->last; n; n = n->parent)
 		if (body == n)
 			break;
 
-	if (NULL == n && ! mdoc_nwarn(m, body, EIMPBRK))
+	if (NULL == n && ! mdoc_nmsg(m, body, MANDOCERR_SCOPE))
 		return(0);
 
 	if (n && ! rew_last(m, body))
@@ -1138,7 +1235,7 @@ blk_part_imp(MACRO_PROT_ARGS)
 
 	/* Standard appending of delimiters. */
 
-	if (1 == ppos && ! append_delims(m, line, pos, buf))
+	if (nl && ! append_delims(m, line, pos, buf))
 		return(0);
 
 	/* Rewind scope, if applicable. */
@@ -1153,13 +1250,15 @@ blk_part_imp(MACRO_PROT_ARGS)
 static int
 blk_part_exp(MACRO_PROT_ARGS)
 {
-	int		  la;
-	enum margerr	  ac;
+	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 & m->flags;
+
 	/*
 	 * The opening of an explicit macro having zero or more leading
 	 * punctuation nodes; a head with optional single element (the
@@ -1180,12 +1279,10 @@ blk_part_exp(MACRO_PROT_ARGS)
 		if (ARGS_EOLN == ac)
 			break;
 
-		assert(ARGS_PHRASE != ac);
-
 		/* Flush out leading punctuation. */
 
 		if (NULL == head && ARGS_QWORD != ac &&
-				1 == mdoc_isdelim(p)) {
+		    DELIM_OPEN == mdoc_isdelim(p)) {
 			assert(NULL == body);
 			if ( ! mdoc_word_alloc(m, line, la, p))
 				return(0);
@@ -1223,7 +1320,9 @@ blk_part_exp(MACRO_PROT_ARGS)
 
 		assert(NULL != head && NULL != body);
 
-		if (MDOC_MAX == (ntok = lookup(tok, p))) {
+		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
+
+		if (MDOC_MAX == ntok) {
 			if ( ! mdoc_word_alloc(m, line, la, p))
 				return(0);
 			continue;
@@ -1252,22 +1351,25 @@ blk_part_exp(MACRO_PROT_ARGS)
 
 	/* Standard appending of delimiters. */
 
-	if (ppos > 1)
+	if ( ! nl)
 		return(1);
-
 	return(append_delims(m, line, pos, buf));
 }
 
 
+/* ARGSUSED */
 static int
 in_line_argn(MACRO_PROT_ARGS)
 {
-	int		 la, flushed, j, c, maxargs;
-	enum margerr	 ac;
+	int		 la, flushed, j, maxargs, nl;
+	enum margserr	 ac;
+	enum margverr	 av;
 	struct mdoc_arg	*arg;
 	char		*p;
 	enum mdoct	 ntok;
 
+	nl = MDOC_NEWLINE & m->flags;
+
 	/*
 	 * A line macro that has a fixed number of arguments (maxargs).
 	 * Only open the scope once the first non-leading-punctuation is
@@ -1296,16 +1398,16 @@ in_line_argn(MACRO_PROT_ARGS)
 
 	for (arg = NULL; ; ) {
 		la = *pos;
-		c = mdoc_argv(m, line, tok, &arg, pos, buf);
+		av = mdoc_argv(m, line, tok, &arg, pos, buf);
 
-		if (ARGV_WORD == c) {
+		if (ARGV_WORD == av) {
 			*pos = la;
 			break;
 		} 
 
-		if (ARGV_EOLN == c)
+		if (ARGV_EOLN == av)
 			break;
-		if (ARGV_ARG == c)
+		if (ARGV_ARG == av)
 			continue;
 
 		mdoc_argv_free(arg);
@@ -1325,7 +1427,7 @@ in_line_argn(MACRO_PROT_ARGS)
 
 		if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) && 
 				ARGS_QWORD != ac &&
-				0 == j && 1 == mdoc_isdelim(p)) {
+				0 == j && DELIM_OPEN == mdoc_isdelim(p)) {
 			if ( ! mdoc_word_alloc(m, line, la, p))
 				return(0);
 			continue;
@@ -1339,7 +1441,9 @@ in_line_argn(MACRO_PROT_ARGS)
 			flushed = 1;
 		}
 
-		if (MDOC_MAX != (ntok = lookup(tok, p))) {
+		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup(tok, p);
+
+		if (MDOC_MAX != ntok) {
 			if ( ! flushed && ! rew_elem(m, tok))
 				return(0);
 			flushed = 1;
@@ -1351,7 +1455,8 @@ in_line_argn(MACRO_PROT_ARGS)
 
 		if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) &&
 				ARGS_QWORD != ac &&
-				! flushed && mdoc_isdelim(p)) {
+				! flushed &&
+				DELIM_NONE != mdoc_isdelim(p)) {
 			if ( ! rew_elem(m, tok))
 				return(0);
 			flushed = 1;
@@ -1385,8 +1490,7 @@ in_line_argn(MACRO_PROT_ARGS)
 
 	if ( ! flushed && ! rew_elem(m, tok))
 		return(0);
-
-	if (ppos > 1)
+	if ( ! nl)
 		return(1);
 	return(append_delims(m, line, pos, buf));
 }
@@ -1395,8 +1499,9 @@ in_line_argn(MACRO_PROT_ARGS)
 static int
 in_line_eoln(MACRO_PROT_ARGS)
 {
-	int		 c, la;
-	enum margerr	 ac;
+	int		 la;
+	enum margserr	 ac;
+	enum margverr	 av;
 	struct mdoc_arg	*arg;
 	char		*p;
 	enum mdoct	 ntok;
@@ -1407,15 +1512,15 @@ in_line_eoln(MACRO_PROT_ARGS)
 
 	for (arg = NULL; ; ) {
 		la = *pos;
-		c = mdoc_argv(m, line, tok, &arg, pos, buf);
+		av = mdoc_argv(m, line, tok, &arg, pos, buf);
 
-		if (ARGV_WORD == c) {
+		if (ARGV_WORD == av) {
 			*pos = la;
 			break;
 		}
-		if (ARGV_EOLN == c) 
+		if (ARGV_EOLN == av) 
 			break;
-		if (ARGV_ARG == c)
+		if (ARGV_ARG == av)
 			continue;
 
 		mdoc_argv_free(arg);
@@ -1461,13 +1566,16 @@ in_line_eoln(MACRO_PROT_ARGS)
 static int
 ctx_synopsis(MACRO_PROT_ARGS)
 {
+	int		 nl;
 
+	nl = MDOC_NEWLINE & m->flags;
+
 	/* If we're not in the SYNOPSIS, go straight to in-line. */
 	if (SEC_SYNOPSIS != m->lastsec)
 		return(in_line(m, tok, line, ppos, pos, buf));
 
 	/* If we're a nested call, same place. */
-	if (ppos > 1)
+	if ( ! nl)
 		return(in_line(m, tok, line, ppos, pos, buf));
 
 	/*
@@ -1485,7 +1593,7 @@ static int
 obsolete(MACRO_PROT_ARGS)
 {
 
-	return(mdoc_pwarn(m, line, ppos, EOBS));
+	return(mdoc_pmsg(m, line, ppos, MANDOCERR_MACROOBS));
 }
 
 
@@ -1495,25 +1603,26 @@ obsolete(MACRO_PROT_ARGS)
  * macro is encountered.
  */
 static int
-phrase(struct mdoc *m, int line, int ppos, char *buf)
+phrase(struct mdoc *m, int line, int ppos, char *buf, enum margserr ac)
 {
 	int		 la, pos;
-	enum margerr	 ac;
+	enum margserr	 aac;
 	enum mdoct	 ntok;
 	char		*p;
 
+	assert(ARGS_PHRASE == ac || ARGS_PPHRASE == ac);
+
 	for (pos = ppos; ; ) {
 		la = pos;
 
-		/* Note: no calling context! */
-		ac = mdoc_zargs(m, line, &pos, buf, 0, &p);
+		aac = mdoc_zargs(m, line, &pos, buf, 0, &p);
 
-		if (ARGS_ERROR == ac)
+		if (ARGS_ERROR == aac)
 			return(0);
-		if (ARGS_EOLN == ac)
+		if (ARGS_EOLN == aac)
 			break;
 
-		ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup_raw(p);
+		ntok = ARGS_QWORD == aac ? MDOC_MAX : lookup_raw(p);
 
 		if (MDOC_MAX == ntok) {
 			if ( ! mdoc_word_alloc(m, line, la, p))