* mandoc: Support nesting of elements with next-line scope.
@ 2018-08-26 16:21 schwarze
0 siblings, 0 replies; only message in thread
From: schwarze @ 2018-08-26 16:21 UTC (permalink / raw)
To: source
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
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2018-08-26 16:21 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-08-26 16:21 mandoc: Support nesting of elements with next-line scope schwarze
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).