Support nesting of elements with next-line scope.

For example, ksh93(1) needs this for .B\n.SM.

1 files changed, 18 insertions, 20 deletions

diff --git a/usr.bin/mandoc/man.c b/usr.bin/mandoc/man.c
index 7eb8458497d..cb48cfb3092 100644
--- a/usr.bin/mandoc/man.c
+++ b/usr.bin/mandoc/man.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: man.c,v 1.127 2018/08/25 12:28:52 schwarze Exp $ */
+/*	$OpenBSD: man.c,v 1.128 2018/08/26 16:18:38 schwarze Exp $ */
 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2013,2014,2015,2017,2018 Ingo Schwarze <schwarze@openbsd.org>
@@ -33,7 +33,6 @@
 #include "roff_int.h"
 #include "libman.h"
 
-static	void		 man_descope(struct roff_man *, int, int, char *);
 static	char		*man_hasc(char *);
 static	int		 man_ptext(struct roff_man *, int, char *, int);
 static	int		 man_pmacro(struct roff_man *, int, char *, int);
@@ -69,23 +68,25 @@ man_hasc(char *start)
 	return (ep - cp) % 2 ? NULL : ep;
 }
 
-static void
+void
 man_descope(struct roff_man *man, int line, int offs, char *start)
 {
 	/* Trailing \c keeps next-line scope open. */
 
-	if (man_hasc(start) != NULL)
+	if (start != NULL && man_hasc(start) != NULL)
 		return;
 
 	/*
 	 * Co-ordinate what happens with having a next-line scope open:
-	 * first close out the element scope (if applicable), then close
-	 * out the block scope (also if applicable).
+	 * first close out the element scopes (if applicable),
+	 * then close out the block scope (also if applicable).
 	 */
 
 	if (man->flags & MAN_ELINE) {
+		while (man->last->parent->type != ROFFT_ROOT &&
+		    man_macro(man->last->parent->tok)->flags & MAN_ESCOPED)
+			man_unscope(man, man->last->parent);
 		man->flags &= ~MAN_ELINE;
-		man_unscope(man, man->last->parent);
 	}
 	if ( ! (man->flags & MAN_BLINE))
 		return;
@@ -241,15 +242,11 @@ man_pmacro(struct roff_man *man, int ln, char *buf, int offs)
 	 * page, that's very likely what the author intended.
 	 */
 
-	if (bline) {
-		cp = strchr(buf + offs, '\0') - 2;
-		if (cp >= buf && cp[0] == '\\' && cp[1] == 'c')
-			bline = 0;
-	}
+	if (bline && man_hasc(buf + offs))
+		bline = 0;
 
 	/* Call to handler... */
 
-	assert(man_macro(tok)->fp != NULL);
 	(*man_macro(tok)->fp)(man, tok, ln, ppos, &offs, buf);
 
 	/* In quick mode (for mandocdb), abort after the NAME section. */
@@ -267,13 +264,13 @@ man_pmacro(struct roff_man *man, int ln, char *buf, int offs)
 	 * unless the next-line scope is allowed to continue.
 	 */
 
-	if ( ! bline || man->flags & MAN_ELINE ||
+	if (bline == 0 ||
+	    (man->flags & MAN_BLINE) == 0 ||
+	    man->flags & MAN_ELINE ||
 	    man_macro(tok)->flags & MAN_NSCOPED)
 		return 1;
 
-	assert(man->flags & MAN_BLINE);
 	man->flags &= ~MAN_BLINE;
-
 	man_unscope(man, man->last->parent);
 	roff_body_alloc(man, ln, ppos, man->last->tok);
 	return 1;
@@ -296,7 +293,8 @@ man_breakscope(struct roff_man *man, int tok)
 		if (n->type == ROFFT_TEXT)
 			n = n->parent;
 		if (n->tok < MAN_TH ||
-		    man_macro(n->tok)->flags & MAN_NSCOPED)
+		    (man_macro(n->tok)->flags & (MAN_NSCOPED | MAN_ESCOPED))
+		     == MAN_NSCOPED)
 			n = n->parent;
 
 		mandoc_vmsg(MANDOCERR_BLK_LINE, man->parse,
@@ -328,18 +326,18 @@ man_breakscope(struct roff_man *man, int tok)
 	 */
 
 	if (man->flags & MAN_BLINE && (tok < MAN_TH ||
-	    man_macro(tok)->flags & MAN_BSCOPE)) {
+	    man_macro(tok)->flags & MAN_XSCOPE)) {
 		n = man->last;
 		if (n->type == ROFFT_TEXT)
 			n = n->parent;
 		if (n->tok < MAN_TH ||
-		    (man_macro(n->tok)->flags & MAN_BSCOPE) == 0)
+		    (man_macro(n->tok)->flags & MAN_XSCOPE) == 0)
 			n = n->parent;
 
 		assert(n->type == ROFFT_HEAD);
 		n = n->parent;
 		assert(n->type == ROFFT_BLOCK);
-		assert(man_macro(n->tok)->flags & MAN_SCOPED);
+		assert(man_macro(n->tok)->flags & MAN_BSCOPED);
 
 		mandoc_vmsg(MANDOCERR_BLK_LINE, man->parse,
 		    n->line, n->pos, "%s breaks %s",