Return to mdoc_term.c CVS log | Up to [cvsweb.bsd.lv] / mandoc |
version 1.50, 2009/07/21 12:47:52 | version 1.139, 2010/06/04 22:16:27 | ||
---|---|---|---|
|
|
||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
*/ | */ | ||
#ifdef HAVE_CONFIG_H | |||
#include "config.h" | |||
#endif | |||
#include <sys/types.h> | #include <sys/types.h> | ||
#include <assert.h> | #include <assert.h> | ||
#include <ctype.h> | #include <ctype.h> | ||
#include <err.h> | #include <stdint.h> | ||
#include <stdio.h> | #include <stdio.h> | ||
#include <stdlib.h> | #include <stdlib.h> | ||
#include <string.h> | #include <string.h> | ||
#include "mandoc.h" | |||
#include "out.h" | |||
#include "term.h" | #include "term.h" | ||
#include "mdoc.h" | #include "mdoc.h" | ||
#include "chars.h" | |||
#include "main.h" | |||
/* FIXME: macro arguments can be escaped. */ | #define INDENT 5 | ||
#define HALFINDENT 3 | |||
#define TTYPE_PROG 0 | |||
#define TTYPE_CMD_FLAG 1 | |||
#define TTYPE_CMD_ARG 2 | |||
#define TTYPE_SECTION 3 | |||
#define TTYPE_FUNC_DECL 4 | |||
#define TTYPE_VAR_DECL 5 | |||
#define TTYPE_FUNC_TYPE 6 | |||
#define TTYPE_FUNC_NAME 7 | |||
#define TTYPE_FUNC_ARG 8 | |||
#define TTYPE_LINK 9 | |||
#define TTYPE_SSECTION 10 | |||
#define TTYPE_FILE 11 | |||
#define TTYPE_EMPH 12 | |||
#define TTYPE_CONFIG 13 | |||
#define TTYPE_CMD 14 | |||
#define TTYPE_INCLUDE 15 | |||
#define TTYPE_SYMB 16 | |||
#define TTYPE_SYMBOL 17 | |||
#define TTYPE_DIAG 18 | |||
#define TTYPE_LINK_ANCHOR 19 | |||
#define TTYPE_LINK_TEXT 20 | |||
#define TTYPE_REF_JOURNAL 21 | |||
#define TTYPE_LIST 22 | |||
#define TTYPE_NMAX 23 | |||
const int ttypes[TTYPE_NMAX] = { | |||
TERMP_BOLD, /* TTYPE_PROG */ | |||
TERMP_BOLD, /* TTYPE_CMD_FLAG */ | |||
TERMP_UNDER, /* TTYPE_CMD_ARG */ | |||
TERMP_BOLD, /* TTYPE_SECTION */ | |||
TERMP_BOLD, /* TTYPE_FUNC_DECL */ | |||
TERMP_UNDER, /* TTYPE_VAR_DECL */ | |||
TERMP_UNDER, /* TTYPE_FUNC_TYPE */ | |||
TERMP_BOLD, /* TTYPE_FUNC_NAME */ | |||
TERMP_UNDER, /* TTYPE_FUNC_ARG */ | |||
TERMP_UNDER, /* TTYPE_LINK */ | |||
TERMP_BOLD, /* TTYPE_SSECTION */ | |||
TERMP_UNDER, /* TTYPE_FILE */ | |||
TERMP_UNDER, /* TTYPE_EMPH */ | |||
TERMP_BOLD, /* TTYPE_CONFIG */ | |||
TERMP_BOLD, /* TTYPE_CMD */ | |||
TERMP_BOLD, /* TTYPE_INCLUDE */ | |||
TERMP_BOLD, /* TTYPE_SYMB */ | |||
TERMP_BOLD, /* TTYPE_SYMBOL */ | |||
TERMP_BOLD, /* TTYPE_DIAG */ | |||
TERMP_UNDER, /* TTYPE_LINK_ANCHOR */ | |||
TERMP_BOLD, /* TTYPE_LINK_TEXT */ | |||
TERMP_UNDER, /* TTYPE_REF_JOURNAL */ | |||
TERMP_BOLD /* TTYPE_LIST */ | |||
}; | |||
struct termpair { | struct termpair { | ||
struct termpair *ppair; | struct termpair *ppair; | ||
int flag; | |||
int count; | int count; | ||
}; | }; | ||
#define DECL_ARGS struct termp *p, \ | #define DECL_ARGS struct termp *p, \ | ||
struct termpair *pair, \ | struct termpair *pair, \ | ||
const struct mdoc_meta *meta, \ | const struct mdoc_meta *m, \ | ||
const struct mdoc_node *node | const struct mdoc_node *n | ||
struct termact { | struct termact { | ||
int (*pre)(DECL_ARGS); | int (*pre)(DECL_ARGS); | ||
void (*post)(DECL_ARGS); | void (*post)(DECL_ARGS); | ||
}; | }; | ||
static size_t a2width(const struct mdoc_argv *, int); | |||
static size_t a2height(const struct mdoc_node *); | |||
static size_t a2offs(const struct mdoc_argv *); | |||
static int arg_hasattr(int, const struct mdoc_node *); | |||
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 void print_bvspace(struct termp *, | |||
const struct mdoc_node *, | |||
const struct mdoc_node *); | |||
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 termp____post(DECL_ARGS); | static void termp____post(DECL_ARGS); | ||
static void termp__t_post(DECL_ARGS); | static void termp_an_post(DECL_ARGS); | ||
static void termp_aq_post(DECL_ARGS); | static void termp_aq_post(DECL_ARGS); | ||
static void termp_bd_post(DECL_ARGS); | static void termp_bd_post(DECL_ARGS); | ||
static void termp_bl_post(DECL_ARGS); | static void termp_bl_post(DECL_ARGS); | ||
|
|
||
static void termp_ss_post(DECL_ARGS); | static void termp_ss_post(DECL_ARGS); | ||
static void termp_vt_post(DECL_ARGS); | static void termp_vt_post(DECL_ARGS); | ||
static int termp__j_pre(DECL_ARGS); | static int termp_an_pre(DECL_ARGS); | ||
static int termp__t_pre(DECL_ARGS); | |||
static int termp_ap_pre(DECL_ARGS); | static int termp_ap_pre(DECL_ARGS); | ||
static int termp_aq_pre(DECL_ARGS); | static int termp_aq_pre(DECL_ARGS); | ||
static int termp_ar_pre(DECL_ARGS); | |||
static int termp_bd_pre(DECL_ARGS); | static int termp_bd_pre(DECL_ARGS); | ||
static int termp_bf_pre(DECL_ARGS); | static int termp_bf_pre(DECL_ARGS); | ||
static int termp_bl_pre(DECL_ARGS); | |||
static int termp_bold_pre(DECL_ARGS); | |||
static int termp_bq_pre(DECL_ARGS); | static int termp_bq_pre(DECL_ARGS); | ||
static int termp_br_pre(DECL_ARGS); | |||
static int termp_brq_pre(DECL_ARGS); | static int termp_brq_pre(DECL_ARGS); | ||
static int termp_bt_pre(DECL_ARGS); | static int termp_bt_pre(DECL_ARGS); | ||
static int termp_cd_pre(DECL_ARGS); | static int termp_cd_pre(DECL_ARGS); | ||
static int termp_cm_pre(DECL_ARGS); | |||
static int termp_d1_pre(DECL_ARGS); | static int termp_d1_pre(DECL_ARGS); | ||
static int termp_dq_pre(DECL_ARGS); | static int termp_dq_pre(DECL_ARGS); | ||
static int termp_em_pre(DECL_ARGS); | |||
static int termp_ex_pre(DECL_ARGS); | static int termp_ex_pre(DECL_ARGS); | ||
static int termp_fa_pre(DECL_ARGS); | static int termp_fa_pre(DECL_ARGS); | ||
static int termp_fd_pre(DECL_ARGS); | |||
static int termp_fl_pre(DECL_ARGS); | static int termp_fl_pre(DECL_ARGS); | ||
static int termp_fn_pre(DECL_ARGS); | static int termp_fn_pre(DECL_ARGS); | ||
static int termp_fo_pre(DECL_ARGS); | static int termp_fo_pre(DECL_ARGS); | ||
static int termp_ft_pre(DECL_ARGS); | static int termp_ft_pre(DECL_ARGS); | ||
static int termp_ic_pre(DECL_ARGS); | |||
static int termp_in_pre(DECL_ARGS); | static int termp_in_pre(DECL_ARGS); | ||
static int termp_it_pre(DECL_ARGS); | static int termp_it_pre(DECL_ARGS); | ||
static int termp_li_pre(DECL_ARGS); | |||
static int termp_lk_pre(DECL_ARGS); | static int termp_lk_pre(DECL_ARGS); | ||
static int termp_ms_pre(DECL_ARGS); | |||
static int termp_mt_pre(DECL_ARGS); | |||
static int termp_nd_pre(DECL_ARGS); | static int termp_nd_pre(DECL_ARGS); | ||
static int termp_nm_pre(DECL_ARGS); | static int termp_nm_pre(DECL_ARGS); | ||
static int termp_ns_pre(DECL_ARGS); | static int termp_ns_pre(DECL_ARGS); | ||
static int termp_op_pre(DECL_ARGS); | static int termp_op_pre(DECL_ARGS); | ||
static int termp_pa_pre(DECL_ARGS); | |||
static int termp_pf_pre(DECL_ARGS); | static int termp_pf_pre(DECL_ARGS); | ||
static int termp_pp_pre(DECL_ARGS); | |||
static int termp_pq_pre(DECL_ARGS); | static int termp_pq_pre(DECL_ARGS); | ||
static int termp_qq_pre(DECL_ARGS); | static int termp_qq_pre(DECL_ARGS); | ||
static int termp_rs_pre(DECL_ARGS); | static int termp_rs_pre(DECL_ARGS); | ||
|
|
||
static int termp_sp_pre(DECL_ARGS); | static int termp_sp_pre(DECL_ARGS); | ||
static int termp_sq_pre(DECL_ARGS); | static int termp_sq_pre(DECL_ARGS); | ||
static int termp_ss_pre(DECL_ARGS); | static int termp_ss_pre(DECL_ARGS); | ||
static int termp_sx_pre(DECL_ARGS); | static int termp_under_pre(DECL_ARGS); | ||
static int termp_sy_pre(DECL_ARGS); | |||
static int termp_ud_pre(DECL_ARGS); | static int termp_ud_pre(DECL_ARGS); | ||
static int termp_va_pre(DECL_ARGS); | |||
static int termp_vt_pre(DECL_ARGS); | static int termp_vt_pre(DECL_ARGS); | ||
static int termp_xr_pre(DECL_ARGS); | static int termp_xr_pre(DECL_ARGS); | ||
static int termp_xx_pre(DECL_ARGS); | static int termp_xx_pre(DECL_ARGS); | ||
static const struct termact termacts[MDOC_MAX] = { | static const struct termact termacts[MDOC_MAX] = { | ||
{ termp_ap_pre, NULL }, /* Ap */ | { termp_ap_pre, NULL }, /* Ap */ | ||
{ NULL, NULL }, /* Dd */ | { NULL, NULL }, /* Dd */ | ||
{ NULL, NULL }, /* Dt */ | { NULL, NULL }, /* Dt */ | ||
{ NULL, NULL }, /* Os */ | { NULL, NULL }, /* Os */ | ||
{ termp_sh_pre, termp_sh_post }, /* Sh */ | { termp_sh_pre, termp_sh_post }, /* Sh */ | ||
{ termp_ss_pre, termp_ss_post }, /* Ss */ | { termp_ss_pre, termp_ss_post }, /* Ss */ | ||
{ termp_pp_pre, NULL }, /* Pp */ | { termp_sp_pre, NULL }, /* Pp */ | ||
{ termp_d1_pre, termp_d1_post }, /* D1 */ | { termp_d1_pre, termp_d1_post }, /* D1 */ | ||
{ termp_d1_pre, termp_d1_post }, /* Dl */ | { termp_d1_pre, termp_d1_post }, /* Dl */ | ||
{ termp_bd_pre, termp_bd_post }, /* Bd */ | { termp_bd_pre, termp_bd_post }, /* Bd */ | ||
{ NULL, NULL }, /* Ed */ | { NULL, NULL }, /* Ed */ | ||
{ NULL, termp_bl_post }, /* Bl */ | { termp_bl_pre, termp_bl_post }, /* Bl */ | ||
{ NULL, NULL }, /* El */ | { NULL, NULL }, /* El */ | ||
{ termp_it_pre, termp_it_post }, /* It */ | { termp_it_pre, termp_it_post }, /* It */ | ||
{ NULL, NULL }, /* Ad */ | { NULL, NULL }, /* Ad */ | ||
{ NULL, NULL }, /* An */ | { termp_an_pre, termp_an_post }, /* An */ | ||
{ termp_ar_pre, NULL }, /* Ar */ | { termp_under_pre, NULL }, /* Ar */ | ||
{ termp_cd_pre, NULL }, /* Cd */ | { termp_cd_pre, NULL }, /* Cd */ | ||
{ termp_cm_pre, NULL }, /* Cm */ | { termp_bold_pre, NULL }, /* Cm */ | ||
{ NULL, NULL }, /* Dv */ | { NULL, NULL }, /* Dv */ | ||
{ NULL, NULL }, /* Er */ | { NULL, NULL }, /* Er */ | ||
{ NULL, NULL }, /* Ev */ | { NULL, NULL }, /* Ev */ | ||
{ termp_ex_pre, NULL }, /* Ex */ | { termp_ex_pre, NULL }, /* Ex */ | ||
{ termp_fa_pre, NULL }, /* Fa */ | { termp_fa_pre, NULL }, /* Fa */ | ||
{ termp_fd_pre, termp_fd_post }, /* Fd */ | { termp_bold_pre, termp_fd_post }, /* Fd */ | ||
{ termp_fl_pre, NULL }, /* Fl */ | { termp_fl_pre, NULL }, /* Fl */ | ||
{ termp_fn_pre, termp_fn_post }, /* Fn */ | { termp_fn_pre, termp_fn_post }, /* Fn */ | ||
{ termp_ft_pre, termp_ft_post }, /* Ft */ | { termp_ft_pre, termp_ft_post }, /* Ft */ | ||
{ termp_ic_pre, NULL }, /* Ic */ | { termp_bold_pre, NULL }, /* Ic */ | ||
{ termp_in_pre, termp_in_post }, /* In */ | { termp_in_pre, termp_in_post }, /* In */ | ||
{ NULL, NULL }, /* Li */ | { termp_li_pre, NULL }, /* Li */ | ||
{ termp_nd_pre, NULL }, /* Nd */ | { termp_nd_pre, NULL }, /* Nd */ | ||
{ termp_nm_pre, NULL }, /* Nm */ | { termp_nm_pre, NULL }, /* Nm */ | ||
{ termp_op_pre, termp_op_post }, /* Op */ | { termp_op_pre, termp_op_post }, /* Op */ | ||
{ NULL, NULL }, /* Ot */ | { NULL, NULL }, /* Ot */ | ||
{ termp_pa_pre, NULL }, /* Pa */ | { termp_under_pre, NULL }, /* Pa */ | ||
{ termp_rv_pre, NULL }, /* Rv */ | { termp_rv_pre, NULL }, /* Rv */ | ||
{ NULL, NULL }, /* St */ | { NULL, NULL }, /* St */ | ||
{ termp_va_pre, NULL }, /* Va */ | { termp_under_pre, NULL }, /* Va */ | ||
{ termp_vt_pre, termp_vt_post }, /* Vt */ | { termp_vt_pre, termp_vt_post }, /* Vt */ | ||
{ termp_xr_pre, NULL }, /* Xr */ | { termp_xr_pre, NULL }, /* Xr */ | ||
{ NULL, termp____post }, /* %A */ | { NULL, termp____post }, /* %A */ | ||
{ NULL, termp____post }, /* %B */ | { termp_under_pre, termp____post }, /* %B */ | ||
{ NULL, termp____post }, /* %D */ | { NULL, termp____post }, /* %D */ | ||
{ NULL, termp____post }, /* %I */ | { termp_under_pre, termp____post }, /* %I */ | ||
{ termp__j_pre, termp____post }, /* %J */ | { termp_under_pre, termp____post }, /* %J */ | ||
{ NULL, termp____post }, /* %N */ | { NULL, termp____post }, /* %N */ | ||
{ NULL, termp____post }, /* %O */ | { NULL, termp____post }, /* %O */ | ||
{ NULL, termp____post }, /* %P */ | { NULL, termp____post }, /* %P */ | ||
{ NULL, termp____post }, /* %R */ | { NULL, termp____post }, /* %R */ | ||
{ termp__t_pre, termp__t_post }, /* %T */ | { termp_under_pre, termp____post }, /* %T */ | ||
{ NULL, termp____post }, /* %V */ | { NULL, termp____post }, /* %V */ | ||
{ NULL, NULL }, /* Ac */ | { NULL, NULL }, /* Ac */ | ||
{ termp_aq_pre, termp_aq_post }, /* Ao */ | { termp_aq_pre, termp_aq_post }, /* Ao */ | ||
|
|
||
{ NULL, NULL }, /* Dc */ | { NULL, NULL }, /* Dc */ | ||
{ termp_dq_pre, termp_dq_post }, /* Do */ | { termp_dq_pre, termp_dq_post }, /* Do */ | ||
{ termp_dq_pre, termp_dq_post }, /* Dq */ | { termp_dq_pre, termp_dq_post }, /* Dq */ | ||
{ NULL, NULL }, /* Ec */ | { NULL, NULL }, /* Ec */ /* FIXME: no space */ | ||
{ NULL, NULL }, /* Ef */ | { NULL, NULL }, /* Ef */ | ||
{ termp_em_pre, NULL }, /* Em */ | { termp_under_pre, NULL }, /* Em */ | ||
{ NULL, NULL }, /* Eo */ | { NULL, NULL }, /* Eo */ | ||
{ termp_xx_pre, NULL }, /* Fx */ | { termp_xx_pre, NULL }, /* Fx */ | ||
{ termp_ms_pre, NULL }, /* Ms */ | { termp_bold_pre, NULL }, /* Ms */ /* FIXME: convert to symbol? */ | ||
{ NULL, NULL }, /* No */ | { NULL, NULL }, /* No */ | ||
{ termp_ns_pre, NULL }, /* Ns */ | { termp_ns_pre, NULL }, /* Ns */ | ||
{ termp_xx_pre, NULL }, /* Nx */ | { termp_xx_pre, NULL }, /* Nx */ | ||
|
|
||
{ termp_sq_pre, termp_sq_post }, /* So */ | { termp_sq_pre, termp_sq_post }, /* So */ | ||
{ termp_sq_pre, termp_sq_post }, /* Sq */ | { termp_sq_pre, termp_sq_post }, /* Sq */ | ||
{ termp_sm_pre, NULL }, /* Sm */ | { termp_sm_pre, NULL }, /* Sm */ | ||
{ termp_sx_pre, NULL }, /* Sx */ | { termp_under_pre, NULL }, /* Sx */ | ||
{ termp_sy_pre, NULL }, /* Sy */ | { termp_bold_pre, NULL }, /* Sy */ | ||
{ NULL, NULL }, /* Tn */ | { NULL, NULL }, /* Tn */ | ||
{ termp_xx_pre, NULL }, /* Ux */ | { termp_xx_pre, NULL }, /* Ux */ | ||
{ NULL, NULL }, /* Xc */ | { NULL, NULL }, /* Xc */ | ||
|
|
||
{ NULL, NULL }, /* Fr */ | { NULL, NULL }, /* Fr */ | ||
{ termp_ud_pre, NULL }, /* Ud */ | { termp_ud_pre, NULL }, /* Ud */ | ||
{ NULL, termp_lb_post }, /* Lb */ | { NULL, termp_lb_post }, /* Lb */ | ||
{ termp_pp_pre, NULL }, /* Lp */ | { termp_sp_pre, NULL }, /* Lp */ | ||
{ termp_lk_pre, NULL }, /* Lk */ | { termp_lk_pre, NULL }, /* Lk */ | ||
{ termp_mt_pre, NULL }, /* Mt */ | { termp_under_pre, NULL }, /* Mt */ | ||
{ termp_brq_pre, termp_brq_post }, /* Brq */ | { termp_brq_pre, termp_brq_post }, /* Brq */ | ||
{ termp_brq_pre, termp_brq_post }, /* Bro */ | { termp_brq_pre, termp_brq_post }, /* Bro */ | ||
{ NULL, NULL }, /* Brc */ | { NULL, NULL }, /* Brc */ | ||
{ NULL, NULL }, /* %C */ | { NULL, termp____post }, /* %C */ | ||
{ NULL, NULL }, /* Es */ | { NULL, NULL }, /* Es */ /* TODO */ | ||
{ NULL, NULL }, /* En */ | { NULL, NULL }, /* En */ /* TODO */ | ||
{ termp_xx_pre, NULL }, /* Dx */ | { termp_xx_pre, NULL }, /* Dx */ | ||
{ NULL, NULL }, /* %Q */ | { NULL, termp____post }, /* %Q */ | ||
{ termp_br_pre, NULL }, /* br */ | { termp_sp_pre, NULL }, /* br */ | ||
{ termp_sp_pre, NULL }, /* sp */ | { termp_sp_pre, NULL }, /* sp */ | ||
{ termp_under_pre, termp____post }, /* %U */ | |||
{ NULL, NULL }, /* Ta */ | |||
}; | }; | ||
#ifdef __linux__ | |||
extern size_t strlcpy(char *, const char *, size_t); | |||
extern size_t strlcat(char *, const char *, size_t); | |||
#endif | |||
static int arg_hasattr(int, const struct mdoc_node *); | void | ||
static int arg_getattrs(const int *, int *, size_t, | terminal_mdoc(void *arg, const struct mdoc *mdoc) | ||
const struct mdoc_node *); | { | ||
static int arg_getattr(int, const struct mdoc_node *); | const struct mdoc_node *n; | ||
static size_t arg_offset(const struct mdoc_argv *); | const struct mdoc_meta *m; | ||
static size_t arg_width(const struct mdoc_argv *, int); | struct termp *p; | ||
static int arg_listtype(const struct mdoc_node *); | |||
static int fmt_block_vspace(struct termp *, | |||
const struct mdoc_node *, | |||
const struct mdoc_node *); | |||
static void print_node(DECL_ARGS); | |||
static void print_head(struct termp *, | |||
const struct mdoc_meta *); | |||
static void print_body(DECL_ARGS); | |||
static void print_foot(struct termp *, | |||
const struct mdoc_meta *); | |||
p = (struct termp *)arg; | |||
int | p->overstep = 0; | ||
mdoc_run(struct termp *p, const struct mdoc *m) | p->maxrmargin = p->defrmargin; | ||
{ | p->tabwidth = 5; | ||
/* | |||
* Main output function. When this is called, assume that the | if (NULL == p->symtab) | ||
* tree is properly formed. | switch (p->enc) { | ||
*/ | case (TERMENC_ASCII): | ||
print_head(p, mdoc_meta(m)); | p->symtab = chars_init(CHARS_ASCII); | ||
assert(mdoc_node(m)); | break; | ||
assert(MDOC_ROOT == mdoc_node(m)->type); | default: | ||
if (mdoc_node(m)->child) | abort(); | ||
print_body(p, NULL, mdoc_meta(m), mdoc_node(m)->child); | /* NOTREACHED */ | ||
print_foot(p, mdoc_meta(m)); | } | ||
return(1); | |||
n = mdoc_node(mdoc); | |||
m = mdoc_meta(mdoc); | |||
print_mdoc_head(p, NULL, m, n); | |||
if (n->child) | |||
print_mdoc_nodelist(p, NULL, m, n->child); | |||
print_foot(p, NULL, m, n); | |||
} | } | ||
static void | static void | ||
print_body(DECL_ARGS) | print_mdoc_nodelist(DECL_ARGS) | ||
{ | { | ||
print_node(p, pair, meta, node); | print_mdoc_node(p, pair, m, n); | ||
if ( ! node->next) | if (n->next) | ||
return; | print_mdoc_nodelist(p, pair, m, n->next); | ||
print_body(p, pair, meta, node->next); | |||
} | } | ||
/* ARGSUSED */ | |||
static void | static void | ||
print_node(DECL_ARGS) | print_mdoc_node(DECL_ARGS) | ||
{ | { | ||
int dochild; | int chld; | ||
const void *font; | |||
struct termpair npair; | struct termpair npair; | ||
size_t offset, rmargin; | size_t offset, rmargin; | ||
dochild = 1; | chld = 1; | ||
offset = p->offset; | offset = p->offset; | ||
rmargin = p->rmargin; | rmargin = p->rmargin; | ||
font = term_fontq(p); | |||
memset(&npair, 0, sizeof(struct termpair)); | |||
npair.ppair = pair; | npair.ppair = pair; | ||
npair.flag = 0; | |||
npair.count = 0; | |||
/* | if (MDOC_TEXT != n->type) { | ||
* Note on termpair. This allows a pre function to set a termp | if (termacts[n->tok].pre) | ||
* flag that is automatically unset after the body, but before | chld = (*termacts[n->tok].pre)(p, &npair, m, n); | ||
* the post function. Thus, if a pre uses a termpair flag, it | } else | ||
* must be reapplied in the post for use. | term_word(p, n->string); | ||
*/ | |||
if (MDOC_TEXT != node->type) { | if (chld && n->child) | ||
if (termacts[node->tok].pre) | print_mdoc_nodelist(p, &npair, m, n->child); | ||
if ( ! (*termacts[node->tok].pre)(p, &npair, meta, node)) | |||
dochild = 0; | |||
} else /* MDOC_TEXT == node->type */ | |||
term_word(p, node->string); | |||
/* Children. */ | term_fontpopq(p, font); | ||
p->flags |= npair.flag; | if (MDOC_TEXT != n->type) | ||
if (termacts[n->tok].post) | |||
(*termacts[n->tok].post)(p, &npair, m, n); | |||
if (dochild && node->child) | if (MDOC_EOS & n->flags) | ||
print_body(p, &npair, meta, node->child); | p->flags |= TERMP_SENTENCE; | ||
p->flags &= ~npair.flag; | |||
/* Post-processing. */ | |||
if (MDOC_TEXT != node->type) | |||
if (termacts[node->tok].post) | |||
(*termacts[node->tok].post)(p, &npair, meta, node); | |||
p->offset = offset; | p->offset = offset; | ||
p->rmargin = rmargin; | p->rmargin = rmargin; | ||
} | } | ||
/* ARGSUSED */ | |||
static void | static void | ||
print_foot(struct termp *p, const struct mdoc_meta *meta) | print_foot(DECL_ARGS) | ||
{ | { | ||
struct tm *tm; | char buf[DATESIZ], os[BUFSIZ]; | ||
char *buf, *os; | |||
term_fontrepl(p, TERMFONT_NONE); | |||
/* | /* | ||
* Output the footer in new-groff style, that is, three columns | * Output the footer in new-groff style, that is, three columns | ||
* with the middle being the manual date and flanking columns | * with the middle being the manual date and flanking columns | ||
|
|
||
* SYSTEM DATE SYSTEM | * SYSTEM DATE SYSTEM | ||
*/ | */ | ||
if (NULL == (buf = malloc(p->rmargin))) | time2a(m->date, buf, DATESIZ); | ||
err(1, "malloc"); | strlcpy(os, m->os, BUFSIZ); | ||
if (NULL == (os = malloc(p->rmargin))) | |||
err(1, "malloc"); | |||
tm = localtime(&meta->date); | |||
if (0 == strftime(buf, p->rmargin, "%B %e, %Y", tm)) | |||
err(1, "strftime"); | |||
(void)strlcpy(os, meta->os, p->rmargin); | |||
term_vspace(p); | term_vspace(p); | ||
p->offset = 0; | p->offset = 0; | ||
|
|
||
p->offset = 0; | p->offset = 0; | ||
p->rmargin = p->maxrmargin; | p->rmargin = p->maxrmargin; | ||
p->flags = 0; | p->flags = 0; | ||
free(buf); | |||
free(os); | |||
} | } | ||
/* ARGSUSED */ | |||
static void | static void | ||
print_head(struct termp *p, const struct mdoc_meta *meta) | print_mdoc_head(DECL_ARGS) | ||
{ | { | ||
char *buf, *title; | char buf[BUFSIZ], title[BUFSIZ]; | ||
p->rmargin = p->maxrmargin; | p->rmargin = p->maxrmargin; | ||
p->offset = 0; | p->offset = 0; | ||
if (NULL == (buf = malloc(p->rmargin))) | |||
err(1, "malloc"); | |||
if (NULL == (title = malloc(p->rmargin))) | |||
err(1, "malloc"); | |||
/* | /* | ||
* The header is strange. It has three components, which are | * The header is strange. It has three components, which are | ||
* really two with the first duplicated. It goes like this: | * really two with the first duplicated. It goes like this: | ||
|
|
||
* switches on the manual section. | * switches on the manual section. | ||
*/ | */ | ||
assert(meta->vol); | assert(m->vol); | ||
(void)strlcpy(buf, meta->vol, p->rmargin); | strlcpy(buf, m->vol, BUFSIZ); | ||
if (meta->arch) { | if (m->arch) { | ||
(void)strlcat(buf, " (", p->rmargin); | strlcat(buf, " (", BUFSIZ); | ||
(void)strlcat(buf, meta->arch, p->rmargin); | strlcat(buf, m->arch, BUFSIZ); | ||
(void)strlcat(buf, ")", p->rmargin); | strlcat(buf, ")", BUFSIZ); | ||
} | } | ||
(void)snprintf(title, p->rmargin, "%s(%d)", | snprintf(title, BUFSIZ, "%s(%s)", m->title, m->msec); | ||
meta->title, meta->msec); | |||
p->offset = 0; | p->offset = 0; | ||
p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2; | p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2; | ||
|
|
||
p->offset = 0; | p->offset = 0; | ||
p->rmargin = p->maxrmargin; | p->rmargin = p->maxrmargin; | ||
p->flags &= ~TERMP_NOSPACE; | p->flags &= ~TERMP_NOSPACE; | ||
free(title); | |||
free(buf); | |||
} | } | ||
static size_t | static size_t | ||
arg_width(const struct mdoc_argv *arg, int pos) | a2height(const struct mdoc_node *n) | ||
{ | { | ||
int i, len; | struct roffsu su; | ||
const char *p; | |||
assert(pos < (int)arg->sz && pos >= 0); | assert(MDOC_TEXT == n->type); | ||
assert(arg->value[pos]); | assert(n->string); | ||
if ( ! a2roffsu(n->string, &su, SCALE_VS)) | |||
SCALE_VS_INIT(&su, strlen(n->string)); | |||
p = arg->value[pos]; | return(term_vspan(&su)); | ||
} | |||
if (0 == (len = (int)strlen(p))) | |||
return(0); | |||
for (i = 0; i < len - 1; i++) | static size_t | ||
if ( ! isdigit((u_char)p[i])) | a2width(const struct mdoc_argv *arg, int pos) | ||
break; | { | ||
struct roffsu su; | |||
if (i == len - 1) | assert(arg->value[pos]); | ||
if ('n' == p[len - 1] || 'm' == p[len - 1]) | if ( ! a2roffsu(arg->value[pos], &su, SCALE_MAX)) | ||
return((size_t)atoi(p) + 2); | SCALE_HS_INIT(&su, strlen(arg->value[pos])); | ||
return((size_t)len + 2); | return(term_hspan(&su)); | ||
} | } | ||
static int | static int | ||
arg_listtype(const struct mdoc_node *n) | arg_disptype(const struct mdoc_node *n) | ||
{ | { | ||
int i, len; | int i, len; | ||
|
|
||
len = (int)(n->args ? n->args->argc : 0); | len = (int)(n->args ? n->args->argc : 0); | ||
for (i = 0; i < len; i++) | for (i = 0; i < len; i++) | ||
switch (n->args->argv[i].arg) { | switch (n->args->argv[i].arg) { | ||
case (MDOC_Bullet): | case (MDOC_Centred): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Dash): | case (MDOC_Ragged): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Enum): | case (MDOC_Filled): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Hyphen): | case (MDOC_Unfilled): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Tag): | case (MDOC_Literal): | ||
/* 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); | return(n->args->argv[i].arg); | ||
default: | default: | ||
break; | break; | ||
|
|
||
static size_t | static size_t | ||
arg_offset(const struct mdoc_argv *arg) | a2offs(const struct mdoc_argv *arg) | ||
{ | { | ||
int len, i; | struct roffsu su; | ||
const char *p; | |||
assert(*arg->value); | if ('\0' == arg->value[0][0]) | ||
p = *arg->value; | |||
if (0 == strcmp(p, "left")) | |||
return(0); | return(0); | ||
if (0 == strcmp(p, "indent")) | else if (0 == strcmp(arg->value[0], "left")) | ||
return(0); | |||
else if (0 == strcmp(arg->value[0], "indent")) | |||
return(INDENT + 1); | return(INDENT + 1); | ||
if (0 == strcmp(p, "indent-two")) | else if (0 == strcmp(arg->value[0], "indent-two")) | ||
return((INDENT + 1) * 2); | return((INDENT + 1) * 2); | ||
else if ( ! a2roffsu(arg->value[0], &su, SCALE_MAX)) | |||
SCALE_HS_INIT(&su, strlen(arg->value[0])); | |||
if (0 == (len = (int)strlen(p))) | return(term_hspan(&su)); | ||
return(0); | |||
for (i = 0; i < len - 1; i++) | |||
if ( ! isdigit((u_char)p[i])) | |||
break; | |||
if (i == len - 1) | |||
if ('n' == p[len - 1] || 'm' == p[len - 1]) | |||
return((size_t)atoi(p)); | |||
return((size_t)len); | |||
} | } | ||
/* | |||
* Return 1 if an argument has a particular argument value or 0 if it | |||
* does not. See arg_getattr(). | |||
*/ | |||
static int | static int | ||
arg_hasattr(int arg, const struct mdoc_node *n) | arg_hasattr(int arg, const struct mdoc_node *n) | ||
{ | { | ||
|
|
||
} | } | ||
/* | |||
* Get the index of an argument in a node's argument list or -1 if it | |||
* does not exist. See arg_getattrs(). | |||
*/ | |||
static int | static int | ||
arg_getattr(int v, const struct mdoc_node *n) | arg_getattr(int v, const struct mdoc_node *n) | ||
{ | { | ||
|
|
||
} | } | ||
/* | |||
* Walk through the argument list for a node and fill an array "vals" | |||
* with the positions of the argument structures listed in "keys". | |||
* Return the number of elements that were written into "vals", which | |||
* can be zero. | |||
*/ | |||
static int | static int | ||
arg_getattrs(const int *keys, int *vals, | arg_getattrs(const int *keys, int *vals, | ||
size_t sz, const struct mdoc_node *n) | size_t sz, const struct mdoc_node *n) | ||
|
|
||
} | } | ||
/* ARGSUSED */ | /* | ||
static int | * Determine how much space to print out before block elements of `It' | ||
fmt_block_vspace(struct termp *p, | * (and thus `Bl') and `Bd'. And then go ahead and print that space, | ||
* too. | |||
*/ | |||
static void | |||
print_bvspace(struct termp *p, | |||
const struct mdoc_node *bl, | const struct mdoc_node *bl, | ||
const struct mdoc_node *node) | const struct mdoc_node *n) | ||
{ | { | ||
const struct mdoc_node *n; | const struct mdoc_node *nn; | ||
term_newln(p); | term_newln(p); | ||
if (arg_hasattr(MDOC_Compact, bl)) | if (arg_hasattr(MDOC_Compact, bl)) | ||
return(1); | return; | ||
/* XXX - not documented! */ | |||
else if (arg_hasattr(MDOC_Column, bl)) | |||
return(1); | |||
for (n = node; n; n = n->parent) { | /* Do not vspace directly after Ss/Sh. */ | ||
if (MDOC_BLOCK != n->type) | |||
for (nn = n; nn; nn = nn->parent) { | |||
if (MDOC_BLOCK != nn->type) | |||
continue; | continue; | ||
if (MDOC_Ss == n->tok) | if (MDOC_Ss == nn->tok) | ||
break; | return; | ||
if (MDOC_Sh == n->tok) | if (MDOC_Sh == nn->tok) | ||
break; | return; | ||
if (NULL == n->prev) | if (NULL == nn->prev) | ||
continue; | continue; | ||
term_vspace(p); | |||
break; | break; | ||
} | } | ||
return(1); | /* A `-column' does not assert vspace within the list. */ | ||
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 && LIST_diag == bl->data.list) | |||
if (n->prev && MDOC_It == n->prev->tok) { | |||
assert(n->prev->body); | |||
if (NULL == n->prev->body->child) | |||
return; | |||
} | |||
term_vspace(p); | |||
} | } | ||
|
|
||
termp_dq_pre(DECL_ARGS) | termp_dq_pre(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return(1); | return(1); | ||
term_word(p, "\\(lq"); | term_word(p, "\\(lq"); | ||
|
|
||
termp_dq_post(DECL_ARGS) | termp_dq_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
|
|
||
static int | static int | ||
termp_it_pre(DECL_ARGS) | termp_it_pre(DECL_ARGS) | ||
{ | { | ||
const struct mdoc_node *bl, *n; | const struct mdoc_node *bl, *nn; | ||
char buf[7]; | char buf[7]; | ||
int i, type, keys[3], vals[3]; | int i, keys[3], vals[3]; | ||
size_t width, offset; | size_t width, offset, ncols, dcol; | ||
enum mdoc_list type; | |||
if (MDOC_BLOCK == node->type) | if (MDOC_BLOCK == n->type) { | ||
return(fmt_block_vspace(p, node->parent->parent, node)); | print_bvspace(p, n->parent->parent, n); | ||
return(1); | |||
} | |||
bl = node->parent->parent->parent; | bl = n->parent->parent->parent; | ||
/* Save parent attributes. */ | /* Get list width, offset, and list type from argument list. */ | ||
pair->flag = p->flags; | |||
/* Get list width and offset. */ | |||
keys[0] = MDOC_Width; | keys[0] = MDOC_Width; | ||
keys[1] = MDOC_Offset; | keys[1] = MDOC_Offset; | ||
keys[2] = MDOC_Column; | keys[2] = MDOC_Column; | ||
vals[0] = vals[1] = vals[2] = -1; | vals[0] = vals[1] = vals[2] = -1; | ||
width = offset = 0; | arg_getattrs(keys, vals, 3, bl); | ||
(void)arg_getattrs(keys, vals, 3, bl); | type = bl->data.list; | ||
type = arg_listtype(bl); | /* | ||
assert(-1 != type); | * First calculate width and offset. This is pretty easy unless | ||
* we're a -column list, in which case all prior columns must | |||
* be accounted for. | |||
*/ | |||
/* Calculate real width and offset. */ | width = offset = 0; | ||
if (vals[1] >= 0) | |||
offset = a2offs(&bl->args->argv[vals[1]]); | |||
switch (type) { | switch (type) { | ||
case (MDOC_Column): | case (LIST_column): | ||
if (MDOC_BODY == node->type) | if (MDOC_HEAD == n->type) | ||
break; | break; | ||
for (i = 0, n = node->prev; n; n = n->prev, i++) | /* | ||
offset += arg_width | * Imitate groff's column handling: | ||
* - For each earlier column, add its width. | |||
* - For less than 5 columns, add four more blanks per | |||
* column. | |||
* - For exactly 5 columns, add three more blank per | |||
* column. | |||
* - For more than 5 columns, add only one column. | |||
*/ | |||
ncols = bl->args->argv[vals[2]].sz; | |||
/* 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->prev && i < (int)ncols; | |||
nn = nn->prev, i++) | |||
offset += dcol + a2width | |||
(&bl->args->argv[vals[2]], i); | (&bl->args->argv[vals[2]], i); | ||
assert(i < (int)bl->args->argv[vals[2]].sz); | |||
width = arg_width(&bl->args->argv[vals[2]], i); | |||
if (vals[1] >= 0) | /* | ||
offset += arg_offset(&bl->args->argv[vals[1]]); | * When exceeding the declared number of columns, leave | ||
* the remaining widths at 0. This will later be | |||
* adjusted to the default width of 10, or, for the last | |||
* column, stretched to the right margin. | |||
*/ | |||
if (i >= (int)ncols) | |||
break; | |||
/* | |||
* Use the declared column widths, extended as explained | |||
* in the preceding paragraph. | |||
*/ | |||
width = a2width(&bl->args->argv[vals[2]], i) + dcol; | |||
break; | break; | ||
default: | default: | ||
if (vals[0] >= 0) | if (vals[0] < 0) | ||
width = arg_width(&bl->args->argv[vals[0]], 0); | break; | ||
if (vals[1] >= 0) | |||
offset += arg_offset(&bl->args->argv[vals[1]]); | /* | ||
* Note: buffer the width by 2, which is groff's magic | |||
* number for buffering single arguments. See the above | |||
* handling for column for how this changes. | |||
*/ | |||
width = a2width(&bl->args->argv[vals[0]], 0) + 2; | |||
break; | break; | ||
} | } | ||
/* | /* | ||
* List-type can override the width in the case of fixed-head | * List-type can override the width in the case of fixed-head | ||
* values (bullet, dash/hyphen, enum). Tags need a non-zero | * values (bullet, dash/hyphen, enum). Tags need a non-zero | ||
* offset. FIXME: double-check that correct. | * offset. | ||
*/ | */ | ||
switch (type) { | switch (type) { | ||
case (MDOC_Bullet): | case (LIST_bullet): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Dash): | case (LIST_dash): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Hyphen): | case (LIST_hyphen): | ||
if (width < 4) | if (width < 4) | ||
width = 4; | width = 4; | ||
break; | break; | ||
case (MDOC_Enum): | case (LIST_enum): | ||
if (width < 5) | if (width < 5) | ||
width = 5; | width = 5; | ||
break; | break; | ||
case (MDOC_Hang): | case (LIST_hang): | ||
if (0 == width) | if (0 == width) | ||
width = 8; | width = 8; | ||
break; | break; | ||
case (MDOC_Column): | case (LIST_column): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Tag): | case (LIST_tag): | ||
if (0 == width) | if (0 == width) | ||
width = 10; | width = 10; | ||
break; | break; | ||
|
|
||
* while diagonal bodies need two. | * while diagonal bodies need two. | ||
*/ | */ | ||
p->flags |= TERMP_NOSPACE; | |||
switch (type) { | switch (type) { | ||
case (MDOC_Inset): | case (LIST_diag): | ||
if (MDOC_BODY == node->type) | if (MDOC_BODY == n->type) | ||
p->flags &= ~TERMP_NOSPACE; | term_word(p, "\\ \\ "); | ||
else | |||
p->flags |= TERMP_NOSPACE; | |||
break; | break; | ||
case (LIST_inset): | |||
if (MDOC_BODY == n->type) | |||
term_word(p, "\\ "); | |||
break; | |||
default: | default: | ||
p->flags |= TERMP_NOSPACE; | |||
break; | break; | ||
} | } | ||
/* | p->flags |= TERMP_NOSPACE; | ||
* Style flags. Diagnostic heads need TTYPE_DIAG. | |||
*/ | |||
switch (type) { | switch (type) { | ||
case (MDOC_Diag): | case (LIST_diag): | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
p->flags |= ttypes[TTYPE_DIAG]; | term_fontpush(p, TERMFONT_BOLD); | ||
break; | break; | ||
default: | default: | ||
break; | break; | ||
} | } | ||
/* | /* | ||
* Pad and break control. This is the tricker part. Lists with | * Pad and break control. This is the tricky part. These flags | ||
* set right-margins for the head get TERMP_NOBREAK because, if | * are documented in term_flushln() in term.c. Note that we're | ||
* they overrun the margin, they wrap to the new margin. | * going to unset all of these flags in termp_it_post() when we | ||
* Correspondingly, the body for these types don't left-pad, as | * exit. | ||
* the head will pad out to to the right. | |||
*/ | */ | ||
switch (type) { | switch (type) { | ||
case (MDOC_Bullet): | case (LIST_bullet): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Dash): | case (LIST_dash): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Enum): | case (LIST_enum): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Hyphen): | case (LIST_hyphen): | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
p->flags |= TERMP_NOBREAK; | p->flags |= TERMP_NOBREAK; | ||
else | else | ||
p->flags |= TERMP_NOLPAD; | p->flags |= TERMP_NOLPAD; | ||
break; | break; | ||
case (MDOC_Hang): | case (LIST_hang): | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
p->flags |= TERMP_NOBREAK; | p->flags |= TERMP_NOBREAK; | ||
else | else | ||
p->flags |= TERMP_NOLPAD; | p->flags |= TERMP_NOLPAD; | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD != n->type) | ||
break; | |||
/* | |||
* This is ugly. If `-hang' is specified and the body | |||
* is a `Bl' or `Bd', then we want basically to nullify | |||
* the "overstep" effect in term_flushln() and treat | |||
* this as a `-ohang' list instead. | |||
*/ | |||
if (n->next->child && | |||
(MDOC_Bl == n->next->child->tok || | |||
MDOC_Bd == n->next->child->tok)) { | |||
p->flags &= ~TERMP_NOBREAK; | |||
p->flags &= ~TERMP_NOLPAD; | |||
} else | |||
p->flags |= TERMP_HANG; | p->flags |= TERMP_HANG; | ||
break; | break; | ||
case (MDOC_Tag): | case (LIST_tag): | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
p->flags |= TERMP_NOBREAK; | p->flags |= TERMP_NOBREAK | TERMP_TWOSPACE; | ||
else | else | ||
p->flags |= TERMP_NOLPAD; | p->flags |= TERMP_NOLPAD; | ||
if (MDOC_HEAD != node->type) | if (MDOC_HEAD != n->type) | ||
break; | break; | ||
if (NULL == node->next || NULL == node->next->child) | if (NULL == n->next || NULL == n->next->child) | ||
p->flags |= TERMP_DANGLE; | p->flags |= TERMP_DANGLE; | ||
break; | break; | ||
case (MDOC_Column): | case (LIST_column): | ||
if (MDOC_HEAD == node->type) { | if (MDOC_HEAD == n->type) | ||
assert(node->next); | break; | ||
if (MDOC_BODY == node->next->type) | |||
p->flags &= ~TERMP_NOBREAK; | if (NULL == n->next) | ||
else | p->flags &= ~TERMP_NOBREAK; | ||
p->flags |= TERMP_NOBREAK; | else | ||
if (node->prev) | p->flags |= TERMP_NOBREAK; | ||
p->flags |= TERMP_NOLPAD; | |||
} | assert(n->prev); | ||
if (MDOC_BODY == n->prev->type) | |||
p->flags |= TERMP_NOLPAD; | |||
break; | break; | ||
case (MDOC_Diag): | case (LIST_diag): | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
p->flags |= TERMP_NOBREAK; | p->flags |= TERMP_NOBREAK; | ||
break; | break; | ||
default: | default: | ||
|
|
||
p->offset += offset; | p->offset += offset; | ||
switch (type) { | switch (type) { | ||
case (MDOC_Bullet): | case (LIST_hang): | ||
/* | |||
* Same stipulation as above, regarding `-hang'. We | |||
* don't want to recalculate rmargin and offsets when | |||
* using `Bd' or `Bl' within `-hang' overstep lists. | |||
*/ | |||
if (MDOC_HEAD == n->type && n->next->child && | |||
(MDOC_Bl == n->next->child->tok || | |||
MDOC_Bd == n->next->child->tok)) | |||
break; | |||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Dash): | case (LIST_bullet): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Enum): | case (LIST_dash): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Hyphen): | case (LIST_enum): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Hang): | case (LIST_hyphen): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Tag): | case (LIST_tag): | ||
assert(width); | assert(width); | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
p->rmargin = p->offset + width; | p->rmargin = p->offset + width; | ||
else | else | ||
p->offset += width; | p->offset += width; | ||
break; | break; | ||
case (MDOC_Column): | case (LIST_column): | ||
assert(width); | assert(width); | ||
p->rmargin = p->offset + width; | p->rmargin = p->offset + width; | ||
/* | /* | ||
* XXX - this behaviour is not documented: the | * XXX - this behaviour is not documented: the | ||
* right-most column is filled to the right margin. | * right-most column is filled to the right margin. | ||
*/ | */ | ||
if (MDOC_HEAD == node->type && | if (MDOC_HEAD == n->type) | ||
MDOC_BODY == node->next->type) | break; | ||
if (NULL == n->next && p->rmargin < p->maxrmargin) | |||
p->rmargin = p->maxrmargin; | p->rmargin = p->maxrmargin; | ||
break; | break; | ||
default: | default: | ||
|
|
||
* HEAD character (temporarily bold, in some cases). | * HEAD character (temporarily bold, in some cases). | ||
*/ | */ | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
switch (type) { | switch (type) { | ||
case (MDOC_Bullet): | case (LIST_bullet): | ||
p->flags |= TERMP_BOLD; | term_fontpush(p, TERMFONT_BOLD); | ||
term_word(p, "\\[bu]"); | term_word(p, "\\[bu]"); | ||
p->flags &= ~TERMP_BOLD; | term_fontpop(p); | ||
break; | break; | ||
case (MDOC_Dash): | case (LIST_dash): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Hyphen): | case (LIST_hyphen): | ||
p->flags |= TERMP_BOLD; | term_fontpush(p, TERMFONT_BOLD); | ||
term_word(p, "\\(hy"); | term_word(p, "\\(hy"); | ||
p->flags &= ~TERMP_BOLD; | term_fontpop(p); | ||
break; | break; | ||
case (MDOC_Enum): | case (LIST_enum): | ||
(pair->ppair->ppair->count)++; | (pair->ppair->ppair->count)++; | ||
(void)snprintf(buf, sizeof(buf), "%d.", | snprintf(buf, sizeof(buf), "%d.", | ||
pair->ppair->ppair->count); | pair->ppair->ppair->count); | ||
term_word(p, buf); | term_word(p, buf); | ||
break; | break; | ||
|
|
||
*/ | */ | ||
switch (type) { | switch (type) { | ||
case (MDOC_Bullet): | case (LIST_bullet): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Item): | case (LIST_item): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Dash): | case (LIST_dash): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Hyphen): | case (LIST_hyphen): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Enum): | case (LIST_enum): | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
return(0); | return(0); | ||
break; | break; | ||
case (MDOC_Column): | case (LIST_column): | ||
if (MDOC_BODY == node->type) | if (MDOC_HEAD == n->type) | ||
return(0); | return(0); | ||
break; | break; | ||
default: | default: | ||
|
|
||
static void | static void | ||
termp_it_post(DECL_ARGS) | termp_it_post(DECL_ARGS) | ||
{ | { | ||
int type; | enum mdoc_list type; | ||
if (MDOC_BODY != node->type && MDOC_HEAD != node->type) | if (MDOC_BLOCK == n->type) | ||
return; | return; | ||
type = arg_listtype(node->parent->parent->parent); | type = n->parent->parent->parent->data.list; | ||
assert(-1 != type); | |||
switch (type) { | switch (type) { | ||
case (MDOC_Diag): | case (LIST_item): | ||
term_word(p, "\\ "); | |||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Item): | case (LIST_diag): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Inset): | case (LIST_inset): | ||
if (MDOC_BODY == node->type) | if (MDOC_BODY == n->type) | ||
term_flushln(p); | term_newln(p); | ||
break; | break; | ||
case (MDOC_Column): | case (LIST_column): | ||
if (MDOC_HEAD == node->type) | if (MDOC_BODY == n->type) | ||
term_flushln(p); | term_flushln(p); | ||
break; | break; | ||
default: | default: | ||
term_flushln(p); | term_newln(p); | ||
break; | break; | ||
} | } | ||
p->flags = pair->flag; | /* | ||
* Now that our output is flushed, we can reset our tags. Since | |||
* only `It' sets these flags, we're free to assume that nobody | |||
* has munged them in the meanwhile. | |||
*/ | |||
p->flags &= ~TERMP_DANGLE; | |||
p->flags &= ~TERMP_NOBREAK; | |||
p->flags &= ~TERMP_TWOSPACE; | |||
p->flags &= ~TERMP_NOLPAD; | |||
p->flags &= ~TERMP_HANG; | |||
} | } | ||
|
|
||
termp_nm_pre(DECL_ARGS) | termp_nm_pre(DECL_ARGS) | ||
{ | { | ||
if (SEC_SYNOPSIS == node->sec) | if (NULL == n->child && NULL == m->name) | ||
return(1); | |||
if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) | |||
term_newln(p); | term_newln(p); | ||
pair->flag |= ttypes[TTYPE_PROG]; | term_fontpush(p, TERMFONT_BOLD); | ||
p->flags |= ttypes[TTYPE_PROG]; | |||
if (NULL == node->child) | if (NULL == n->child) | ||
term_word(p, meta->name); | term_word(p, m->name); | ||
return(1); | return(1); | ||
} | } | ||
|
|
||
termp_fl_pre(DECL_ARGS) | termp_fl_pre(DECL_ARGS) | ||
{ | { | ||
pair->flag |= ttypes[TTYPE_CMD_FLAG]; | term_fontpush(p, TERMFONT_BOLD); | ||
p->flags |= ttypes[TTYPE_CMD_FLAG]; | |||
term_word(p, "\\-"); | term_word(p, "\\-"); | ||
p->flags |= TERMP_NOSPACE; | |||
if (n->child) | |||
p->flags |= TERMP_NOSPACE; | |||
else if (n->next && n->next->line == n->line) | |||
p->flags |= TERMP_NOSPACE; | |||
return(1); | return(1); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_ar_pre(DECL_ARGS) | termp_an_pre(DECL_ARGS) | ||
{ | { | ||
pair->flag |= ttypes[TTYPE_CMD_ARG]; | if (NULL == n->child) | ||
return(1); | |||
/* | |||
* If not in the AUTHORS section, `An -split' will cause | |||
* newlines to occur before the author name. If in the AUTHORS | |||
* section, by default, the first `An' invocation is nosplit, | |||
* then all subsequent ones, regardless of whether interspersed | |||
* with other macros/text, are split. -split, in this case, | |||
* will override the condition of the implied first -nosplit. | |||
*/ | |||
if (n->sec == SEC_AUTHORS) { | |||
if ( ! (TERMP_ANPREC & p->flags)) { | |||
if (TERMP_SPLIT & p->flags) | |||
term_newln(p); | |||
return(1); | |||
} | |||
if (TERMP_NOSPLIT & p->flags) | |||
return(1); | |||
term_newln(p); | |||
return(1); | |||
} | |||
if (TERMP_SPLIT & p->flags) | |||
term_newln(p); | |||
return(1); | return(1); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static void | ||
termp_ns_pre(DECL_ARGS) | termp_an_post(DECL_ARGS) | ||
{ | { | ||
p->flags |= TERMP_NOSPACE; | if (n->child) { | ||
return(1); | if (SEC_AUTHORS == n->sec) | ||
p->flags |= TERMP_ANPREC; | |||
return; | |||
} | |||
if (arg_hasattr(MDOC_Split, n)) { | |||
p->flags &= ~TERMP_NOSPLIT; | |||
p->flags |= TERMP_SPLIT; | |||
} else { | |||
p->flags &= ~TERMP_SPLIT; | |||
p->flags |= TERMP_NOSPLIT; | |||
} | |||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_pp_pre(DECL_ARGS) | termp_ns_pre(DECL_ARGS) | ||
{ | { | ||
term_vspace(p); | p->flags |= TERMP_NOSPACE; | ||
return(1); | return(1); | ||
} | } | ||
|
|
||
termp_rs_pre(DECL_ARGS) | termp_rs_pre(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BLOCK == node->type && node->prev) | if (SEC_SEE_ALSO != n->sec) | ||
return(1); | |||
if (MDOC_BLOCK == n->type && n->prev) | |||
term_vspace(p); | term_vspace(p); | ||
return(1); | return(1); | ||
} | } | ||
|
|
||
static int | static int | ||
termp_rv_pre(DECL_ARGS) | termp_rv_pre(DECL_ARGS) | ||
{ | { | ||
int i; | const struct mdoc_node *nn; | ||
i = arg_getattr(MDOC_Std, node); | |||
assert(-1 != i); | |||
assert(node->args->argv[i].sz); | |||
term_newln(p); | term_newln(p); | ||
term_word(p, "The"); | term_word(p, "The"); | ||
p->flags |= ttypes[TTYPE_FUNC_NAME]; | for (nn = n->child; nn; nn = nn->next) { | ||
term_word(p, *node->args->argv[i].value); | term_fontpush(p, TERMFONT_BOLD); | ||
p->flags &= ~ttypes[TTYPE_FUNC_NAME]; | term_word(p, nn->string); | ||
p->flags |= TERMP_NOSPACE; | term_fontpop(p); | ||
p->flags |= TERMP_NOSPACE; | |||
if (nn->next && NULL == nn->next->next) | |||
term_word(p, "(), and"); | |||
else if (nn->next) | |||
term_word(p, "(),"); | |||
else | |||
term_word(p, "()"); | |||
} | |||
term_word(p, "() function returns the value 0 if successful;"); | if (n->child && n->child->next) | ||
term_word(p, "otherwise the value -1 is returned and the"); | term_word(p, "functions return"); | ||
term_word(p, "global variable"); | else | ||
term_word(p, "function returns"); | |||
p->flags |= ttypes[TTYPE_VAR_DECL]; | term_word(p, "the value 0 if successful; otherwise the value " | ||
"-1 is returned and the global variable"); | |||
term_fontpush(p, TERMFONT_UNDER); | |||
term_word(p, "errno"); | term_word(p, "errno"); | ||
p->flags &= ~ttypes[TTYPE_VAR_DECL]; | term_fontpop(p); | ||
term_word(p, "is set to indicate the error."); | term_word(p, "is set to indicate the error."); | ||
p->flags |= TERMP_SENTENCE; | |||
return(1); | return(0); | ||
} | } | ||
|
|
||
static int | static int | ||
termp_ex_pre(DECL_ARGS) | termp_ex_pre(DECL_ARGS) | ||
{ | { | ||
int i; | const struct mdoc_node *nn; | ||
i = arg_getattr(MDOC_Std, node); | |||
assert(-1 != i); | |||
assert(node->args->argv[i].sz); | |||
term_word(p, "The"); | term_word(p, "The"); | ||
p->flags |= ttypes[TTYPE_PROG]; | |||
term_word(p, *node->args->argv[i].value); | |||
p->flags &= ~ttypes[TTYPE_PROG]; | |||
term_word(p, "utility exits 0 on success, and >0 if an error occurs."); | |||
return(1); | for (nn = n->child; nn; nn = nn->next) { | ||
term_fontpush(p, TERMFONT_BOLD); | |||
term_word(p, nn->string); | |||
term_fontpop(p); | |||
p->flags |= TERMP_NOSPACE; | |||
if (nn->next && NULL == nn->next->next) | |||
term_word(p, ", and"); | |||
else if (nn->next) | |||
term_word(p, ","); | |||
else | |||
p->flags &= ~TERMP_NOSPACE; | |||
} | |||
if (n->child && n->child->next) | |||
term_word(p, "utilities exit"); | |||
else | |||
term_word(p, "utility exits"); | |||
term_word(p, "0 on success, and >0 if an error occurs."); | |||
p->flags |= TERMP_SENTENCE; | |||
return(0); | |||
} | } | ||
|
|
||
termp_nd_pre(DECL_ARGS) | termp_nd_pre(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return(1); | return(1); | ||
#if defined(__OpenBSD__) || defined(__linux__) | #if defined(__OpenBSD__) || defined(__linux__) | ||
|
|
||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | |||
termp_bl_pre(DECL_ARGS) | |||
{ | |||
return(MDOC_HEAD != n->type); | |||
} | |||
/* ARGSUSED */ | |||
static void | static void | ||
termp_bl_post(DECL_ARGS) | termp_bl_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BLOCK == node->type) | if (MDOC_BLOCK == n->type) | ||
term_newln(p); | term_newln(p); | ||
} | } | ||
|
|
||
termp_op_post(DECL_ARGS) | termp_op_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, "\\(rB"); | term_word(p, "\\(rB"); | ||
|
|
||
static int | static int | ||
termp_xr_pre(DECL_ARGS) | termp_xr_pre(DECL_ARGS) | ||
{ | { | ||
const struct mdoc_node *n; | const struct mdoc_node *nn; | ||
assert(node->child && MDOC_TEXT == node->child->type); | if (NULL == n->child) | ||
n = node->child; | return(0); | ||
term_word(p, n->string); | assert(MDOC_TEXT == n->child->type); | ||
if (NULL == (n = n->next)) | nn = n->child; | ||
term_word(p, nn->string); | |||
if (NULL == (nn = nn->next)) | |||
return(0); | return(0); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, "("); | term_word(p, "("); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, n->string); | term_word(p, nn->string); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, ")"); | term_word(p, ")"); | ||
return(0); | return(0); | ||
} | } | ||
/* ARGSUSED */ | |||
static int | static int | ||
termp_vt_pre(DECL_ARGS) | termp_vt_pre(DECL_ARGS) | ||
{ | { | ||
/* FIXME: this can be "type name". */ | if (MDOC_ELEM == n->type) | ||
pair->flag |= ttypes[TTYPE_VAR_DECL]; | return(termp_under_pre(p, pair, m, n)); | ||
return(1); | else if (MDOC_HEAD == n->type) | ||
return(0); | |||
else if (MDOC_BLOCK == n->type) | |||
return(1); | |||
return(termp_under_pre(p, pair, m, n)); | |||
} | } | ||
|
|
||
termp_vt_post(DECL_ARGS) | termp_vt_post(DECL_ARGS) | ||
{ | { | ||
if (node->sec != SEC_SYNOPSIS) | if (MDOC_BLOCK != n->type) | ||
return; | return; | ||
if (node->next && MDOC_Vt == node->next->tok) | if (n->next && MDOC_Vt == n->next->tok) | ||
term_newln(p); | term_newln(p); | ||
else if (node->next) | else if (n->next) | ||
term_vspace(p); | term_vspace(p); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_fd_pre(DECL_ARGS) | termp_bold_pre(DECL_ARGS) | ||
{ | { | ||
pair->flag |= ttypes[TTYPE_FUNC_DECL]; | term_fontpush(p, TERMFONT_BOLD); | ||
return(1); | return(1); | ||
} | } | ||
|
|
||
termp_fd_post(DECL_ARGS) | termp_fd_post(DECL_ARGS) | ||
{ | { | ||
if (node->sec != SEC_SYNOPSIS) | |||
return; | |||
term_newln(p); | term_newln(p); | ||
if (node->next && MDOC_Fd != node->next->tok) | |||
term_vspace(p); | |||
} | } | ||
|
|
||
termp_sh_pre(DECL_ARGS) | termp_sh_pre(DECL_ARGS) | ||
{ | { | ||
switch (node->type) { | /* No vspace between consecutive `Sh' calls. */ | ||
case (MDOC_HEAD): | |||
switch (n->type) { | |||
case (MDOC_BLOCK): | |||
if (n->prev && MDOC_Sh == n->prev->tok) | |||
if (NULL == n->prev->body->child) | |||
break; | |||
term_vspace(p); | term_vspace(p); | ||
pair->flag |= ttypes[TTYPE_SECTION]; | |||
break; | break; | ||
case (MDOC_HEAD): | |||
term_fontpush(p, TERMFONT_BOLD); | |||
break; | |||
case (MDOC_BODY): | case (MDOC_BODY): | ||
p->offset = INDENT; | p->offset = INDENT; | ||
break; | break; | ||
|
|
||
termp_sh_post(DECL_ARGS) | termp_sh_post(DECL_ARGS) | ||
{ | { | ||
switch (node->type) { | switch (n->type) { | ||
case (MDOC_HEAD): | case (MDOC_HEAD): | ||
term_newln(p); | term_newln(p); | ||
break; | break; | ||
|
|
||
termp_op_pre(DECL_ARGS) | termp_op_pre(DECL_ARGS) | ||
{ | { | ||
switch (node->type) { | switch (n->type) { | ||
case (MDOC_BODY): | case (MDOC_BODY): | ||
term_word(p, "\\(lB"); | term_word(p, "\\(lB"); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
|
|
||
{ | { | ||
term_word(p, "is currently in beta test."); | term_word(p, "is currently in beta test."); | ||
return(1); | p->flags |= TERMP_SENTENCE; | ||
return(0); | |||
} | } | ||
|
|
||
termp_lb_post(DECL_ARGS) | termp_lb_post(DECL_ARGS) | ||
{ | { | ||
term_newln(p); | if (SEC_LIBRARY == n->sec && MDOC_LINE & n->flags) | ||
term_newln(p); | |||
} | } | ||
|
|
||
{ | { | ||
term_word(p, "currently under development."); | term_word(p, "currently under development."); | ||
return(1); | p->flags |= TERMP_SENTENCE; | ||
return(0); | |||
} | } | ||
|
|
||
termp_d1_pre(DECL_ARGS) | termp_d1_pre(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BLOCK != node->type) | if (MDOC_BLOCK != n->type) | ||
return(1); | return(1); | ||
term_newln(p); | term_newln(p); | ||
p->offset += (INDENT + 1); | p->offset += (INDENT + 1); | ||
|
|
||
termp_d1_post(DECL_ARGS) | termp_d1_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BLOCK != node->type) | if (MDOC_BLOCK != n->type) | ||
return; | return; | ||
term_newln(p); | term_newln(p); | ||
} | } | ||
|
|
||
termp_aq_pre(DECL_ARGS) | termp_aq_pre(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return(1); | return(1); | ||
term_word(p, "\\(la"); | term_word(p, "\\(la"); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
|
|
||
termp_aq_post(DECL_ARGS) | termp_aq_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, "\\(ra"); | term_word(p, "\\(ra"); | ||
|
|
||
termp_ft_pre(DECL_ARGS) | termp_ft_pre(DECL_ARGS) | ||
{ | { | ||
if (SEC_SYNOPSIS == node->sec) | if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) | ||
if (node->prev && MDOC_Fo == node->prev->tok) | if (n->prev && MDOC_Fo == n->prev->tok) | ||
term_vspace(p); | term_vspace(p); | ||
pair->flag |= ttypes[TTYPE_FUNC_TYPE]; | |||
term_fontpush(p, TERMFONT_UNDER); | |||
return(1); | return(1); | ||
} | } | ||
|
|
||
termp_ft_post(DECL_ARGS) | termp_ft_post(DECL_ARGS) | ||
{ | { | ||
if (SEC_SYNOPSIS == node->sec) | if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) | ||
term_newln(p); | term_newln(p); | ||
} | } | ||
|
|
||
static int | static int | ||
termp_fn_pre(DECL_ARGS) | termp_fn_pre(DECL_ARGS) | ||
{ | { | ||
const struct mdoc_node *n; | const struct mdoc_node *nn; | ||
assert(node->child && MDOC_TEXT == node->child->type); | /* NB: MDOC_LINE has no effect on this macro! */ | ||
if (SEC_SYNOPSIS == n->sec) { | |||
if (n->prev) | |||
term_vspace(p); | |||
} | |||
/* FIXME: can be "type funcname" "type varname"... */ | term_fontpush(p, TERMFONT_BOLD); | ||
term_word(p, n->child->string); | |||
term_fontpop(p); | |||
p->flags |= ttypes[TTYPE_FUNC_NAME]; | |||
term_word(p, node->child->string); | |||
p->flags &= ~ttypes[TTYPE_FUNC_NAME]; | |||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, "("); | term_word(p, "("); | ||
for (n = node->child->next; n; n = n->next) { | for (nn = n->child->next; nn; nn = nn->next) { | ||
p->flags |= ttypes[TTYPE_FUNC_ARG]; | term_fontpush(p, TERMFONT_UNDER); | ||
term_word(p, n->string); | term_word(p, nn->string); | ||
p->flags &= ~ttypes[TTYPE_FUNC_ARG]; | term_fontpop(p); | ||
if (n->next) | |||
if (nn->next) | |||
term_word(p, ","); | term_word(p, ","); | ||
} | } | ||
term_word(p, ")"); | term_word(p, ")"); | ||
if (SEC_SYNOPSIS == node->sec) | if (SEC_SYNOPSIS == n->sec) | ||
term_word(p, ";"); | term_word(p, ";"); | ||
return(0); | return(0); | ||
|
|
||
termp_fn_post(DECL_ARGS) | termp_fn_post(DECL_ARGS) | ||
{ | { | ||
if (node->sec == SEC_SYNOPSIS && node->next) | /* NB: MDOC_LINE has no effect on this macro! */ | ||
term_vspace(p); | if (SEC_SYNOPSIS == n->sec) | ||
term_newln(p); | |||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_sx_pre(DECL_ARGS) | |||
{ | |||
pair->flag |= ttypes[TTYPE_LINK]; | |||
return(1); | |||
} | |||
/* ARGSUSED */ | |||
static int | |||
termp_fa_pre(DECL_ARGS) | termp_fa_pre(DECL_ARGS) | ||
{ | { | ||
struct mdoc_node *n; | const struct mdoc_node *nn; | ||
if (node->parent->tok != MDOC_Fo) { | if (n->parent->tok != MDOC_Fo) { | ||
pair->flag |= ttypes[TTYPE_FUNC_ARG]; | term_fontpush(p, TERMFONT_UNDER); | ||
return(1); | return(1); | ||
} | } | ||
for (n = node->child; n; n = n->next) { | for (nn = n->child; nn; nn = nn->next) { | ||
p->flags |= ttypes[TTYPE_FUNC_ARG]; | term_fontpush(p, TERMFONT_UNDER); | ||
term_word(p, n->string); | term_word(p, nn->string); | ||
p->flags &= ~ttypes[TTYPE_FUNC_ARG]; | term_fontpop(p); | ||
if (n->next) | |||
if (nn->next) | |||
term_word(p, ","); | term_word(p, ","); | ||
} | } | ||
if (node->child && node->next && node->next->tok == MDOC_Fa) | if (n->child && n->next && n->next->tok == MDOC_Fa) | ||
term_word(p, ","); | term_word(p, ","); | ||
return(0); | return(0); | ||
|
|
||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_va_pre(DECL_ARGS) | |||
{ | |||
pair->flag |= ttypes[TTYPE_VAR_DECL]; | |||
return(1); | |||
} | |||
/* ARGSUSED */ | |||
static int | |||
termp_bd_pre(DECL_ARGS) | termp_bd_pre(DECL_ARGS) | ||
{ | { | ||
int i, type, ln; | size_t tabwidth; | ||
int i, type; | |||
size_t rm, rmax; | |||
const struct mdoc_node *nn; | |||
/* | if (MDOC_BLOCK == n->type) { | ||
* This is fairly tricky due primarily to crappy documentation. | print_bvspace(p, n, n); | ||
* If -ragged or -filled are specified, the block does nothing | |||
* but change the indentation. | |||
* | |||
* If, on the other hand, -unfilled or -literal are specified, | |||
* then the game changes. Text is printed exactly as entered in | |||
* the display: if a macro line, a newline is appended to the | |||
* line. Blank lines are allowed. | |||
*/ | |||
if (MDOC_BLOCK == node->type) | |||
return(fmt_block_vspace(p, node, node)); | |||
else if (MDOC_BODY != node->type) | |||
return(1); | return(1); | ||
} else if (MDOC_HEAD == n->type) | |||
return(0); | |||
/* FIXME: display type should be mandated by parser. */ | nn = n->parent; | ||
if (NULL == node->parent->args) | type = arg_disptype(nn); | ||
errx(1, "missing display type"); | assert(-1 != type); | ||
for (type = -1, i = 0; | if (-1 != (i = arg_getattr(MDOC_Offset, nn))) | ||
i < (int)node->parent->args->argc; i++) { | p->offset += a2offs(&nn->args->argv[i]); | ||
switch (node->parent->args->argv[i].arg) { | |||
case (MDOC_Ragged): | |||
/* FALLTHROUGH */ | |||
case (MDOC_Filled): | |||
/* FALLTHROUGH */ | |||
case (MDOC_Unfilled): | |||
/* FALLTHROUGH */ | |||
case (MDOC_Literal): | |||
type = node->parent->args->argv[i].arg; | |||
i = (int)node->parent->args->argc; | |||
break; | |||
default: | |||
break; | |||
} | |||
} | |||
if (NULL == node->parent->args) | |||
errx(1, "missing display type"); | |||
i = arg_getattr(MDOC_Offset, node->parent); | |||
if (-1 != i) { | |||
if (1 != node->parent->args->argv[i].sz) | |||
errx(1, "expected single value"); | |||
p->offset += arg_offset(&node->parent->args->argv[i]); | |||
} | |||
switch (type) { | |||
case (MDOC_Literal): | |||
/* FALLTHROUGH */ | |||
case (MDOC_Unfilled): | |||
break; | |||
default: | |||
return(1); | |||
} | |||
/* | /* | ||
* Tricky. Iterate through all children. If we're on a | * If -ragged or -filled are specified, the block does nothing | ||
* different parse line, append a newline and then the contents. | * but change the indentation. If -unfilled or -literal are | ||
* Ew. | * 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 (MDOC_Literal != type && MDOC_Unfilled != type) | |||
return(1); | |||
ln = node->child ? node->child->line : 0; | tabwidth = p->tabwidth; | ||
p->tabwidth = 8; | |||
rm = p->rmargin; | |||
rmax = p->maxrmargin; | |||
p->rmargin = p->maxrmargin = TERM_MAXMARGIN; | |||
for (node = node->child; node; node = node->next) { | for (nn = n->child; nn; nn = nn->next) { | ||
if (ln < node->line) { | p->flags |= TERMP_NOSPACE; | ||
print_mdoc_node(p, pair, m, nn); | |||
if (NULL == nn->prev || | |||
nn->prev->line < nn->line || | |||
NULL == nn->next) | |||
term_flushln(p); | term_flushln(p); | ||
p->flags |= TERMP_NOSPACE; | |||
} | |||
ln = node->line; | |||
print_node(p, pair, meta, node); | |||
} | } | ||
p->tabwidth = tabwidth; | |||
p->rmargin = rm; | |||
p->maxrmargin = rmax; | |||
return(0); | return(0); | ||
} | } | ||
|
|
||
static void | static void | ||
termp_bd_post(DECL_ARGS) | termp_bd_post(DECL_ARGS) | ||
{ | { | ||
int type; | |||
size_t rm, rmax; | |||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
term_flushln(p); | |||
type = arg_disptype(n->parent); | |||
assert(-1 != type); | |||
rm = p->rmargin; | |||
rmax = p->maxrmargin; | |||
if (MDOC_Literal == type || MDOC_Unfilled == type) | |||
p->rmargin = p->maxrmargin = TERM_MAXMARGIN; | |||
p->flags |= TERMP_NOSPACE; | |||
term_newln(p); | |||
p->rmargin = rm; | |||
p->maxrmargin = rmax; | |||
} | } | ||
|
|
||
termp_qq_pre(DECL_ARGS) | termp_qq_pre(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return(1); | return(1); | ||
term_word(p, "\""); | term_word(p, "\""); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
|
|
||
termp_qq_post(DECL_ARGS) | termp_qq_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, "\""); | term_word(p, "\""); | ||
|
|
||
termp_bx_post(DECL_ARGS) | termp_bx_post(DECL_ARGS) | ||
{ | { | ||
if (node->child) | if (n->child) | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, "BSD"); | term_word(p, "BSD"); | ||
} | } | ||
|
|
||
const char *pp; | const char *pp; | ||
pp = NULL; | pp = NULL; | ||
switch (node->tok) { | switch (n->tok) { | ||
case (MDOC_Bsx): | case (MDOC_Bsx): | ||
pp = "BSDI BSD/OS"; | pp = "BSDI BSD/OS"; | ||
break; | break; | ||
case (MDOC_Dx): | case (MDOC_Dx): | ||
pp = "DragonFlyBSD"; | pp = "DragonFly"; | ||
break; | break; | ||
case (MDOC_Fx): | case (MDOC_Fx): | ||
pp = "FreeBSD"; | pp = "FreeBSD"; | ||
|
|
||
termp_sq_pre(DECL_ARGS) | termp_sq_pre(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return(1); | return(1); | ||
term_word(p, "\\(oq"); | term_word(p, "\\(oq"); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
|
|
||
termp_sq_post(DECL_ARGS) | termp_sq_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, "\\(aq"); | term_word(p, "\\(aq"); | ||
|
|
||
termp_ss_pre(DECL_ARGS) | termp_ss_pre(DECL_ARGS) | ||
{ | { | ||
switch (node->type) { | switch (n->type) { | ||
case (MDOC_BLOCK): | case (MDOC_BLOCK): | ||
term_newln(p); | term_newln(p); | ||
if (node->prev) | if (n->prev) | ||
term_vspace(p); | term_vspace(p); | ||
break; | break; | ||
case (MDOC_HEAD): | case (MDOC_HEAD): | ||
pair->flag |= ttypes[TTYPE_SSECTION]; | term_fontpush(p, TERMFONT_BOLD); | ||
p->offset = HALFINDENT; | p->offset = HALFINDENT; | ||
break; | break; | ||
default: | default: | ||
|
|
||
termp_ss_post(DECL_ARGS) | termp_ss_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
term_newln(p); | term_newln(p); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_pa_pre(DECL_ARGS) | |||
{ | |||
pair->flag |= ttypes[TTYPE_FILE]; | |||
return(1); | |||
} | |||
/* ARGSUSED */ | |||
static int | |||
termp_em_pre(DECL_ARGS) | |||
{ | |||
pair->flag |= ttypes[TTYPE_EMPH]; | |||
return(1); | |||
} | |||
/* ARGSUSED */ | |||
static int | |||
termp_cd_pre(DECL_ARGS) | termp_cd_pre(DECL_ARGS) | ||
{ | { | ||
pair->flag |= ttypes[TTYPE_CONFIG]; | term_fontpush(p, TERMFONT_BOLD); | ||
term_newln(p); | term_newln(p); | ||
return(1); | return(1); | ||
} | } | ||
|
|
||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_cm_pre(DECL_ARGS) | |||
{ | |||
pair->flag |= ttypes[TTYPE_CMD_FLAG]; | |||
return(1); | |||
} | |||
/* ARGSUSED */ | |||
static int | |||
termp_ic_pre(DECL_ARGS) | |||
{ | |||
pair->flag |= ttypes[TTYPE_CMD]; | |||
return(1); | |||
} | |||
/* ARGSUSED */ | |||
static int | |||
termp_in_pre(DECL_ARGS) | termp_in_pre(DECL_ARGS) | ||
{ | { | ||
pair->flag |= ttypes[TTYPE_INCLUDE]; | if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) { | ||
p->flags |= ttypes[TTYPE_INCLUDE]; | term_fontpush(p, TERMFONT_BOLD); | ||
if (SEC_SYNOPSIS == node->sec) | |||
term_word(p, "#include"); | term_word(p, "#include"); | ||
term_word(p, "<"); | |||
} else { | |||
term_word(p, "<"); | |||
term_fontpush(p, TERMFONT_UNDER); | |||
} | |||
term_word(p, "<"); | |||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
return(1); | return(1); | ||
} | } | ||
|
|
||
termp_in_post(DECL_ARGS) | termp_in_post(DECL_ARGS) | ||
{ | { | ||
p->flags |= TERMP_NOSPACE | ttypes[TTYPE_INCLUDE]; | if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) | ||
term_fontpush(p, TERMFONT_BOLD); | |||
p->flags |= TERMP_NOSPACE; | |||
term_word(p, ">"); | term_word(p, ">"); | ||
p->flags &= ~ttypes[TTYPE_INCLUDE]; | |||
if (SEC_SYNOPSIS != node->sec) | if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) { | ||
return; | term_fontpop(p); | ||
term_newln(p); | |||
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 <foo>; mandoc asserts a vertical space. Since this | |||
* construction is rarely used, I think it's fine. | |||
*/ | |||
if (node->next && MDOC_In != node->next->tok) | |||
term_vspace(p); | |||
} | } | ||
|
|
||
static int | static int | ||
termp_sp_pre(DECL_ARGS) | termp_sp_pre(DECL_ARGS) | ||
{ | { | ||
int i, len; | size_t i, len; | ||
if (NULL == node->child) { | switch (n->tok) { | ||
term_vspace(p); | case (MDOC_sp): | ||
return(0); | len = n->child ? a2height(n->child) : 1; | ||
break; | |||
case (MDOC_br): | |||
len = 0; | |||
break; | |||
default: | |||
len = 1; | |||
break; | |||
} | } | ||
len = atoi(node->child->string); | |||
if (0 == len) | if (0 == len) | ||
term_newln(p); | term_newln(p); | ||
for (i = 0; i < len; i++) | for (i = 0; i < len; i++) | ||
|
|
||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_br_pre(DECL_ARGS) | |||
{ | |||
term_newln(p); | |||
return(1); | |||
} | |||
/* ARGSUSED */ | |||
static int | |||
termp_brq_pre(DECL_ARGS) | termp_brq_pre(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return(1); | return(1); | ||
term_word(p, "\\(lC"); | term_word(p, "\\(lC"); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
|
|
||
termp_brq_post(DECL_ARGS) | termp_brq_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, "\\(rC"); | term_word(p, "\\(rC"); | ||
|
|
||
termp_bq_pre(DECL_ARGS) | termp_bq_pre(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return(1); | return(1); | ||
term_word(p, "\\(lB"); | term_word(p, "\\(lB"); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
|
|
||
termp_bq_post(DECL_ARGS) | termp_bq_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, "\\(rB"); | term_word(p, "\\(rB"); | ||
|
|
||
termp_pq_pre(DECL_ARGS) | termp_pq_pre(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return(1); | return(1); | ||
term_word(p, "\\&("); | term_word(p, "\\&("); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
|
|
||
termp_pq_post(DECL_ARGS) | termp_pq_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
term_word(p, ")"); | term_word(p, ")"); | ||
} | } | ||
|
|
||
static int | static int | ||
termp_fo_pre(DECL_ARGS) | termp_fo_pre(DECL_ARGS) | ||
{ | { | ||
const struct mdoc_node *n; | const struct mdoc_node *nn; | ||
if (MDOC_BODY == node->type) { | if (MDOC_BODY == n->type) { | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, "("); | term_word(p, "("); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
return(1); | return(1); | ||
} else if (MDOC_HEAD != node->type) | } else if (MDOC_HEAD != n->type) | ||
return(1); | return(1); | ||
p->flags |= ttypes[TTYPE_FUNC_NAME]; | term_fontpush(p, TERMFONT_BOLD); | ||
for (n = node->child; n; n = n->next) { | for (nn = n->child; nn; nn = nn->next) { | ||
assert(MDOC_TEXT == n->type); | assert(MDOC_TEXT == nn->type); | ||
term_word(p, n->string); | term_word(p, nn->string); | ||
} | } | ||
p->flags &= ~ttypes[TTYPE_FUNC_NAME]; | term_fontpop(p); | ||
return(0); | return(0); | ||
} | } | ||
|
|
||
termp_fo_post(DECL_ARGS) | termp_fo_post(DECL_ARGS) | ||
{ | { | ||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, ")"); | term_word(p, ")"); | ||
|
|
||
static int | static int | ||
termp_bf_pre(DECL_ARGS) | termp_bf_pre(DECL_ARGS) | ||
{ | { | ||
const struct mdoc_node *n; | const struct mdoc_node *nn; | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
return(0); | return(0); | ||
else if (MDOC_BLOCK != node->type) | else if (MDOC_BLOCK != n->type) | ||
return(1); | return(1); | ||
if (NULL == (n = node->head->child)) { | if (NULL == (nn = n->head->child)) { | ||
if (arg_hasattr(MDOC_Emphasis, node)) | if (arg_hasattr(MDOC_Emphasis, n)) | ||
pair->flag |= ttypes[TTYPE_EMPH]; | term_fontpush(p, TERMFONT_UNDER); | ||
else if (arg_hasattr(MDOC_Symbolic, node)) | else if (arg_hasattr(MDOC_Symbolic, n)) | ||
pair->flag |= ttypes[TTYPE_SYMB]; | term_fontpush(p, TERMFONT_BOLD); | ||
else | |||
term_fontpush(p, TERMFONT_NONE); | |||
return(1); | return(1); | ||
} | } | ||
assert(MDOC_TEXT == n->type); | assert(MDOC_TEXT == nn->type); | ||
if (0 == strcmp("Em", n->string)) | if (0 == strcmp("Em", nn->string)) | ||
pair->flag |= ttypes[TTYPE_EMPH]; | term_fontpush(p, TERMFONT_UNDER); | ||
else if (0 == strcmp("Sy", n->string)) | else if (0 == strcmp("Sy", nn->string)) | ||
pair->flag |= ttypes[TTYPE_SYMB]; | term_fontpush(p, TERMFONT_BOLD); | ||
else | |||
term_fontpush(p, TERMFONT_NONE); | |||
return(1); | return(1); | ||
} | } | ||
|
|
||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_sy_pre(DECL_ARGS) | |||
{ | |||
pair->flag |= ttypes[TTYPE_SYMB]; | |||
return(1); | |||
} | |||
/* ARGSUSED */ | |||
static int | |||
termp_ms_pre(DECL_ARGS) | |||
{ | |||
pair->flag |= ttypes[TTYPE_SYMBOL]; | |||
return(1); | |||
} | |||
/* ARGSUSED */ | |||
static int | |||
termp_sm_pre(DECL_ARGS) | termp_sm_pre(DECL_ARGS) | ||
{ | { | ||
assert(node->child && MDOC_TEXT == node->child->type); | assert(n->child && MDOC_TEXT == n->child->type); | ||
if (0 == strcmp("on", node->child->string)) { | if (0 == strcmp("on", n->child->string)) | ||
p->flags &= ~TERMP_NONOSPACE; | p->flags &= ~TERMP_NONOSPACE; | ||
p->flags &= ~TERMP_NOSPACE; | else | ||
} else | |||
p->flags |= TERMP_NONOSPACE; | p->flags |= TERMP_NONOSPACE; | ||
return(0); | return(0); | ||
|
|
||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static void | ||
termp__j_pre(DECL_ARGS) | termp____post(DECL_ARGS) | ||
{ | { | ||
pair->flag |= ttypes[TTYPE_REF_JOURNAL]; | /* TODO: %U. */ | ||
return(1); | |||
p->flags |= TERMP_NOSPACE; | |||
term_word(p, n->next ? "," : "."); | |||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp__t_pre(DECL_ARGS) | termp_li_pre(DECL_ARGS) | ||
{ | { | ||
term_word(p, "\""); | term_fontpush(p, TERMFONT_NONE); | ||
p->flags |= TERMP_NOSPACE; | |||
return(1); | return(1); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static void | |||
termp__t_post(DECL_ARGS) | |||
{ | |||
p->flags |= TERMP_NOSPACE; | |||
term_word(p, "\""); | |||
termp____post(p, pair, meta, node); | |||
} | |||
/* ARGSUSED */ | |||
static void | |||
termp____post(DECL_ARGS) | |||
{ | |||
p->flags |= TERMP_NOSPACE; | |||
term_word(p, node->next ? "," : "."); | |||
} | |||
/* ARGSUSED */ | |||
static int | static int | ||
termp_lk_pre(DECL_ARGS) | termp_lk_pre(DECL_ARGS) | ||
{ | { | ||
const struct mdoc_node *n; | const struct mdoc_node *nn; | ||
assert(node->child); | term_fontpush(p, TERMFONT_UNDER); | ||
n = node->child; | nn = n->child; | ||
if (NULL == n->next) { | if (NULL == nn->next) | ||
pair->flag |= ttypes[TTYPE_LINK_ANCHOR]; | |||
return(1); | return(1); | ||
} | |||
p->flags |= ttypes[TTYPE_LINK_ANCHOR]; | term_word(p, nn->string); | ||
term_word(p, n->string); | term_fontpop(p); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, ":"); | term_word(p, ":"); | ||
p->flags &= ~ttypes[TTYPE_LINK_ANCHOR]; | |||
p->flags |= ttypes[TTYPE_LINK_TEXT]; | term_fontpush(p, TERMFONT_BOLD); | ||
for (n = n->next; n; n = n->next) | for (nn = nn->next; nn; nn = nn->next) | ||
term_word(p, n->string); | term_word(p, nn->string); | ||
term_fontpop(p); | |||
p->flags &= ~ttypes[TTYPE_LINK_TEXT]; | |||
return(0); | return(0); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_mt_pre(DECL_ARGS) | termp_under_pre(DECL_ARGS) | ||
{ | { | ||
pair->flag |= ttypes[TTYPE_LINK_ANCHOR]; | term_fontpush(p, TERMFONT_UNDER); | ||
return(1); | return(1); | ||
} | } | ||