From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from localhost (fantadrom.bsd.lv [local]) by fantadrom.bsd.lv (OpenSMTPD) with ESMTPA id c27ff8ac for ; Sun, 26 Aug 2018 11:21:54 -0500 (EST) Date: Sun, 26 Aug 2018 11:21:54 -0500 (EST) X-Mailinglist: mandoc-source Reply-To: source@mandoc.bsd.lv MIME-Version: 1.0 From: schwarze@mandoc.bsd.lv To: source@mandoc.bsd.lv Subject: mandoc: Support nesting of elements with next-line scope. X-Mailer: activitymail 1.26, http://search.cpan.org/dist/activitymail/ Content-Type: text/plain; charset=utf-8 Message-Id: Log Message: ----------- Support nesting of elements with next-line scope. For example, ksh93(1) needs this for .B\n.SM. Modified Files: -------------- mandoc: libman.h man.c man_macro.c man_term.c Revision Data ------------- Index: libman.h =================================================================== RCS file: /home/cvs/mandoc/mandoc/libman.h,v retrieving revision 1.82 retrieving revision 1.83 diff -Llibman.h -Llibman.h -u -p -r1.82 -r1.83 --- libman.h +++ 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 *); Index: man.c =================================================================== RCS file: /home/cvs/mandoc/mandoc/man.c,v retrieving revision 1.179 retrieving revision 1.180 diff -Lman.c -Lman.c -u -p -r1.179 -r1.180 --- man.c +++ 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, * 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, * 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 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 */ 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", Index: man_term.c =================================================================== RCS file: /home/cvs/mandoc/mandoc/man_term.c,v retrieving revision 1.219 retrieving revision 1.220 diff -Lman_term.c -Lman_term.c -u -p -r1.219 -r1.220 --- man_term.c +++ 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: Index: man_macro.c =================================================================== RCS file: /home/cvs/mandoc/mandoc/man_macro.c,v retrieving revision 1.132 retrieving revision 1.133 diff -Lman_macro.c -Lman_macro.c -u -p -r1.132 -r1.133 --- man_macro.c +++ man_macro.c @@ -41,45 +41,45 @@ static int man_args(struct roff_man *, 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 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 -- To unsubscribe send an email to source+unsubscribe@mandoc.bsd.lv