=================================================================== RCS file: /cvs/mandoc/mdoc_term.c,v retrieving revision 1.125 retrieving revision 1.143 diff -u -p -r1.125 -r1.143 --- mandoc/mdoc_term.c 2010/05/17 22:11:42 1.125 +++ mandoc/mdoc_term.c 2010/06/07 11:01:15 1.143 @@ -1,4 +1,4 @@ -/* $Id: mdoc_term.c,v 1.125 2010/05/17 22:11:42 kristaps Exp $ */ +/* $Id: mdoc_term.c,v 1.143 2010/06/07 11:01:15 kristaps Exp $ */ /* * Copyright (c) 2008, 2009 Kristaps Dzonsons * @@ -61,7 +61,6 @@ static int arg_getattrs(const int *, int *, size_t, const struct mdoc_node *); static int arg_getattr(int, const struct mdoc_node *); static int arg_disptype(const struct mdoc_node *); -static int arg_listtype(const struct mdoc_node *); static void print_bvspace(struct termp *, const struct mdoc_node *, const struct mdoc_node *); @@ -69,6 +68,8 @@ static void print_mdoc_node(DECL_ARGS); static void print_mdoc_head(DECL_ARGS); static void print_mdoc_nodelist(DECL_ARGS); static void print_foot(DECL_ARGS); +static void synopsis_pre(struct termp *, + const struct mdoc_node *); static void termp____post(DECL_ARGS); static void termp_an_post(DECL_ARGS); @@ -80,10 +81,8 @@ static void termp_brq_post(DECL_ARGS); static void termp_bx_post(DECL_ARGS); static void termp_d1_post(DECL_ARGS); static void termp_dq_post(DECL_ARGS); -static void termp_fd_post(DECL_ARGS); -static void termp_fn_post(DECL_ARGS); +static int termp_fd_pre(DECL_ARGS); static void termp_fo_post(DECL_ARGS); -static void termp_ft_post(DECL_ARGS); static void termp_in_post(DECL_ARGS); static void termp_it_post(DECL_ARGS); static void termp_lb_post(DECL_ARGS); @@ -94,7 +93,6 @@ static void termp_qq_post(DECL_ARGS); static void termp_sh_post(DECL_ARGS); static void termp_sq_post(DECL_ARGS); static void termp_ss_post(DECL_ARGS); -static void termp_vt_post(DECL_ARGS); static int termp_an_pre(DECL_ARGS); static int termp_ap_pre(DECL_ARGS); @@ -164,10 +162,10 @@ static const struct termact termacts[MDOC_MAX] = { { NULL, NULL }, /* Ev */ { termp_ex_pre, NULL }, /* Ex */ { termp_fa_pre, NULL }, /* Fa */ - { termp_bold_pre, termp_fd_post }, /* Fd */ + { termp_fd_pre, NULL }, /* Fd */ { termp_fl_pre, NULL }, /* Fl */ - { termp_fn_pre, termp_fn_post }, /* Fn */ - { termp_ft_pre, termp_ft_post }, /* Ft */ + { termp_fn_pre, NULL }, /* Fn */ + { termp_ft_pre, NULL }, /* Ft */ { termp_bold_pre, NULL }, /* Ic */ { termp_in_pre, termp_in_post }, /* In */ { termp_li_pre, NULL }, /* Li */ @@ -179,7 +177,7 @@ static const struct termact termacts[MDOC_MAX] = { { termp_rv_pre, NULL }, /* Rv */ { NULL, NULL }, /* St */ { termp_under_pre, NULL }, /* Va */ - { termp_vt_pre, termp_vt_post }, /* Vt */ + { termp_vt_pre, NULL }, /* Vt */ { termp_xr_pre, NULL }, /* Xr */ { NULL, termp____post }, /* %A */ { termp_under_pre, termp____post }, /* %B */ @@ -261,6 +259,7 @@ static const struct termact termacts[MDOC_MAX] = { { termp_sp_pre, NULL }, /* br */ { termp_sp_pre, NULL }, /* sp */ { termp_under_pre, termp____post }, /* %U */ + { NULL, NULL }, /* Ta */ }; @@ -275,6 +274,7 @@ terminal_mdoc(void *arg, const struct mdoc *mdoc) p->overstep = 0; p->maxrmargin = p->defrmargin; + p->tabwidth = 5; if (NULL == p->symtab) switch (p->enc) { @@ -512,47 +512,6 @@ arg_disptype(const struct mdoc_node *n) } -static int -arg_listtype(const struct mdoc_node *n) -{ - int i, len; - - assert(MDOC_BLOCK == n->type); - - len = (int)(n->args ? n->args->argc : 0); - - for (i = 0; i < len; i++) - switch (n->args->argv[i].arg) { - case (MDOC_Bullet): - /* FALLTHROUGH */ - case (MDOC_Dash): - /* FALLTHROUGH */ - case (MDOC_Enum): - /* FALLTHROUGH */ - case (MDOC_Hyphen): - /* FALLTHROUGH */ - case (MDOC_Tag): - /* FALLTHROUGH */ - case (MDOC_Inset): - /* FALLTHROUGH */ - case (MDOC_Diag): - /* FALLTHROUGH */ - case (MDOC_Item): - /* FALLTHROUGH */ - case (MDOC_Column): - /* FALLTHROUGH */ - case (MDOC_Hang): - /* FALLTHROUGH */ - case (MDOC_Ohang): - return(n->args->argv[i].arg); - default: - break; - } - - return(-1); -} - - static size_t a2offs(const struct mdoc_argv *arg) { @@ -655,13 +614,13 @@ print_bvspace(struct termp *p, /* A `-column' does not assert vspace within the list. */ - if (MDOC_Bl == bl->tok && arg_hasattr(MDOC_Column, bl)) + if (MDOC_Bl == bl->tok && LIST_column == bl->data.list) if (n->prev && MDOC_It == n->prev->tok) return; /* A `-diag' without body does not vspace. */ - if (MDOC_Bl == bl->tok && arg_hasattr(MDOC_Diag, bl)) + if (MDOC_Bl == bl->tok && LIST_diag == bl->data.list) if (n->prev && MDOC_It == n->prev->tok) { assert(n->prev->body); if (NULL == n->prev->body->child) @@ -705,8 +664,9 @@ termp_it_pre(DECL_ARGS) { const struct mdoc_node *bl, *nn; char buf[7]; - int i, type, keys[3], vals[3]; + int i, keys[3], vals[3]; size_t width, offset, ncols, dcol; + enum mdoc_list type; if (MDOC_BLOCK == n->type) { print_bvspace(p, n->parent->parent, n); @@ -725,8 +685,7 @@ termp_it_pre(DECL_ARGS) arg_getattrs(keys, vals, 3, bl); - type = arg_listtype(bl); - assert(-1 != type); + type = bl->data.list; /* * First calculate width and offset. This is pretty easy unless @@ -740,8 +699,8 @@ termp_it_pre(DECL_ARGS) offset = a2offs(&bl->args->argv[vals[1]]); switch (type) { - case (MDOC_Column): - if (MDOC_BODY == n->type) + case (LIST_column): + if (MDOC_HEAD == n->type) break; /* * Imitate groff's column handling: @@ -756,8 +715,13 @@ termp_it_pre(DECL_ARGS) /* LINTED */ dcol = ncols < 5 ? 4 : ncols == 5 ? 3 : 1; + /* + * Calculate the offset by applying all prior MDOC_BODY, + * so we stop at the MDOC_HEAD (NULL == nn->prev). + */ + for (i = 0, nn = n->prev; - nn && i < (int)ncols; + nn->prev && i < (int)ncols; nn = nn->prev, i++) offset += dcol + a2width (&bl->args->argv[vals[2]], i); @@ -798,25 +762,25 @@ termp_it_pre(DECL_ARGS) */ switch (type) { - case (MDOC_Bullet): + case (LIST_bullet): /* FALLTHROUGH */ - case (MDOC_Dash): + case (LIST_dash): /* FALLTHROUGH */ - case (MDOC_Hyphen): + case (LIST_hyphen): if (width < 4) width = 4; break; - case (MDOC_Enum): + case (LIST_enum): if (width < 5) width = 5; break; - case (MDOC_Hang): + case (LIST_hang): if (0 == width) width = 8; break; - case (MDOC_Column): + case (LIST_column): /* FALLTHROUGH */ - case (MDOC_Tag): + case (LIST_tag): if (0 == width) width = 10; break; @@ -832,11 +796,11 @@ termp_it_pre(DECL_ARGS) p->flags |= TERMP_NOSPACE; switch (type) { - case (MDOC_Diag): + case (LIST_diag): if (MDOC_BODY == n->type) term_word(p, "\\ \\ "); break; - case (MDOC_Inset): + case (LIST_inset): if (MDOC_BODY == n->type) term_word(p, "\\ "); break; @@ -847,7 +811,7 @@ termp_it_pre(DECL_ARGS) p->flags |= TERMP_NOSPACE; switch (type) { - case (MDOC_Diag): + case (LIST_diag): if (MDOC_HEAD == n->type) term_fontpush(p, TERMFONT_BOLD); break; @@ -863,19 +827,19 @@ termp_it_pre(DECL_ARGS) */ switch (type) { - case (MDOC_Bullet): + case (LIST_bullet): /* FALLTHROUGH */ - case (MDOC_Dash): + case (LIST_dash): /* FALLTHROUGH */ - case (MDOC_Enum): + case (LIST_enum): /* FALLTHROUGH */ - case (MDOC_Hyphen): + case (LIST_hyphen): if (MDOC_HEAD == n->type) p->flags |= TERMP_NOBREAK; else p->flags |= TERMP_NOLPAD; break; - case (MDOC_Hang): + case (LIST_hang): if (MDOC_HEAD == n->type) p->flags |= TERMP_NOBREAK; else @@ -898,7 +862,7 @@ termp_it_pre(DECL_ARGS) } else p->flags |= TERMP_HANG; break; - case (MDOC_Tag): + case (LIST_tag): if (MDOC_HEAD == n->type) p->flags |= TERMP_NOBREAK | TERMP_TWOSPACE; else @@ -909,18 +873,21 @@ termp_it_pre(DECL_ARGS) if (NULL == n->next || NULL == n->next->child) p->flags |= TERMP_DANGLE; break; - case (MDOC_Column): - if (MDOC_HEAD == n->type) { - assert(n->next); - if (MDOC_BODY == n->next->type) - p->flags &= ~TERMP_NOBREAK; - else - p->flags |= TERMP_NOBREAK; - if (n->prev) - p->flags |= TERMP_NOLPAD; - } + case (LIST_column): + if (MDOC_HEAD == n->type) + break; + + if (NULL == n->next) + p->flags &= ~TERMP_NOBREAK; + else + p->flags |= TERMP_NOBREAK; + + assert(n->prev); + if (MDOC_BODY == n->prev->type) + p->flags |= TERMP_NOLPAD; + break; - case (MDOC_Diag): + case (LIST_diag): if (MDOC_HEAD == n->type) p->flags |= TERMP_NOBREAK; break; @@ -937,7 +904,7 @@ termp_it_pre(DECL_ARGS) p->offset += offset; switch (type) { - case (MDOC_Hang): + case (LIST_hang): /* * Same stipulation as above, regarding `-hang'. We * don't want to recalculate rmargin and offsets when @@ -948,31 +915,31 @@ termp_it_pre(DECL_ARGS) MDOC_Bd == n->next->child->tok)) break; /* FALLTHROUGH */ - case (MDOC_Bullet): + case (LIST_bullet): /* FALLTHROUGH */ - case (MDOC_Dash): + case (LIST_dash): /* FALLTHROUGH */ - case (MDOC_Enum): + case (LIST_enum): /* FALLTHROUGH */ - case (MDOC_Hyphen): + case (LIST_hyphen): /* FALLTHROUGH */ - case (MDOC_Tag): + case (LIST_tag): assert(width); if (MDOC_HEAD == n->type) p->rmargin = p->offset + width; else p->offset += width; break; - case (MDOC_Column): + case (LIST_column): assert(width); p->rmargin = p->offset + width; /* * XXX - this behaviour is not documented: the * right-most column is filled to the right margin. */ - if (MDOC_HEAD == n->type && - MDOC_BODY == n->next->type && - p->rmargin < p->maxrmargin) + if (MDOC_HEAD == n->type) + break; + if (NULL == n->next && p->rmargin < p->maxrmargin) p->rmargin = p->maxrmargin; break; default: @@ -986,19 +953,19 @@ termp_it_pre(DECL_ARGS) if (MDOC_HEAD == n->type) switch (type) { - case (MDOC_Bullet): + case (LIST_bullet): term_fontpush(p, TERMFONT_BOLD); term_word(p, "\\[bu]"); term_fontpop(p); break; - case (MDOC_Dash): + case (LIST_dash): /* FALLTHROUGH */ - case (MDOC_Hyphen): + case (LIST_hyphen): term_fontpush(p, TERMFONT_BOLD); term_word(p, "\\(hy"); term_fontpop(p); break; - case (MDOC_Enum): + case (LIST_enum): (pair->ppair->ppair->count)++; snprintf(buf, sizeof(buf), "%d.", pair->ppair->ppair->count); @@ -1013,20 +980,20 @@ termp_it_pre(DECL_ARGS) */ switch (type) { - case (MDOC_Bullet): + case (LIST_bullet): /* FALLTHROUGH */ - case (MDOC_Item): + case (LIST_item): /* FALLTHROUGH */ - case (MDOC_Dash): + case (LIST_dash): /* FALLTHROUGH */ - case (MDOC_Hyphen): + case (LIST_hyphen): /* FALLTHROUGH */ - case (MDOC_Enum): + case (LIST_enum): if (MDOC_HEAD == n->type) return(0); break; - case (MDOC_Column): - if (MDOC_BODY == n->type) + case (LIST_column): + if (MDOC_HEAD == n->type) return(0); break; default: @@ -1041,29 +1008,28 @@ termp_it_pre(DECL_ARGS) static void termp_it_post(DECL_ARGS) { - int type; + enum mdoc_list type; if (MDOC_BLOCK == n->type) return; - type = arg_listtype(n->parent->parent->parent); - assert(-1 != type); + type = n->parent->parent->parent->data.list; switch (type) { - case (MDOC_Item): + case (LIST_item): /* FALLTHROUGH */ - case (MDOC_Diag): + case (LIST_diag): /* FALLTHROUGH */ - case (MDOC_Inset): + case (LIST_inset): if (MDOC_BODY == n->type) - term_flushln(p); + term_newln(p); break; - case (MDOC_Column): - if (MDOC_HEAD == n->type) + case (LIST_column): + if (MDOC_BODY == n->type) term_flushln(p); break; default: - term_flushln(p); + term_newln(p); break; } @@ -1087,15 +1053,13 @@ termp_nm_pre(DECL_ARGS) { if (NULL == n->child && NULL == m->name) + return(1); - if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) - term_newln(p); + synopsis_pre(p, n); term_fontpush(p, TERMFONT_BOLD); - if (NULL == n->child) term_word(p, m->name); - return(1); } @@ -1233,6 +1197,7 @@ termp_rv_pre(DECL_ARGS) term_fontpop(p); term_word(p, "is set to indicate the error."); + p->flags |= TERMP_SENTENCE; return(0); } @@ -1265,6 +1230,7 @@ termp_ex_pre(DECL_ARGS) term_word(p, "utility exits"); term_word(p, "0 on success, and >0 if an error occurs."); + p->flags |= TERMP_SENTENCE; return(0); } @@ -1344,36 +1310,82 @@ termp_xr_pre(DECL_ARGS) } +/* + * This decides how to assert whitespace before any of the SYNOPSIS set + * of macros (which, as in the case of Ft/Fo and Ft/Fn, may contain + * macro combos). + */ +static void +synopsis_pre(struct termp *p, const struct mdoc_node *n) +{ + /* + * Obviously, if we're not in a SYNOPSIS or no prior macros + * exist, do nothing. + */ + if (NULL == n->prev || SEC_SYNOPSIS != n->sec) + return; + + /* + * If we're the second in a pair of like elements, emit our + * newline and return. UNLESS we're `Fo', `Fn', `Fn', in which + * case we soldier on. + */ + if (n->prev->tok == n->tok && + MDOC_Ft != n->tok && + MDOC_Fo != n->tok && + MDOC_Fn != n->tok) { + term_newln(p); + return; + } + + /* + * If we're one of the SYNOPSIS set and non-like pair-wise after + * another (or Fn/Fo, which we've let slip through) then assert + * vertical space, else only newline and move on. + */ + switch (n->prev->tok) { + case (MDOC_Fd): + /* FALLTHROUGH */ + case (MDOC_Fn): + /* FALLTHROUGH */ + case (MDOC_Fo): + /* FALLTHROUGH */ + case (MDOC_In): + /* FALLTHROUGH */ + case (MDOC_Vt): + term_vspace(p); + break; + case (MDOC_Ft): + if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) { + term_vspace(p); + break; + } + /* FALLTHROUGH */ + default: + term_newln(p); + break; + } +} + + static int termp_vt_pre(DECL_ARGS) { - if (MDOC_ELEM == n->type) + if (MDOC_ELEM == n->type) { + synopsis_pre(p, n); return(termp_under_pre(p, pair, m, n)); - else if (MDOC_HEAD == n->type) - return(0); - else if (MDOC_BLOCK == n->type) + } else if (MDOC_BLOCK == n->type) { + synopsis_pre(p, n); return(1); + } else if (MDOC_HEAD == n->type) + return(0); return(termp_under_pre(p, pair, m, n)); } /* ARGSUSED */ -static void -termp_vt_post(DECL_ARGS) -{ - - if (MDOC_BLOCK != n->type) - return; - if (n->next && MDOC_Vt == n->next->tok) - term_newln(p); - else if (n->next) - term_vspace(p); -} - - -/* ARGSUSED */ static int termp_bold_pre(DECL_ARGS) { @@ -1384,16 +1396,12 @@ termp_bold_pre(DECL_ARGS) /* ARGSUSED */ -static void -termp_fd_post(DECL_ARGS) +static int +termp_fd_pre(DECL_ARGS) { - if (n->sec != SEC_SYNOPSIS || ! (MDOC_LINE & n->flags)) - return; - - term_newln(p); - if (n->next && MDOC_Fd != n->next->tok) - term_vspace(p); + synopsis_pre(p, n); + return(termp_bold_pre(p, pair, m, n)); } @@ -1466,6 +1474,7 @@ termp_bt_pre(DECL_ARGS) { term_word(p, "is currently in beta test."); + p->flags |= TERMP_SENTENCE; return(0); } @@ -1486,6 +1495,7 @@ termp_ud_pre(DECL_ARGS) { term_word(p, "currently under development."); + p->flags |= TERMP_SENTENCE; return(0); } @@ -1544,31 +1554,21 @@ static int termp_ft_pre(DECL_ARGS) { - if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) - if (n->prev && MDOC_Fo == n->prev->tok) - term_vspace(p); - + /* NB: MDOC_LINE does not effect this! */ + synopsis_pre(p, n); term_fontpush(p, TERMFONT_UNDER); return(1); } /* ARGSUSED */ -static void -termp_ft_post(DECL_ARGS) -{ - - if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) - term_newln(p); -} - - -/* ARGSUSED */ static int termp_fn_pre(DECL_ARGS) { const struct mdoc_node *nn; + synopsis_pre(p, n); + term_fontpush(p, TERMFONT_BOLD); term_word(p, n->child->string); term_fontpop(p); @@ -1595,16 +1595,6 @@ termp_fn_pre(DECL_ARGS) /* ARGSUSED */ -static void -termp_fn_post(DECL_ARGS) -{ - - if (n->sec == SEC_SYNOPSIS && n->next && MDOC_LINE & n->flags) - term_vspace(p); -} - - -/* ARGSUSED */ static int termp_fa_pre(DECL_ARGS) { @@ -1635,6 +1625,7 @@ termp_fa_pre(DECL_ARGS) static int termp_bd_pre(DECL_ARGS) { + size_t tabwidth; int i, type; size_t rm, rmax; const struct mdoc_node *nn; @@ -1664,6 +1655,8 @@ termp_bd_pre(DECL_ARGS) if (MDOC_Literal != type && MDOC_Unfilled != type) return(1); + tabwidth = p->tabwidth; + p->tabwidth = 8; rm = p->rmargin; rmax = p->maxrmargin; p->rmargin = p->maxrmargin = TERM_MAXMARGIN; @@ -1671,13 +1664,12 @@ termp_bd_pre(DECL_ARGS) for (nn = n->child; nn; nn = nn->next) { p->flags |= TERMP_NOSPACE; print_mdoc_node(p, pair, m, nn); - if (NULL == nn->next) - continue; - if (nn->prev && nn->prev->line < nn->line) + if (NULL == nn->prev || + nn->prev->line < nn->line || + NULL == nn->next) term_flushln(p); - else if (NULL == nn->prev) - term_flushln(p); } + p->tabwidth = tabwidth; p->rmargin = rm; p->maxrmargin = rmax; @@ -1705,7 +1697,7 @@ termp_bd_post(DECL_ARGS) p->rmargin = p->maxrmargin = TERM_MAXMARGIN; p->flags |= TERMP_NOSPACE; - term_flushln(p); + term_newln(p); p->rmargin = rm; p->maxrmargin = rmax; @@ -1867,8 +1859,8 @@ static int termp_cd_pre(DECL_ARGS) { + synopsis_pre(p, n); term_fontpush(p, TERMFONT_BOLD); - term_newln(p); return(1); } @@ -1878,11 +1870,17 @@ static int termp_in_pre(DECL_ARGS) { - term_fontpush(p, TERMFONT_BOLD); - if (SEC_SYNOPSIS == n->sec) + synopsis_pre(p, n); + + if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) { + term_fontpush(p, TERMFONT_BOLD); term_word(p, "#include"); + term_word(p, "<"); + } else { + term_word(p, "<"); + term_fontpush(p, TERMFONT_UNDER); + } - term_word(p, "<"); p->flags |= TERMP_NOSPACE; return(1); } @@ -1893,23 +1891,14 @@ static void termp_in_post(DECL_ARGS) { - term_fontpush(p, TERMFONT_BOLD); + if (SEC_SYNOPSIS == n->sec) + term_fontpush(p, TERMFONT_BOLD); + p->flags |= TERMP_NOSPACE; term_word(p, ">"); - term_fontpop(p); - if (SEC_SYNOPSIS != n->sec && ! (MDOC_LINE & n->flags)) - return; - - term_newln(p); - /* - * XXX Not entirely correct. If `.In foo bar' is specified in - * the SYNOPSIS section, then it produces a single break after - * the ; mandoc asserts a vertical space. Since this - * construction is rarely used, I think it's fine. - */ - if (n->next && MDOC_In != n->next->tok) - term_vspace(p); + if (SEC_SYNOPSIS == n->sec) + term_fontpop(p); } @@ -2018,23 +2007,23 @@ termp_pq_post(DECL_ARGS) static int termp_fo_pre(DECL_ARGS) { - const struct mdoc_node *nn; - if (MDOC_BODY == n->type) { + if (MDOC_BLOCK == n->type) { + synopsis_pre(p, n); + return(1); + } else if (MDOC_BODY == n->type) { p->flags |= TERMP_NOSPACE; term_word(p, "("); p->flags |= TERMP_NOSPACE; return(1); - } else if (MDOC_HEAD != n->type) - return(1); + } - term_fontpush(p, TERMFONT_BOLD); - for (nn = n->child; nn; nn = nn->next) { - assert(MDOC_TEXT == nn->type); - term_word(p, nn->string); - } - term_fontpop(p); + /* XXX: we drop non-initial arguments as per groff. */ + assert(n->child); + assert(n->child->string); + term_fontpush(p, TERMFONT_BOLD); + term_word(p, n->child->string); return(0); } @@ -2044,13 +2033,16 @@ static void termp_fo_post(DECL_ARGS) { - if (MDOC_BODY != n->type) + if (MDOC_BODY != n->type) return; + p->flags |= TERMP_NOSPACE; term_word(p, ")"); - p->flags |= TERMP_NOSPACE; - term_word(p, ";"); - term_newln(p); + + if (SEC_SYNOPSIS == n->sec) { + p->flags |= TERMP_NOSPACE; + term_word(p, ";"); + } }