summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorIngo Schwarze <schwarze@openbsd.org>2018-08-26 16:21:23 +0000
committerIngo Schwarze <schwarze@openbsd.org>2018-08-26 16:21:23 +0000
commit6bdbb0b18d6cd5a193294913df278355deebfa02 (patch)
tree50b3607a2b46b4dfc70c4a6d01e8a289774f5c02
parent7582daff204d17b170462dc6b7f6fd218be6afc9 (diff)
downloadmandoc-6bdbb0b18d6cd5a193294913df278355deebfa02.tar.gz
Support nesting of elements with next-line scope.
For example, ksh93(1) needs this for .B\n.SM.
-rw-r--r--libman.h10
-rw-r--r--man.c36
-rw-r--r--man_macro.c67
-rw-r--r--man_term.c4
4 files changed, 61 insertions, 56 deletions
diff --git a/libman.h b/libman.h
index 89525d4e..5b279559 100644
--- a/libman.h
+++ b/libman.h
@@ -26,14 +26,16 @@
struct man_macro {
void (*fp)(MACRO_PROT_ARGS);
int flags;
-#define MAN_SCOPED (1 << 0) /* Optional next-line scope. */
-#define MAN_NSCOPED (1 << 1) /* Allowed in next-line element scope. */
-#define MAN_BSCOPE (1 << 2) /* Break next-line block scope. */
-#define MAN_JOIN (1 << 3) /* Join arguments together. */
+#define MAN_BSCOPED (1 << 0) /* Optional next-line block scope. */
+#define MAN_ESCOPED (1 << 1) /* Optional next-line element scope. */
+#define MAN_NSCOPED (1 << 2) /* Allowed in next-line element scope. */
+#define MAN_XSCOPE (1 << 3) /* Exit next-line block scope. */
+#define MAN_JOIN (1 << 4) /* Join arguments together. */
};
const struct man_macro *man_macro(enum roff_tok);
+void man_descope(struct roff_man *, int, int, char *);
void man_node_validate(struct roff_man *);
void man_state(struct roff_man *, struct roff_node *);
void man_unscope(struct roff_man *, const struct roff_node *);
diff --git a/man.c b/man.c
index a28063a0..acd3da20 100644
--- a/man.c
+++ b/man.c
@@ -35,7 +35,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);
@@ -71,23 +70,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;
@@ -243,15 +244,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. */
@@ -269,13 +266,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;
@@ -298,7 +295,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,
@@ -330,18 +328,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",
diff --git a/man_macro.c b/man_macro.c
index d27a2bd2..bc81bffb 100644
--- a/man_macro.c
+++ b/man_macro.c
@@ -41,45 +41,45 @@ static int man_args(struct roff_man *, int,
static void rew_scope(struct roff_man *, enum roff_tok);
static const struct man_macro man_macros[MAN_MAX - MAN_TH] = {
- { in_line_eoln, MAN_BSCOPE }, /* TH */
- { blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* SH */
- { blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* SS */
- { blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* TP */
- { blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* TQ */
- { blk_imp, MAN_BSCOPE }, /* LP */
- { blk_imp, MAN_BSCOPE }, /* PP */
- { blk_imp, MAN_BSCOPE }, /* P */
- { blk_imp, MAN_BSCOPE }, /* IP */
- { blk_imp, MAN_BSCOPE }, /* HP */
- { in_line_eoln, MAN_SCOPED | MAN_JOIN }, /* SM */
- { in_line_eoln, MAN_SCOPED | MAN_JOIN }, /* SB */
+ { in_line_eoln, MAN_XSCOPE }, /* TH */
+ { blk_imp, MAN_XSCOPE | MAN_BSCOPED }, /* SH */
+ { blk_imp, MAN_XSCOPE | MAN_BSCOPED }, /* SS */
+ { blk_imp, MAN_XSCOPE | MAN_BSCOPED }, /* TP */
+ { blk_imp, MAN_XSCOPE | MAN_BSCOPED }, /* TQ */
+ { blk_imp, MAN_XSCOPE }, /* LP */
+ { blk_imp, MAN_XSCOPE }, /* PP */
+ { blk_imp, MAN_XSCOPE }, /* P */
+ { blk_imp, MAN_XSCOPE }, /* IP */
+ { blk_imp, MAN_XSCOPE }, /* HP */
+ { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* SM */
+ { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* SB */
{ in_line_eoln, 0 }, /* BI */
{ in_line_eoln, 0 }, /* IB */
{ in_line_eoln, 0 }, /* BR */
{ in_line_eoln, 0 }, /* RB */
- { in_line_eoln, MAN_SCOPED | MAN_JOIN }, /* R */
- { in_line_eoln, MAN_SCOPED | MAN_JOIN }, /* B */
- { in_line_eoln, MAN_SCOPED | MAN_JOIN }, /* I */
+ { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* R */
+ { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* B */
+ { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* I */
{ in_line_eoln, 0 }, /* IR */
{ in_line_eoln, 0 }, /* RI */
{ in_line_eoln, MAN_NSCOPED }, /* nf */
{ in_line_eoln, MAN_NSCOPED }, /* fi */
- { blk_close, MAN_BSCOPE }, /* RE */
- { blk_exp, MAN_BSCOPE }, /* RS */
+ { blk_close, MAN_XSCOPE }, /* RE */
+ { blk_exp, MAN_XSCOPE }, /* RS */
{ in_line_eoln, 0 }, /* DT */
{ in_line_eoln, 0 }, /* UC */
{ in_line_eoln, MAN_NSCOPED }, /* PD */
{ in_line_eoln, 0 }, /* AT */
{ in_line_eoln, MAN_NSCOPED }, /* in */
- { blk_imp, MAN_BSCOPE }, /* SY */
- { blk_close, MAN_BSCOPE }, /* YS */
+ { blk_imp, MAN_XSCOPE }, /* SY */
+ { blk_close, MAN_XSCOPE }, /* YS */
{ in_line_eoln, 0 }, /* OP */
- { in_line_eoln, MAN_BSCOPE }, /* EX */
- { in_line_eoln, MAN_BSCOPE }, /* EE */
- { blk_exp, MAN_BSCOPE }, /* UR */
- { blk_close, MAN_BSCOPE }, /* UE */
- { blk_exp, MAN_BSCOPE }, /* MT */
- { blk_close, MAN_BSCOPE }, /* ME */
+ { in_line_eoln, MAN_XSCOPE }, /* EX */
+ { in_line_eoln, MAN_XSCOPE }, /* EE */
+ { blk_exp, MAN_XSCOPE }, /* UR */
+ { blk_close, MAN_XSCOPE }, /* UE */
+ { blk_exp, MAN_XSCOPE }, /* MT */
+ { blk_close, MAN_XSCOPE }, /* ME */
};
@@ -103,7 +103,8 @@ man_unscope(struct roff_man *man, const struct roff_node *to)
if (to == NULL && ! (n->flags & NODE_VALID)) {
if (man->flags & (MAN_BLINE | MAN_ELINE) &&
- man_macro(n->tok)->flags & MAN_SCOPED) {
+ man_macro(n->tok)->flags &
+ (MAN_BSCOPED | MAN_NSCOPED)) {
mandoc_vmsg(MANDOCERR_BLK_LINE,
man->parse, n->line, n->pos,
"EOF breaks %s", roff_name[n->tok]);
@@ -351,10 +352,10 @@ blk_imp(MACRO_PROT_ARGS)
/*
* For macros having optional next-line scope,
* keep the head open if there were no arguments.
- * For `TP', always keep the head open.
+ * For `TP' and `TQ', always keep the head open.
*/
- if (man_macro(tok)->flags & MAN_SCOPED &&
+ if (man_macro(tok)->flags & MAN_BSCOPED &&
(tok == MAN_TP || tok == MAN_TQ || n == man->last)) {
man->flags |= MAN_BLINE;
return;
@@ -409,13 +410,12 @@ in_line_eoln(MACRO_PROT_ARGS)
man->last->flags |= NODE_EOS;
/*
- * If no arguments are specified and this is MAN_SCOPED (i.e.,
+ * If no arguments are specified and this is MAN_ESCOPED (i.e.,
* next-line scoped), then set our mode to indicate that we're
* waiting for terms to load into our context.
*/
- if (n == man->last && man_macro(tok)->flags & MAN_SCOPED) {
- assert((man_macro(tok)->flags & MAN_NSCOPED) == 0);
+ if (n == man->last && man_macro(tok)->flags & MAN_ESCOPED) {
man->flags |= MAN_ELINE;
return;
}
@@ -430,6 +430,11 @@ in_line_eoln(MACRO_PROT_ARGS)
if (man->last == n)
break;
}
+
+ /* Rewind next-line scoped ancestors, if any. */
+
+ if (man_macro(tok)->flags & MAN_ESCOPED)
+ man_descope(man, line, ppos, NULL);
}
void
diff --git a/man_term.c b/man_term.c
index 1264460a..2a676945 100644
--- a/man_term.c
+++ b/man_term.c
@@ -985,7 +985,7 @@ print_man_node(DECL_ARGS)
}
act = man_term_act(n->tok);
- if ((act->flags & MAN_NOTEXT) == 0)
+ if ((act->flags & MAN_NOTEXT) == 0 && n->tok != MAN_SM)
term_fontrepl(p, TERMFONT_NONE);
c = 1;
@@ -997,7 +997,7 @@ print_man_node(DECL_ARGS)
if (act->post != NULL)
(*act->post)(p, mt, n, meta);
- if ((act->flags & MAN_NOTEXT) == 0)
+ if ((act->flags & MAN_NOTEXT) == 0 && n->tok != MAN_SM)
term_fontrepl(p, TERMFONT_NONE);
out: