=================================================================== RCS file: /cvs/mandoc/mdoc_term.c,v retrieving revision 1.367 retrieving revision 1.378 diff -u -p -r1.367 -r1.378 --- mandoc/mdoc_term.c 2018/04/11 17:11:13 1.367 +++ mandoc/mdoc_term.c 2020/02/27 21:43:44 1.378 @@ -1,7 +1,7 @@ -/* $Id: mdoc_term.c,v 1.367 2018/04/11 17:11:13 schwarze Exp $ */ +/* $Id: mdoc_term.c,v 1.378 2020/02/27 21:43:44 schwarze Exp $ */ /* * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons - * Copyright (c) 2010, 2012-2018 Ingo Schwarze + * Copyright (c) 2010, 2012-2020 Ingo Schwarze * Copyright (c) 2013 Franco Fichtner * * Permission to use, copy, modify, and distribute this software for any @@ -29,7 +29,6 @@ #include #include "mandoc_aux.h" -#include "mandoc.h" #include "roff.h" #include "mdoc.h" #include "out.h" @@ -47,7 +46,7 @@ struct termpair { const struct roff_meta *meta, \ struct roff_node *n -struct termact { +struct mdoc_term_act { int (*pre)(DECL_ARGS); void (*post)(DECL_ARGS); }; @@ -55,14 +54,12 @@ struct termact { static int a2width(const struct termp *, const char *); static void print_bvspace(struct termp *, - const struct roff_node *, - const struct roff_node *); + struct roff_node *, struct roff_node *); static void print_mdoc_node(DECL_ARGS); static void print_mdoc_nodelist(DECL_ARGS); static void print_mdoc_head(struct termp *, const struct roff_meta *); static void print_mdoc_foot(struct termp *, const struct roff_meta *); -static void synopsis_pre(struct termp *, - const struct roff_node *); +static void synopsis_pre(struct termp *, struct roff_node *); static void termp____post(DECL_ARGS); static void termp__t_post(DECL_ARGS); @@ -84,6 +81,7 @@ static void termp_xx_post(DECL_ARGS); static int termp__a_pre(DECL_ARGS); static int termp__t_pre(DECL_ARGS); +static int termp_abort_pre(DECL_ARGS); static int termp_an_pre(DECL_ARGS); static int termp_ap_pre(DECL_ARGS); static int termp_bd_pre(DECL_ARGS); @@ -124,7 +122,7 @@ static int termp_vt_pre(DECL_ARGS); static int termp_xr_pre(DECL_ARGS); static int termp_xx_pre(DECL_ARGS); -static const struct termact __termacts[MDOC_MAX - MDOC_Dd] = { +static const struct mdoc_term_act mdoc_term_acts[MDOC_MAX - MDOC_Dd] = { { NULL, NULL }, /* Dd */ { NULL, NULL }, /* Dt */ { NULL, NULL }, /* Os */ @@ -159,7 +157,7 @@ static const struct termact __termacts[MDOC_MAX - MDOC { termp_nd_pre, NULL }, /* Nd */ { termp_nm_pre, termp_nm_post }, /* Nm */ { termp_quote_pre, termp_quote_post }, /* Op */ - { termp_ft_pre, NULL }, /* Ot */ + { termp_abort_pre, NULL }, /* Ot */ { termp_under_pre, NULL }, /* Pa */ { termp_ex_pre, NULL }, /* Rv */ { NULL, NULL }, /* St */ @@ -232,7 +230,7 @@ static const struct termact __termacts[MDOC_MAX - MDOC { termp_under_pre, NULL }, /* Fr */ { NULL, NULL }, /* Ud */ { NULL, termp_lb_post }, /* Lb */ - { termp_pp_pre, NULL }, /* Lp */ + { termp_abort_pre, NULL }, /* Lp */ { termp_lk_pre, NULL }, /* Lk */ { termp_under_pre, NULL }, /* Mt */ { termp_quote_pre, termp_quote_post }, /* Brq */ @@ -245,16 +243,16 @@ static const struct termact __termacts[MDOC_MAX - MDOC { NULL, termp____post }, /* %Q */ { NULL, termp____post }, /* %U */ { NULL, NULL }, /* Ta */ + { termp_skip_pre, NULL }, /* Tg */ }; -static const struct termact *const termacts = __termacts - MDOC_Dd; -static int fn_prio; +static int fn_prio = TAG_STRONG; void -terminal_mdoc(void *arg, const struct roff_man *mdoc) +terminal_mdoc(void *arg, const struct roff_meta *mdoc) { - struct roff_node *n; + struct roff_node *n, *nn; struct termp *p; size_t save_defindent; @@ -266,23 +264,25 @@ terminal_mdoc(void *arg, const struct roff_man *mdoc) n = mdoc->first->child; if (p->synopsisonly) { - while (n != NULL) { - if (n->tok == MDOC_Sh && n->sec == SEC_SYNOPSIS) { - if (n->child->next->child != NULL) - print_mdoc_nodelist(p, NULL, - &mdoc->meta, - n->child->next->child); - term_newln(p); + for (nn = NULL; n != NULL; n = n->next) { + if (n->tok != MDOC_Sh) + continue; + if (n->sec == SEC_SYNOPSIS) break; - } - n = n->next; + if (nn == NULL && n->sec == SEC_NAME) + nn = n; } + if (n == NULL) + n = nn; + p->flags |= TERMP_NOSPACE; + if (n != NULL && (n = n->child->next->child) != NULL) + print_mdoc_nodelist(p, NULL, mdoc, n); + term_newln(p); } else { save_defindent = p->defindent; if (p->defindent == 0) p->defindent = 5; - term_begin(p, print_mdoc_head, print_mdoc_foot, - &mdoc->meta); + term_begin(p, print_mdoc_head, print_mdoc_foot, mdoc); while (n != NULL && (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)) @@ -290,7 +290,7 @@ terminal_mdoc(void *arg, const struct roff_man *mdoc) if (n != NULL) { if (n->tok != MDOC_Sh) term_vspace(p); - print_mdoc_nodelist(p, NULL, &mdoc->meta, n); + print_mdoc_nodelist(p, NULL, mdoc, n); } term_end(p); p->defindent = save_defindent; @@ -310,10 +310,24 @@ print_mdoc_nodelist(DECL_ARGS) static void print_mdoc_node(DECL_ARGS) { - int chld; + const struct mdoc_term_act *act; struct termpair npair; size_t offset, rmargin; + int chld; + /* + * In no-fill mode, break the output line at the beginning + * of new input lines except after \c, and nowhere else. + */ + + if (n->flags & NODE_NOFILL) { + if (n->flags & NODE_LINE && + (p->flags & TERMP_NONEWLINE) == 0) + term_newln(p); + p->flags |= TERMP_BRNEVER; + } else + p->flags &= ~TERMP_BRNEVER; + if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT) return; @@ -326,6 +340,10 @@ print_mdoc_node(DECL_ARGS) memset(&npair, 0, sizeof(struct termpair)); npair.ppair = pair; + if (n->flags & NODE_ID) + tag_put(n->string == NULL ? n->child->string : n->string, + TAG_MANUAL, p->line); + /* * Keeps only work until the end of a line. If a keep was * invoked in a prior line, revert it to PREKEEP. @@ -341,11 +359,25 @@ print_mdoc_node(DECL_ARGS) * produce output. Note that some pre-handlers do so. */ + act = NULL; switch (n->type) { case ROFFT_TEXT: - if (*n->string == ' ' && n->flags & NODE_LINE && - (p->flags & TERMP_NONEWLINE) == 0) - term_newln(p); + if (n->flags & NODE_LINE) { + switch (*n->string) { + case '\0': + if (p->flags & TERMP_NONEWLINE) + term_newln(p); + else + term_vspace(p); + return; + case ' ': + if ((p->flags & TERMP_NONEWLINE) == 0) + term_newln(p); + break; + default: + break; + } + } if (NODE_DELIMC & n->flags) p->flags |= TERMP_NOSPACE; term_word(p, n->string); @@ -370,10 +402,10 @@ print_mdoc_node(DECL_ARGS) return; } assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX); - if (termacts[n->tok].pre != NULL && + act = mdoc_term_acts + (n->tok - MDOC_Dd); + if (act->pre != NULL && (n->end == ENDBODY_NOT || n->child != NULL)) - chld = (*termacts[n->tok].pre) - (p, &npair, meta, n); + chld = (*act->pre)(p, &npair, meta, n); break; } @@ -391,9 +423,9 @@ print_mdoc_node(DECL_ARGS) case ROFFT_EQN: break; default: - if (termacts[n->tok].post == NULL || n->flags & NODE_ENDED) + if (act->post == NULL || n->flags & NODE_ENDED) break; - (void)(*termacts[n->tok].post)(p, &npair, meta, n); + (void)(*act->post)(p, &npair, meta, n); /* * Explicit end tokens not only call the post @@ -551,29 +583,20 @@ a2width(const struct termp *p, const char *v) * too. */ static void -print_bvspace(struct termp *p, - const struct roff_node *bl, - const struct roff_node *n) +print_bvspace(struct termp *p, struct roff_node *bl, struct roff_node *n) { - const struct roff_node *nn; + struct roff_node *nn; - assert(n); - term_newln(p); - if (MDOC_Bd == bl->tok && bl->norm->Bd.comp) + if ((bl->tok == MDOC_Bd && bl->norm->Bd.comp) || + (bl->tok == MDOC_Bl && bl->norm->Bl.comp)) return; - if (MDOC_Bl == bl->tok && bl->norm->Bl.comp) - return; /* Do not vspace directly after Ss/Sh. */ nn = n; - while (nn->prev != NULL && - (nn->prev->type == ROFFT_COMMENT || - nn->prev->flags & NODE_NOPRT)) - nn = nn->prev; - while (nn->prev == NULL) { + while (roff_node_prev(nn) == NULL) { do { nn = nn->parent; if (nn->type == ROFFT_ROOT) @@ -586,22 +609,18 @@ print_bvspace(struct termp *p, break; } - /* A `-column' does not assert vspace within the list. */ + /* + * No vertical space after: + * items in .Bl -column + * items without a body in .Bl -diag + */ - if (MDOC_Bl == bl->tok && LIST_column == bl->norm->Bl.type) - if (n->prev && MDOC_It == n->prev->tok) - return; - - /* A `-diag' without body does not vspace. */ - - if (MDOC_Bl == bl->tok && LIST_diag == bl->norm->Bl.type) - if (n->prev && MDOC_It == n->prev->tok) { - assert(n->prev->body); - if (NULL == n->prev->body->child) - return; - } - - term_vspace(p); + if (bl->tok != MDOC_Bl || + n->prev == NULL || n->prev->tok != MDOC_It || + (bl->norm->Bl.type != LIST_column && + (bl->norm->Bl.type != LIST_diag || + n->prev->body->child != NULL))) + term_vspace(p); } @@ -1012,15 +1031,16 @@ termp_nm_post(DECL_ARGS) static int termp_fl_pre(DECL_ARGS) { + struct roff_node *nn; termp_tag_pre(p, pair, meta, n); term_fontpush(p, TERMFONT_BOLD); term_word(p, "\\-"); - if (!(n->child == NULL && - (n->next == NULL || - n->next->type == ROFFT_TEXT || - n->next->flags & NODE_LINE))) + if (n->child != NULL || + ((nn = roff_node_next(n)) != NULL && + nn->type != ROFFT_TEXT && + (nn->flags & NODE_LINE) == 0)) p->flags |= TERMP_NOSPACE; return 1; @@ -1029,10 +1049,11 @@ termp_fl_pre(DECL_ARGS) static int termp__a_pre(DECL_ARGS) { + struct roff_node *nn; - if (n->prev && MDOC__A == n->prev->tok) - if (NULL == n->next || MDOC__A != n->next->tok) - term_word(p, "and"); + if ((nn = roff_node_prev(n)) != NULL && nn->tok == MDOC__A && + ((nn = roff_node_next(n)) == NULL || nn->tok != MDOC__A)) + term_word(p, "and"); return 1; } @@ -1073,10 +1094,9 @@ termp_ns_pre(DECL_ARGS) static int termp_rs_pre(DECL_ARGS) { - if (SEC_SEE_ALSO != n->sec) return 1; - if (n->type == ROFFT_BLOCK && n->prev != NULL) + if (n->type == ROFFT_BLOCK && roff_node_prev(n) != NULL) term_vspace(p); return 1; } @@ -1150,13 +1170,12 @@ termp_xr_pre(DECL_ARGS) * macro combos). */ static void -synopsis_pre(struct termp *p, const struct roff_node *n) +synopsis_pre(struct termp *p, struct roff_node *n) { - /* - * Obviously, if we're not in a SYNOPSIS or no prior macros - * exist, do nothing. - */ - if (NULL == n->prev || ! (NODE_SYNPRETTY & n->flags)) + struct roff_node *np; + + if ((n->flags & NODE_SYNPRETTY) == 0 || + (np = roff_node_prev(n)) == NULL) return; /* @@ -1164,7 +1183,7 @@ synopsis_pre(struct termp *p, const struct roff_node * * newline and return. UNLESS we're `Fo', `Fn', `Fn', in which * case we soldier on. */ - if (n->prev->tok == n->tok && + if (np->tok == n->tok && MDOC_Ft != n->tok && MDOC_Fo != n->tok && MDOC_Fn != n->tok) { @@ -1177,7 +1196,7 @@ synopsis_pre(struct termp *p, const struct roff_node * * another (or Fn/Fo, which we've let slip through) then assert * vertical space, else only newline and move on. */ - switch (n->prev->tok) { + switch (np->tok) { case MDOC_Fd: case MDOC_Fn: case MDOC_Fo: @@ -1186,7 +1205,7 @@ synopsis_pre(struct termp *p, const struct roff_node * term_vspace(p); break; case MDOC_Ft: - if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) { + if (n->tok != MDOC_Fn && n->tok != MDOC_Fo) { term_vspace(p); break; } @@ -1240,6 +1259,7 @@ termp_fd_post(DECL_ARGS) static int termp_sh_pre(DECL_ARGS) { + struct roff_node *np; switch (n->type) { case ROFFT_BLOCK: @@ -1247,10 +1267,9 @@ termp_sh_pre(DECL_ARGS) * Vertical space before sections, except * when the previous section was empty. */ - if (n->prev == NULL || - n->prev->tok != MDOC_Sh || - (n->prev->body != NULL && - n->prev->body->child != NULL)) + if ((np = roff_node_prev(n)) == NULL || + np->tok != MDOC_Sh || + (np->body != NULL && np->body->child != NULL)) term_vspace(p); break; case ROFFT_HEAD: @@ -1263,7 +1282,7 @@ termp_sh_pre(DECL_ARGS) term_tab_set(p, ".5i"); switch (n->sec) { case SEC_DESCRIPTION: - fn_prio = 0; + fn_prio = TAG_STRONG; break; case SEC_AUTHORS: p->flags &= ~(TERMP_SPLIT|TERMP_NOSPLIT); @@ -1352,7 +1371,7 @@ termp_fn_pre(DECL_ARGS) term_fontpop(p); if (n->sec == SEC_DESCRIPTION || n->sec == SEC_CUSTOM) - tag_put(n->string, ++fn_prio, p->line); + tag_put(n->string, fn_prio++, p->line); if (pretty) { term_flushln(p); @@ -1401,27 +1420,28 @@ termp_fa_pre(DECL_ARGS) term_fontpush(p, TERMFONT_UNDER); return 1; } - - for (nn = n->child; nn; nn = nn->next) { + for (nn = n->child; nn != NULL; nn = nn->next) { term_fontpush(p, TERMFONT_UNDER); p->flags |= TERMP_NBRWORD; term_word(p, nn->string); term_fontpop(p); - - if (nn->next || (n->next && n->next->tok == MDOC_Fa)) { + if (nn->next != NULL) { p->flags |= TERMP_NOSPACE; term_word(p, ","); } } - + if (n->child != NULL && + (nn = roff_node_next(n)) != NULL && + nn->tok == MDOC_Fa) { + p->flags |= TERMP_NOSPACE; + term_word(p, ","); + } return 0; } static int termp_bd_pre(DECL_ARGS) { - size_t lm, len; - struct roff_node *nn; int offset; if (n->type == ROFFT_BLOCK) { @@ -1447,66 +1467,19 @@ termp_bd_pre(DECL_ARGS) p->tcol->offset += offset; } - /* - * If -ragged or -filled are specified, the block does nothing - * but change the indentation. If -unfilled or -literal are - * specified, text is printed exactly as entered in the display: - * for macro lines, a newline is appended to the line. Blank - * lines are allowed. - */ - - if (n->norm->Bd.type != DISP_literal && - n->norm->Bd.type != DISP_unfilled && - n->norm->Bd.type != DISP_centered) - return 1; - - if (n->norm->Bd.type == DISP_literal) { + switch (n->norm->Bd.type) { + case DISP_literal: term_tab_set(p, NULL); term_tab_set(p, "T"); term_tab_set(p, "8n"); + break; + case DISP_centered: + p->flags |= TERMP_CENTER; + break; + default: + break; } - - lm = p->tcol->offset; - p->flags |= TERMP_BRNEVER; - for (nn = n->child; nn != NULL; nn = nn->next) { - if (n->norm->Bd.type == DISP_centered) { - if (nn->type == ROFFT_TEXT) { - len = term_strlen(p, nn->string); - p->tcol->offset = len >= p->tcol->rmargin ? - 0 : lm + len >= p->tcol->rmargin ? - p->tcol->rmargin - len : - (lm + p->tcol->rmargin - len) / 2; - } else - p->tcol->offset = lm; - } - print_mdoc_node(p, pair, meta, nn); - /* - * If the printed node flushes its own line, then we - * needn't do it here as well. This is hacky, but the - * notion of selective eoln whitespace is pretty dumb - * anyway, so don't sweat it. - */ - if (nn->tok < ROFF_MAX) - continue; - switch (nn->tok) { - case MDOC_Sm: - case MDOC_Bl: - case MDOC_D1: - case MDOC_Dl: - case MDOC_Lp: - case MDOC_Pp: - continue; - default: - break; - } - if (p->flags & TERMP_NONEWLINE || - (nn->next && ! (nn->next->flags & NODE_LINE))) - continue; - term_flushln(p); - p->flags |= TERMP_NOSPACE; - } - p->flags &= ~TERMP_BRNEVER; - return 0; + return 1; } static void @@ -1514,12 +1487,14 @@ termp_bd_post(DECL_ARGS) { if (n->type != ROFFT_BODY) return; - if (DISP_literal == n->norm->Bd.type || - DISP_unfilled == n->norm->Bd.type) + if (n->norm->Bd.type == DISP_unfilled || + n->norm->Bd.type == DISP_literal) p->flags |= TERMP_BRNEVER; p->flags |= TERMP_NOSPACE; term_newln(p); p->flags &= ~TERMP_BRNEVER; + if (n->norm->Bd.type == DISP_centered) + p->flags &= ~TERMP_CENTER; } static int @@ -1540,24 +1515,18 @@ termp_xx_post(DECL_ARGS) static void termp_pf_post(DECL_ARGS) { - - if ( ! (n->next == NULL || n->next->flags & NODE_LINE)) + if (n->next != NULL && (n->next->flags & NODE_LINE) == 0) p->flags |= TERMP_NOSPACE; } static int termp_ss_pre(DECL_ARGS) { - struct roff_node *nn; - switch (n->type) { case ROFFT_BLOCK: - term_newln(p); - for (nn = n->prev; nn != NULL; nn = nn->prev) - if (nn->type != ROFFT_COMMENT && - (nn->flags & NODE_NOPRT) == 0) - break; - if (nn != NULL) + if (roff_node_prev(n) == NULL) + term_newln(p); + else term_vspace(p); break; case ROFFT_HEAD: @@ -1573,14 +1542,12 @@ termp_ss_pre(DECL_ARGS) default: break; } - return 1; } static void termp_ss_post(DECL_ARGS) { - if (n->type == ROFFT_HEAD || n->type == ROFFT_BODY) term_newln(p); } @@ -1630,7 +1597,7 @@ termp_in_post(DECL_ARGS) static int termp_pp_pre(DECL_ARGS) { - fn_prio = 0; + fn_prio = TAG_STRONG; term_vspace(p); return 0; } @@ -1908,24 +1875,26 @@ termp_ap_pre(DECL_ARGS) static void termp____post(DECL_ARGS) { + struct roff_node *nn; /* * Handle lists of authors. In general, print each followed by * a comma. Don't print the comma if there are only two * authors. */ - if (MDOC__A == n->tok && n->next && MDOC__A == n->next->tok) - if (NULL == n->next->next || MDOC__A != n->next->next->tok) - if (NULL == n->prev || MDOC__A != n->prev->tok) - return; + if (n->tok == MDOC__A && + (nn = roff_node_next(n)) != NULL && nn->tok == MDOC__A && + ((nn = roff_node_next(nn)) == NULL || nn->tok != MDOC__A) && + ((nn = roff_node_prev(n)) == NULL || nn->tok != MDOC__A)) + return; /* TODO: %U. */ - if (NULL == n->parent || MDOC_Rs != n->parent->tok) + if (n->parent == NULL || n->parent->tok != MDOC_Rs) return; p->flags |= TERMP_NOSPACE; - if (NULL == n->next) { + if (roff_node_next(n) == NULL) { term_word(p, "."); p->flags |= TERMP_SENTENCE; } else @@ -2055,7 +2024,7 @@ termp_em_pre(DECL_ARGS) { if (n->child != NULL && n->child->type == ROFFT_TEXT) - tag_put(n->child->string, 0, p->line); + tag_put(n->child->string, TAG_FALLBACK, p->line); term_fontpush(p, TERMFONT_UNDER); return 1; } @@ -2065,7 +2034,7 @@ termp_sy_pre(DECL_ARGS) { if (n->child != NULL && n->child->type == ROFFT_TEXT) - tag_put(n->child->string, 0, p->line); + tag_put(n->child->string, TAG_FALLBACK, p->line); term_fontpush(p, TERMFONT_BOLD); return 1; } @@ -2078,7 +2047,7 @@ termp_er_pre(DECL_ARGS) (n->parent->tok == MDOC_It || (n->parent->tok == MDOC_Bq && n->parent->parent->parent->tok == MDOC_It))) - tag_put(n->child->string, 1, p->line); + tag_put(n->child->string, TAG_STRONG, p->line); return 1; } @@ -2095,6 +2064,12 @@ termp_tag_pre(DECL_ARGS) (n->parent->tok == MDOC_Xo && n->parent->parent->prev == NULL && n->parent->parent->parent->tok == MDOC_It))) - tag_put(n->child->string, 1, p->line); + tag_put(n->child->string, TAG_STRONG, p->line); return 1; +} + +static int +termp_abort_pre(DECL_ARGS) +{ + abort(); }