![]() ![]() | ![]() |
version 1.77, 2009/09/21 14:08:13 | version 1.164, 2010/07/01 15:38:56 | ||
---|---|---|---|
|
|
||
/* $Id$ */ | /* $Id$ */ | ||
/* | /* | ||
* Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se> | * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@bsd.lv> | ||
* | * | ||
* Permission to use, copy, modify, and distribute this software for any | * Permission to use, copy, modify, and distribute this software for any | ||
* purpose with or without fee is hereby granted, provided that the above | * purpose with or without fee is hereby granted, provided that the above | ||
|
|
||
* 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 "regs.h" | |||
#include "mdoc.h" | #include "mdoc.h" | ||
#include "chars.h" | |||
#include "main.h" | |||
/* FIXME: check HANG lists: they seem to be broken... : | |||
* .Bl -hang -width Ds | |||
* .It a | |||
* b | |||
* .It Fl f Ns Ar option... | |||
* Override default compiler behaviour. See | |||
* .Sx Compiler Options | |||
* for details. | |||
* Override default compiler behaviour. See | |||
* .Sx Compiler Options | |||
* for details. | |||
* Override default compiler behaviour. See | |||
* .Sx Compiler Options | |||
* for details. | |||
* Override default compiler behaviour. See | |||
* .Sx Compiler Options | |||
* for details. | |||
* . | |||
* .It a sasd fasd as afsd sfad sfds sadfs sd sfd ssfad asfd | |||
* Override default compiler behaviour. See | |||
* .Sx Compiler Options | |||
* for details. | |||
* Override default compiler behaviour. See | |||
* .Sx Compiler Options | |||
* for details. | |||
* Override default compiler behaviour. See | |||
* .Sx Compiler Options | |||
* for details. | |||
* Override default compiler behaviour. See | |||
* .Sx Compiler Options | |||
* for details. | |||
* .El | |||
* | |||
*/ | |||
#define INDENT 5 | #define INDENT 5 | ||
#define HALFINDENT 3 | #define HALFINDENT 3 | ||
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 termp *, const char *); | |||
static size_t a2height(const struct termp *, const char *); | |||
static size_t a2offs(const struct termp *, const char *); | |||
static int arg_hasattr(int, const struct mdoc_node *); | |||
static int arg_getattr(int, 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_nodelist(DECL_ARGS); | |||
static void print_mdoc_head(struct termp *, const void *); | |||
static void print_mdoc_foot(struct termp *, const void *); | |||
static void synopsis_pre(struct termp *, | |||
const struct mdoc_node *); | |||
static void termp____post(DECL_ARGS); | static void termp____post(DECL_ARGS); | ||
static void termp_an_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_bk_post(DECL_ARGS); | |||
static void termp_bl_post(DECL_ARGS); | static void termp_bl_post(DECL_ARGS); | ||
static void termp_bq_post(DECL_ARGS); | static void termp_bq_post(DECL_ARGS); | ||
static void termp_brq_post(DECL_ARGS); | static void termp_brq_post(DECL_ARGS); | ||
static void termp_bx_post(DECL_ARGS); | static void termp_bx_post(DECL_ARGS); | ||
static void termp_d1_post(DECL_ARGS); | static void termp_d1_post(DECL_ARGS); | ||
static void termp_dq_post(DECL_ARGS); | static void termp_dq_post(DECL_ARGS); | ||
static void termp_fd_post(DECL_ARGS); | static int termp_fd_pre(DECL_ARGS); | ||
static void termp_fn_post(DECL_ARGS); | |||
static void termp_fo_post(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_in_post(DECL_ARGS); | ||
static void termp_it_post(DECL_ARGS); | static void termp_it_post(DECL_ARGS); | ||
static void termp_lb_post(DECL_ARGS); | static void termp_lb_post(DECL_ARGS); | ||
static void termp_nm_post(DECL_ARGS); | |||
static void termp_op_post(DECL_ARGS); | static void termp_op_post(DECL_ARGS); | ||
static void termp_pf_post(DECL_ARGS); | static void termp_pf_post(DECL_ARGS); | ||
static void termp_pq_post(DECL_ARGS); | static void termp_pq_post(DECL_ARGS); | ||
|
|
||
static void termp_sh_post(DECL_ARGS); | static void termp_sh_post(DECL_ARGS); | ||
static void termp_sq_post(DECL_ARGS); | static void termp_sq_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 int termp_an_pre(DECL_ARGS); | static int termp_an_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_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_bk_pre(DECL_ARGS); | |||
static int termp_bl_pre(DECL_ARGS); | |||
static int termp_bold_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_brq_pre(DECL_ARGS); | static int termp_brq_pre(DECL_ARGS); | ||
|
|
||
static int termp_ft_pre(DECL_ARGS); | static int termp_ft_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_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_ss_pre(DECL_ARGS); | static int termp_ss_pre(DECL_ARGS); | ||
static int termp_under_pre(DECL_ARGS); | static int termp_under_pre(DECL_ARGS); | ||
static int termp_ud_pre(DECL_ARGS); | static int termp_ud_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); | ||
|
|
||
{ 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 }, /* 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_bold_pre, termp_fd_post }, /* Fd */ | { termp_fd_pre, NULL }, /* Fd */ | ||
{ termp_fl_pre, NULL }, /* Fl */ | { termp_fl_pre, NULL }, /* Fl */ | ||
{ termp_fn_pre, termp_fn_post }, /* Fn */ | { termp_fn_pre, NULL }, /* Fn */ | ||
{ termp_ft_pre, termp_ft_post }, /* Ft */ | { termp_ft_pre, NULL }, /* Ft */ | ||
{ termp_bold_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, termp_nm_post }, /* Nm */ | ||
{ termp_op_pre, termp_op_post }, /* Op */ | { termp_op_pre, termp_op_post }, /* Op */ | ||
{ NULL, NULL }, /* Ot */ | { NULL, NULL }, /* Ot */ | ||
{ termp_under_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_under_pre, NULL }, /* Va */ | { termp_under_pre, NULL }, /* Va */ | ||
{ termp_under_pre, termp_vt_post }, /* Vt */ | { termp_vt_pre, NULL }, /* 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_under_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, 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_under_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_bold_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 */ | ||
|
|
||
{ NULL, NULL }, /* Fc */ | { NULL, NULL }, /* Fc */ | ||
{ termp_op_pre, termp_op_post }, /* Oo */ | { termp_op_pre, termp_op_post }, /* Oo */ | ||
{ NULL, NULL }, /* Oc */ | { NULL, NULL }, /* Oc */ | ||
{ NULL, NULL }, /* Bk */ | { termp_bk_pre, termp_bk_post }, /* Bk */ | ||
{ NULL, NULL }, /* Ek */ | { NULL, NULL }, /* Ek */ | ||
{ termp_bt_pre, NULL }, /* Bt */ | { termp_bt_pre, NULL }, /* Bt */ | ||
{ NULL, NULL }, /* Hf */ | { NULL, NULL }, /* Hf */ | ||
|
|
||
{ 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_sp_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 *); | |||
static int arg_getattrs(const int *, int *, size_t, | |||
const struct mdoc_node *); | |||
static int arg_getattr(int, const struct mdoc_node *); | |||
static size_t arg_offset(const struct mdoc_argv *); | |||
static size_t arg_width(const struct mdoc_argv *, int); | |||
static int arg_listtype(const struct mdoc_node *); | |||
static void fmt_block_vspace(struct termp *, | |||
const struct mdoc_node *, | |||
const struct mdoc_node *); | |||
static void print_node(DECL_ARGS); | |||
static void print_head(DECL_ARGS); | |||
static void print_body(DECL_ARGS); | |||
static void print_foot(DECL_ARGS); | |||
void | void | ||
mdoc_run(struct termp *p, const struct mdoc *mdoc) | terminal_mdoc(void *arg, const struct mdoc *mdoc) | ||
{ | { | ||
const struct mdoc_node *n; | const struct mdoc_node *n; | ||
const struct mdoc_meta *m; | const struct mdoc_meta *m; | ||
struct termp *p; | |||
p = (struct termp *)arg; | |||
p->overstep = 0; | |||
p->maxrmargin = p->defrmargin; | |||
p->tabwidth = term_len(p, 5); | |||
if (NULL == p->symtab) | |||
switch (p->enc) { | |||
case (TERMENC_ASCII): | |||
p->symtab = chars_init(CHARS_ASCII); | |||
break; | |||
default: | |||
abort(); | |||
/* NOTREACHED */ | |||
} | |||
n = mdoc_node(mdoc); | n = mdoc_node(mdoc); | ||
m = mdoc_meta(mdoc); | m = mdoc_meta(mdoc); | ||
print_head(p, NULL, m, n); | term_begin(p, print_mdoc_head, print_mdoc_foot, m); | ||
if (n->child) | if (n->child) | ||
print_body(p, NULL, m, n->child); | print_mdoc_nodelist(p, NULL, m, n->child); | ||
print_foot(p, NULL, m, n); | |||
term_end(p); | |||
} | } | ||
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) | ||
print_body(p, pair, meta, node->next); | print_mdoc_nodelist(p, pair, m, n->next); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static void | static void | ||
print_node(DECL_ARGS) | print_mdoc_node(DECL_ARGS) | ||
{ | { | ||
int chld, bold, under; | int chld; | ||
const void *font; | |||
struct termpair npair; | struct termpair npair; | ||
size_t offset, rmargin; | size_t offset, rmargin; | ||
chld = 1; | chld = 1; | ||
offset = p->offset; | offset = p->offset; | ||
rmargin = p->rmargin; | rmargin = p->rmargin; | ||
bold = p->bold; | font = term_fontq(p); | ||
under = p->under; | |||
bzero(&npair, sizeof(struct termpair)); | memset(&npair, 0, sizeof(struct termpair)); | ||
npair.ppair = pair; | npair.ppair = pair; | ||
if (MDOC_TEXT != node->type) { | if (MDOC_TEXT == n->type) | ||
if (termacts[node->tok].pre) | term_word(p, n->string); | ||
chld = (*termacts[node->tok].pre) | else if (termacts[n->tok].pre && ENDBODY_NOT == n->end) | ||
(p, &npair, meta, node); | chld = (*termacts[n->tok].pre)(p, &npair, m, n); | ||
} else | |||
term_word(p, node->string); | |||
if (chld && node->child) | if (chld && n->child) | ||
print_body(p, &npair, meta, node->child); | print_mdoc_nodelist(p, &npair, m, n->child); | ||
/* | term_fontpopq(p, font); | ||
* XXX - if bold/under were to span scopes, this wouldn't be | |||
* possible, but because decoration is always in-scope, we can | |||
* get away with this. | |||
*/ | |||
p->bold = bold; | if (MDOC_TEXT != n->type && | ||
p->under = under; | termacts[n->tok].post && | ||
! (MDOC_ENDED & n->flags)) { | |||
(*termacts[n->tok].post)(p, &npair, m, n); | |||
if (MDOC_TEXT != node->type) | /* | ||
if (termacts[node->tok].post) | * Explicit end tokens not only call the post | ||
(*termacts[node->tok].post) | * handler, but also tell the respective block | ||
(p, &npair, meta, node); | * that it must not call the post handler again. | ||
*/ | |||
if (n->end) | |||
n->pending->flags |= MDOC_ENDED; | |||
/* | |||
* End of line terminating an implicit block | |||
* while an explicit block is still open. | |||
* Continue the explicit block without spacing. | |||
*/ | |||
if (ENDBODY_NOSPACE == n->end) | |||
p->flags |= TERMP_NOSPACE; | |||
} | |||
if (MDOC_EOS & n->flags) | |||
p->flags |= TERMP_SENTENCE; | |||
p->offset = offset; | p->offset = offset; | ||
p->rmargin = rmargin; | p->rmargin = rmargin; | ||
} | } | ||
/* ARGSUSED */ | |||
static void | static void | ||
print_foot(DECL_ARGS) | print_mdoc_foot(struct termp *p, const void *arg) | ||
{ | { | ||
struct tm *tm; | char buf[DATESIZ], os[BUFSIZ]; | ||
char *buf, *os; | const struct mdoc_meta *m; | ||
m = (const struct mdoc_meta *)arg; | |||
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(EXIT_FAILURE, "malloc"); | strlcpy(os, m->os, BUFSIZ); | ||
if (NULL == (os = malloc(p->rmargin))) | |||
err(EXIT_FAILURE, "malloc"); | |||
tm = localtime(&meta->date); | |||
if (0 == strftime(buf, p->rmargin, "%B %e, %Y", tm)) | |||
err(EXIT_FAILURE, "strftime"); | |||
(void)strlcpy(os, meta->os, p->rmargin); | |||
term_vspace(p); | term_vspace(p); | ||
p->offset = 0; | p->offset = 0; | ||
p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2; | p->rmargin = (p->maxrmargin - | ||
term_strlen(p, buf) + term_len(p, 1)) / 2; | |||
p->flags |= TERMP_NOSPACE | TERMP_NOBREAK; | p->flags |= TERMP_NOSPACE | TERMP_NOBREAK; | ||
term_word(p, os); | term_word(p, os); | ||
term_flushln(p); | term_flushln(p); | ||
p->offset = p->rmargin; | p->offset = p->rmargin; | ||
p->rmargin = p->maxrmargin - strlen(os); | p->rmargin = p->maxrmargin - term_strlen(p, os); | ||
p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; | p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; | ||
term_word(p, buf); | term_word(p, buf); | ||
|
|
||
p->offset = 0; | p->offset = 0; | ||
p->rmargin = p->maxrmargin; | p->rmargin = p->maxrmargin; | ||
p->flags = 0; | p->flags = 0; | ||
free(buf); | |||
free(os); | |||
} | } | ||
/* FIXME: put in utility library. */ | |||
/* ARGSUSED */ | |||
static void | static void | ||
print_head(DECL_ARGS) | print_mdoc_head(struct termp *p, const void *arg) | ||
{ | { | ||
char *buf, *title; | char buf[BUFSIZ], title[BUFSIZ]; | ||
const struct mdoc_meta *m; | |||
m = (const struct mdoc_meta *)arg; | |||
p->rmargin = p->maxrmargin; | p->rmargin = p->maxrmargin; | ||
p->offset = 0; | p->offset = 0; | ||
if (NULL == (buf = malloc(p->rmargin))) | |||
err(EXIT_FAILURE, "malloc"); | |||
if (NULL == (title = malloc(p->rmargin))) | |||
err(EXIT_FAILURE, "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); | ||
} | } | ||
snprintf(title, p->rmargin, "%s(%d)", meta->title, meta->msec); | snprintf(title, BUFSIZ, "%s(%s)", m->title, m->msec); | ||
p->offset = 0; | p->offset = 0; | ||
p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2; | p->rmargin = (p->maxrmargin - | ||
term_strlen(p, buf) + term_len(p, 1)) / 2; | |||
p->flags |= TERMP_NOBREAK | TERMP_NOSPACE; | p->flags |= TERMP_NOBREAK | TERMP_NOSPACE; | ||
term_word(p, title); | term_word(p, title); | ||
term_flushln(p); | term_flushln(p); | ||
p->offset = p->rmargin; | p->offset = p->rmargin; | ||
p->rmargin = p->maxrmargin - strlen(title); | p->rmargin = p->maxrmargin - term_strlen(p, title); | ||
p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; | p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; | ||
term_word(p, buf); | term_word(p, buf); | ||
|
|
||
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); | |||
} | } | ||
/* FIXME: put in utility file for front-ends. */ | |||
static size_t | static size_t | ||
arg_width(const struct mdoc_argv *arg, int pos) | a2height(const struct termp *p, const char *v) | ||
{ | { | ||
int i, len; | struct roffsu su; | ||
const char *p; | |||
assert(pos < (int)arg->sz && pos >= 0); | assert(v); | ||
assert(arg->value[pos]); | if ( ! a2roffsu(v, &su, SCALE_VS)) | ||
SCALE_VS_INIT(&su, term_len(p, 1)); | |||
p = arg->value[pos]; | return(term_vspan(p, &su)); | ||
if (0 == (len = (int)strlen(p))) | |||
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) + 2); | |||
return((size_t)len + 2); | |||
} | } | ||
/* FIXME: put in utility file for front-ends. */ | static size_t | ||
static int | a2width(const struct termp *p, const char *v) | ||
arg_listtype(const struct mdoc_node *n) | |||
{ | { | ||
int i, len; | struct roffsu su; | ||
assert(MDOC_BLOCK == n->type); | assert(v); | ||
if ( ! a2roffsu(v, &su, SCALE_MAX)) | |||
SCALE_HS_INIT(&su, term_strlen(p, v)); | |||
len = (int)(n->args ? n->args->argc : 0); | return(term_hspan(p, &su)); | ||
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); | |||
} | } | ||
/* FIXME: put in utility file for front-ends. */ | |||
static size_t | static size_t | ||
arg_offset(const struct mdoc_argv *arg) | a2offs(const struct termp *p, const char *v) | ||
{ | { | ||
int len, i; | struct roffsu su; | ||
const char *p; | |||
assert(*arg->value); | if ('\0' == *v) | ||
p = *arg->value; | |||
if (0 == strcmp(p, "left")) | |||
return(0); | return(0); | ||
if (0 == strcmp(p, "indent")) | else if (0 == strcmp(v, "left")) | ||
return(INDENT + 1); | |||
if (0 == strcmp(p, "indent-two")) | |||
return((INDENT + 1) * 2); | |||
if (0 == (len = (int)strlen(p))) | |||
return(0); | return(0); | ||
else if (0 == strcmp(v, "indent")) | |||
return(term_len(p, INDENT + 1)); | |||
else if (0 == strcmp(v, "indent-two")) | |||
return(term_len(p, (INDENT + 1) * 2)); | |||
else if ( ! a2roffsu(v, &su, SCALE_MAX)) | |||
SCALE_HS_INIT(&su, term_strlen(p, v)); | |||
for (i = 0; i < len - 1; i++) | return(term_hspan(p, &su)); | ||
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. | |||
*/ | |||
static int | static int | ||
arg_getattr(int v, const struct mdoc_node *n) | arg_getattr(int v, const struct mdoc_node *n) | ||
{ | { | ||
int val; | int i; | ||
return(arg_getattrs(&v, &val, 1, n) ? val : -1); | |||
} | |||
static int | |||
arg_getattrs(const int *keys, int *vals, | |||
size_t sz, const struct mdoc_node *n) | |||
{ | |||
int i, j, k; | |||
if (NULL == n->args) | if (NULL == n->args) | ||
return(0); | return(0); | ||
for (k = i = 0; i < (int)n->args->argc; i++) | for (i = 0; i < (int)n->args->argc; i++) | ||
for (j = 0; j < (int)sz; j++) | if (n->args->argv[i].arg == v) | ||
if (n->args->argv[i].arg == keys[j]) { | return(i); | ||
vals[j] = i; | |||
k++; | return(-1); | ||
} | |||
return(k); | |||
} | } | ||
/* ARGSUSED */ | /* | ||
* Determine how much space to print out before block elements of `It' | |||
* (and thus `Bl') and `Bd'. And then go ahead and print that space, | |||
* too. | |||
*/ | |||
static void | static void | ||
fmt_block_vspace(struct termp *p, | 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 (MDOC_Bl == bl->tok && arg_hasattr(MDOC_Compact, bl)) | if (MDOC_Bd == bl->tok && bl->data.Bd.comp) | ||
return; | return; | ||
assert(node); | if (MDOC_Bl == bl->tok && bl->data.Bl.comp) | ||
return; | |||
/* | /* Do not vspace directly after Ss/Sh. */ | ||
* Search through our prior nodes. If we follow a `Ss' or `Sh', | |||
* then don't vspace. | |||
*/ | |||
for (n = node; n; n = n->parent) { | for (nn = n; nn; nn = nn->parent) { | ||
if (MDOC_BLOCK != n->type) | if (MDOC_BLOCK != nn->type) | ||
continue; | continue; | ||
if (MDOC_Ss == n->tok) | if (MDOC_Ss == nn->tok) | ||
return; | return; | ||
if (MDOC_Sh == n->tok) | if (MDOC_Sh == nn->tok) | ||
return; | return; | ||
if (NULL == n->prev) | if (NULL == nn->prev) | ||
continue; | continue; | ||
break; | break; | ||
} | } | ||
/* | /* A `-column' does not assert vspace within the list. */ | ||
* XXX - not documented: a `-column' does not ever assert vspace | |||
* within the list. | |||
*/ | |||
if (MDOC_Bl == bl->tok && arg_hasattr(MDOC_Column, bl)) | if (MDOC_Bl == bl->tok && LIST_column == bl->data.Bl.type) | ||
if (node->prev && MDOC_It == node->prev->tok) | if (n->prev && MDOC_It == n->prev->tok) | ||
return; | return; | ||
/* | /* A `-diag' without body does not vspace. */ | ||
* XXX - not documented: a `-diag' without a body does not | |||
* assert a vspace prior to the next element. | if (MDOC_Bl == bl->tok && LIST_diag == bl->data.Bl.type) | ||
*/ | if (n->prev && MDOC_It == n->prev->tok) { | ||
if (MDOC_Bl == bl->tok && arg_hasattr(MDOC_Diag, bl)) | assert(n->prev->body); | ||
if (node->prev && MDOC_It == node->prev->tok) { | if (NULL == n->prev->body->child) | ||
assert(node->prev->body); | |||
if (NULL == node->prev->body->child) | |||
return; | return; | ||
} | } | ||
|
|
||
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, col; | ||
size_t width, offset; | size_t width, offset, ncols, dcol; | ||
enum mdoc_list type; | |||
if (MDOC_BLOCK == node->type) { | if (MDOC_BLOCK == n->type) { | ||
fmt_block_vspace(p, node->parent->parent, node); | print_bvspace(p, n->parent->parent, n); | ||
return(1); | return(1); | ||
} | } | ||
bl = node->parent->parent->parent; | bl = n->parent->parent->parent; | ||
type = bl->data.Bl.type; | |||
/* Save parent attributes. */ | /* | ||
* 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. | |||
*/ | |||
pair->flag = p->flags; | width = offset = 0; | ||
/* Get list width and offset. */ | if (bl->data.Bl.offs) | ||
offset = a2offs(p, bl->data.Bl.offs); | |||
keys[0] = MDOC_Width; | switch (type) { | ||
keys[1] = MDOC_Offset; | case (LIST_column): | ||
keys[2] = MDOC_Column; | if (MDOC_HEAD == n->type) | ||
break; | |||
vals[0] = vals[1] = vals[2] = -1; | col = arg_getattr(MDOC_Column, bl); | ||
width = offset = 0; | /* | ||
* 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[col].sz; | |||
/* LINTED */ | |||
dcol = ncols < 5 ? term_len(p, 4) : | |||
ncols == 5 ? term_len(p, 3) : term_len(p, 1); | |||
(void)arg_getattrs(keys, vals, 3, bl); | /* | ||
* Calculate the offset by applying all prior MDOC_BODY, | |||
* so we stop at the MDOC_HEAD (NULL == nn->prev). | |||
*/ | |||
type = arg_listtype(bl); | for (i = 0, nn = n->prev; | ||
assert(-1 != type); | nn->prev && i < (int)ncols; | ||
nn = nn->prev, i++) | |||
offset += dcol + a2width | |||
(p, bl->args->argv[col].value[i]); | |||
/* Calculate real width and offset. */ | /* | ||
* 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; | |||
switch (type) { | /* | ||
case (MDOC_Column): | * Use the declared column widths, extended as explained | ||
if (MDOC_BODY == node->type) | * in the preceding paragraph. | ||
*/ | |||
width = a2width(p, bl->args->argv[col].value[i]) + dcol; | |||
break; | |||
default: | |||
if (NULL == bl->data.Bl.width) | |||
break; | break; | ||
/* | /* | ||
* Work around groff's column handling. The offset is | * Note: buffer the width by 2, which is groff's magic | ||
* equal to the sum of all widths leading to the current | * number for buffering single arguments. See the above | ||
* column (plus the -offset value). If this column | * handling for column for how this changes. | ||
* exceeds the stated number of columns, the width is | |||
* set as 0, else it's the stated column width (later | |||
* the 0 will be adjusted to default 10 or, if in the | |||
* last column case, set to stretch to the margin). | |||
*/ | */ | ||
for (i = 0, n = node->prev; n && | assert(bl->data.Bl.width); | ||
i < (int)bl->args[vals[2]].argv->sz; | width = a2width(p, bl->data.Bl.width) + term_len(p, 2); | ||
n = n->prev, i++) | |||
offset += arg_width | |||
(&bl->args->argv[vals[2]], i); | |||
/* Whether exceeds maximum column. */ | |||
if (i < (int)bl->args[vals[2]].argv->sz) | |||
width = arg_width(&bl->args->argv[vals[2]], i); | |||
else | |||
width = 0; | |||
if (vals[1] >= 0) | |||
offset += arg_offset(&bl->args->argv[vals[1]]); | |||
break; | break; | ||
default: | |||
if (vals[0] >= 0) | |||
width = arg_width(&bl->args->argv[vals[0]], 0); | |||
if (vals[1] >= 0) | |||
offset += arg_offset(&bl->args->argv[vals[1]]); | |||
break; | |||
} | } | ||
/* | /* | ||
|
|
||
*/ | */ | ||
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 < term_len(p, 4)) | ||
width = 4; | width = term_len(p, 4); | ||
break; | break; | ||
case (MDOC_Enum): | case (LIST_enum): | ||
if (width < 5) | if (width < term_len(p, 5)) | ||
width = 5; | width = term_len(p, 5); | ||
break; | break; | ||
case (MDOC_Hang): | case (LIST_hang): | ||
if (0 == width) | if (0 == width) | ||
width = 8; | width = term_len(p, 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 = term_len(p, 10); | ||
break; | break; | ||
default: | default: | ||
break; | break; | ||
|
|
||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
switch (type) { | switch (type) { | ||
case (MDOC_Diag): | case (LIST_diag): | ||
if (MDOC_BODY == node->type) | if (MDOC_BODY == n->type) | ||
term_word(p, "\\ \\ "); | term_word(p, "\\ \\ "); | ||
break; | break; | ||
case (MDOC_Inset): | case (LIST_inset): | ||
if (MDOC_BODY == node->type) | if (MDOC_BODY == n->type) | ||
term_word(p, "\\ "); | term_word(p, "\\ "); | ||
break; | break; | ||
default: | default: | ||
|
|
||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
switch (type) { | switch (type) { | ||
case (MDOC_Diag): | case (LIST_diag): | ||
if (MDOC_HEAD == node->type) | if (MDOC_HEAD == n->type) | ||
p->bold++; | 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; | break; | ||
/* | /* | ||
|
|
||
* the "overstep" effect in term_flushln() and treat | * the "overstep" effect in term_flushln() and treat | ||
* this as a `-ohang' list instead. | * this as a `-ohang' list instead. | ||
*/ | */ | ||
if (node->next->child && | if (n->next->child && | ||
(MDOC_Bl == node->next->child->tok || | (MDOC_Bl == n->next->child->tok || | ||
MDOC_Bd == node->next->child->tok)) { | MDOC_Bd == n->next->child->tok)) { | ||
p->flags &= ~TERMP_NOBREAK; | p->flags &= ~TERMP_NOBREAK; | ||
p->flags &= ~TERMP_NOLPAD; | p->flags &= ~TERMP_NOLPAD; | ||
} else | } 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 | TERMP_TWOSPACE; | 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_Hang): | case (LIST_hang): | ||
/* | /* | ||
* Same stipulation as above, regarding `-hang'. We | * Same stipulation as above, regarding `-hang'. We | ||
* don't want to recalculate rmargin and offsets when | * don't want to recalculate rmargin and offsets when | ||
* using `Bd' or `Bl' within `-hang' overstep lists. | * using `Bd' or `Bl' within `-hang' overstep lists. | ||
*/ | */ | ||
if (MDOC_HEAD == node->type && node->next->child && | if (MDOC_HEAD == n->type && n->next->child && | ||
(MDOC_Bl == node->next->child->tok || | (MDOC_Bl == n->next->child->tok || | ||
MDOC_Bd == node->next->child->tok)) | MDOC_Bd == n->next->child->tok)) | ||
break; | break; | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
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): | ||
/* 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->bold++; | term_fontpush(p, TERMFONT_BOLD); | ||
term_word(p, "\\[bu]"); | term_word(p, "\\[bu]"); | ||
p->bold--; | term_fontpop(p); | ||
break; | break; | ||
case (MDOC_Dash): | case (LIST_dash): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Hyphen): | case (LIST_hyphen): | ||
p->bold++; | term_fontpush(p, TERMFONT_BOLD); | ||
term_word(p, "\\(hy"); | term_word(p, "\\(hy"); | ||
p->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.Bl.type; | ||
assert(-1 != type); | |||
switch (type) { | switch (type) { | ||
case (MDOC_Item): | case (LIST_item): | ||
/* FALLTHROUGH */ | /* FALLTHROUGH */ | ||
case (MDOC_Diag): | 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 (MDOC_BLOCK == n->type) | ||
term_newln(p); | return(1); | ||
p->bold++; | |||
if (NULL == node->child) | if (MDOC_BODY == n->type) { | ||
term_word(p, meta->name); | if (NULL == n->child) | ||
return(0); | |||
p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; | |||
p->offset += term_len(p, 1) + | |||
(NULL == n->prev->child ? term_strlen(p, m->name) : | |||
MDOC_TEXT == n->prev->child->type ? | |||
term_strlen(p, n->prev->child->string) : | |||
term_len(p, 5)); | |||
return(1); | |||
} | |||
if (NULL == n->child && NULL == m->name) | |||
return(0); | |||
synopsis_pre(p, n); | |||
if (MDOC_HEAD == n->type && n->next->child) { | |||
p->flags |= TERMP_NOSPACE | TERMP_NOBREAK | TERMP_HANG; | |||
p->rmargin = p->offset + term_len(p, 1) + | |||
(NULL == n->child ? term_strlen(p, m->name) : | |||
MDOC_TEXT == n->child->type ? | |||
term_strlen(p, n->child->string) : | |||
term_len(p, 5)); | |||
} | |||
term_fontpush(p, TERMFONT_BOLD); | |||
if (NULL == n->child) | |||
term_word(p, m->name); | |||
return(1); | return(1); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static void | |||
termp_nm_post(DECL_ARGS) | |||
{ | |||
if (MDOC_HEAD == n->type && n->next->child) { | |||
term_flushln(p); | |||
p->flags &= ~(TERMP_NOBREAK | TERMP_HANG); | |||
} else if (MDOC_BODY == n->type && n->child) { | |||
term_flushln(p); | |||
p->flags &= ~TERMP_NOLPAD; | |||
} | |||
} | |||
/* ARGSUSED */ | |||
static int | static int | ||
termp_fl_pre(DECL_ARGS) | termp_fl_pre(DECL_ARGS) | ||
{ | { | ||
p->bold++; | term_fontpush(p, TERMFONT_BOLD); | ||
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); | ||
} | } | ||
|
|
||
termp_an_pre(DECL_ARGS) | termp_an_pre(DECL_ARGS) | ||
{ | { | ||
if (NULL == node->child) | if (NULL == n->child) | ||
return(1); | return(1); | ||
/* | /* | ||
* XXX: this is poorly documented. If not in the AUTHORS | * If not in the AUTHORS section, `An -split' will cause | ||
* section, `An -split' will cause newlines to occur before the | * newlines to occur before the author name. If in the AUTHORS | ||
* author name. If in the AUTHORS section, by default, the | * section, by default, the first `An' invocation is nosplit, | ||
* first `An' invocation is nosplit, then all subsequent ones, | * then all subsequent ones, regardless of whether interspersed | ||
* regardless of whether interspersed with other macros/text, | * with other macros/text, are split. -split, in this case, | ||
* are split. -split, in this case, will override the condition | * will override the condition of the implied first -nosplit. | ||
* of the implied first -nosplit. | |||
*/ | */ | ||
if (node->sec == SEC_AUTHORS) { | if (n->sec == SEC_AUTHORS) { | ||
if ( ! (TERMP_ANPREC & p->flags)) { | if ( ! (TERMP_ANPREC & p->flags)) { | ||
if (TERMP_SPLIT & p->flags) | if (TERMP_SPLIT & p->flags) | ||
term_newln(p); | term_newln(p); | ||
|
|
||
termp_an_post(DECL_ARGS) | termp_an_post(DECL_ARGS) | ||
{ | { | ||
if (node->child) { | if (n->child) { | ||
if (SEC_AUTHORS == node->sec) | if (SEC_AUTHORS == n->sec) | ||
p->flags |= TERMP_ANPREC; | p->flags |= TERMP_ANPREC; | ||
return; | return; | ||
} | } | ||
if (arg_getattr(MDOC_Split, node) > -1) { | if (arg_hasattr(MDOC_Split, n)) { | ||
p->flags &= ~TERMP_NOSPLIT; | p->flags &= ~TERMP_NOSPLIT; | ||
p->flags |= TERMP_SPLIT; | p->flags |= TERMP_SPLIT; | ||
} else { | } else { | ||
|
|
||
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); | ||
} | } | ||
|
|
||
term_newln(p); | term_newln(p); | ||
term_word(p, "The"); | term_word(p, "The"); | ||
nn = node->child; | for (nn = n->child; nn; nn = nn->next) { | ||
assert(nn); | term_fontpush(p, TERMFONT_BOLD); | ||
for ( ; nn; nn = nn->next) { | |||
p->bold++; | |||
term_word(p, nn->string); | term_word(p, nn->string); | ||
p->bold--; | term_fontpop(p); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
if (nn->next && NULL == nn->next->next) | if (nn->next && NULL == nn->next->next) | ||
term_word(p, "(), and"); | term_word(p, "(), and"); | ||
|
|
||
term_word(p, "()"); | term_word(p, "()"); | ||
} | } | ||
if (node->child->next) | if (n->child && n->child->next) | ||
term_word(p, "functions return"); | term_word(p, "functions return"); | ||
else | else | ||
term_word(p, "function returns"); | term_word(p, "function returns"); | ||
|
|
||
term_word(p, "the value 0 if successful; otherwise the value " | term_word(p, "the value 0 if successful; otherwise the value " | ||
"-1 is returned and the global variable"); | "-1 is returned and the global variable"); | ||
p->under++; | term_fontpush(p, TERMFONT_UNDER); | ||
term_word(p, "errno"); | term_word(p, "errno"); | ||
p->under--; | 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(0); | return(0); | ||
} | } | ||
|
|
||
term_word(p, "The"); | term_word(p, "The"); | ||
nn = node->child; | for (nn = n->child; nn; nn = nn->next) { | ||
assert(nn); | term_fontpush(p, TERMFONT_BOLD); | ||
for ( ; nn; nn = nn->next) { | |||
p->bold++; | |||
term_word(p, nn->string); | term_word(p, nn->string); | ||
p->bold--; | term_fontpop(p); | ||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
if (nn->next && NULL == nn->next->next) | if (nn->next && NULL == nn->next->next) | ||
term_word(p, ", and"); | term_word(p, ", and"); | ||
|
|
||
p->flags &= ~TERMP_NOSPACE; | p->flags &= ~TERMP_NOSPACE; | ||
} | } | ||
if (node->child->next) | if (n->child && n->child->next) | ||
term_word(p, "utilities exit"); | term_word(p, "utilities exit"); | ||
else | else | ||
term_word(p, "utility exits"); | term_word(p, "utility exits"); | ||
term_word(p, "0 on success, and >0 if an error occurs."); | term_word(p, "0 on success, and >0 if an error occurs."); | ||
p->flags |= TERMP_SENTENCE; | |||
return(0); | 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 */ | /* | ||
* 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 | static void | ||
termp_vt_post(DECL_ARGS) | synopsis_pre(struct termp *p, const struct mdoc_node *n) | ||
{ | { | ||
/* | |||
if (node->sec != SEC_SYNOPSIS) | * Obviously, if we're not in a SYNOPSIS or no prior macros | ||
* exist, do nothing. | |||
*/ | |||
if (NULL == n->prev || ! (MDOC_SYNPRETTY & n->flags)) | |||
return; | return; | ||
if (node->next && MDOC_Vt == node->next->tok) | |||
/* | |||
* 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); | term_newln(p); | ||
else if (node->next) | 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); | 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) { | |||
synopsis_pre(p, n); | |||
return(termp_under_pre(p, pair, m, n)); | |||
} 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 */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_bold_pre(DECL_ARGS) | termp_bold_pre(DECL_ARGS) | ||
{ | { | ||
p->bold++; | term_fontpush(p, TERMFONT_BOLD); | ||
return(1); | return(1); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static void | static int | ||
termp_fd_post(DECL_ARGS) | termp_fd_pre(DECL_ARGS) | ||
{ | { | ||
if (node->sec != SEC_SYNOPSIS) | synopsis_pre(p, n); | ||
return; | return(termp_bold_pre(p, pair, m, n)); | ||
term_newln(p); | |||
if (node->next && MDOC_Fd != node->next->tok) | |||
term_vspace(p); | |||
} | } | ||
|
|
||
static int | static int | ||
termp_sh_pre(DECL_ARGS) | termp_sh_pre(DECL_ARGS) | ||
{ | { | ||
/* | |||
* XXX: undocumented: using two `Sh' macros in sequence has no | /* No vspace between consecutive `Sh' calls. */ | ||
* vspace between calls, only a newline. | |||
*/ | switch (n->type) { | ||
switch (node->type) { | |||
case (MDOC_BLOCK): | case (MDOC_BLOCK): | ||
if (node->prev && MDOC_Sh == node->prev->tok) | if (n->prev && MDOC_Sh == n->prev->tok) | ||
if (NULL == node->prev->body->child) | if (NULL == n->prev->body->child) | ||
break; | break; | ||
term_vspace(p); | term_vspace(p); | ||
break; | break; | ||
case (MDOC_HEAD): | case (MDOC_HEAD): | ||
p->bold++; | term_fontpush(p, TERMFONT_BOLD); | ||
break; | break; | ||
case (MDOC_BODY): | case (MDOC_BODY): | ||
p->offset = INDENT; | p->offset = term_len(p, INDENT); | ||
break; | break; | ||
default: | default: | ||
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 += term_len(p, (INDENT + 1)); | ||
return(1); | return(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) | /* NB: MDOC_LINE does not effect this! */ | ||
if (node->prev && MDOC_Fo == node->prev->tok) | synopsis_pre(p, n); | ||
term_vspace(p); | term_fontpush(p, TERMFONT_UNDER); | ||
p->under++; | |||
return(1); | return(1); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static void | |||
termp_ft_post(DECL_ARGS) | |||
{ | |||
if (SEC_SYNOPSIS == node->sec) | |||
term_newln(p); | |||
} | |||
/* ARGSUSED */ | |||
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); | synopsis_pre(p, n); | ||
/* FIXME: can be "type funcname" "type varname"... */ | term_fontpush(p, TERMFONT_BOLD); | ||
term_word(p, n->child->string); | |||
term_fontpop(p); | |||
p->bold++; | |||
term_word(p, node->child->string); | |||
p->bold--; | |||
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->under++; | term_fontpush(p, TERMFONT_UNDER); | ||
term_word(p, n->string); | term_word(p, nn->string); | ||
p->under--; | 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 (MDOC_SYNPRETTY & n->flags) | ||
term_word(p, ";"); | term_word(p, ";"); | ||
return(0); | return(0); | ||
|
|
||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static void | |||
termp_fn_post(DECL_ARGS) | |||
{ | |||
if (node->sec == SEC_SYNOPSIS && node->next) | |||
term_vspace(p); | |||
} | |||
/* ARGSUSED */ | |||
static int | 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) { | ||
p->under++; | 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->under++; | term_fontpush(p, TERMFONT_UNDER); | ||
term_word(p, n->string); | term_word(p, nn->string); | ||
p->under--; | 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); | ||
|
|
||
static int | static int | ||
termp_bd_pre(DECL_ARGS) | termp_bd_pre(DECL_ARGS) | ||
{ | { | ||
int i, type; | size_t tabwidth; | ||
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) { | |||
fmt_block_vspace(p, node, node); | |||
return(1); | return(1); | ||
} else if (MDOC_BODY != node->type) | } else if (MDOC_HEAD == n->type) | ||
return(1); | return(0); | ||
assert(node->parent->args); | if (n->data.Bd.offs) | ||
p->offset += a2offs(p, n->data.Bd.offs); | |||
for (type = -1, i = 0; -1 == type && | /* | ||
i < (int)node->parent->args->argc; i++) { | * If -ragged or -filled are specified, the block does nothing | ||
switch (node->parent->args->argv[i].arg) { | * but change the indentation. If -unfilled or -literal are | ||
case (MDOC_Ragged): | * specified, text is printed exactly as entered in the display: | ||
/* FALLTHROUGH */ | * for macro lines, a newline is appended to the line. Blank | ||
case (MDOC_Filled): | * lines are allowed. | ||
/* FALLTHROUGH */ | */ | ||
case (MDOC_Unfilled): | |||
/* FALLTHROUGH */ | |||
case (MDOC_Literal): | |||
type = node->parent->args->argv[i].arg; | |||
break; | |||
default: | |||
break; | |||
} | |||
} | |||
assert(type > -1); | if (DISP_literal != n->data.Bd.type && | ||
DISP_unfilled != n->data.Bd.type) | |||
i = arg_getattr(MDOC_Offset, node->parent); | |||
if (-1 != i) | |||
p->offset += arg_offset(&node->parent->args->argv[i]); | |||
switch (type) { | |||
case (MDOC_Literal): | |||
/* FALLTHROUGH */ | |||
case (MDOC_Unfilled): | |||
break; | |||
default: | |||
return(1); | return(1); | ||
} | |||
for (node = node->child; node; node = node->next) { | tabwidth = p->tabwidth; | ||
p->tabwidth = term_len(p, 8); | |||
rm = p->rmargin; | |||
rmax = p->maxrmargin; | |||
p->rmargin = p->maxrmargin = TERM_MAXMARGIN; | |||
for (nn = n->child; nn; nn = nn->next) { | |||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
print_node(p, pair, meta, node); | print_mdoc_node(p, pair, m, nn); | ||
if (node->next) | if (NULL == nn->prev || | ||
nn->prev->line < nn->line || | |||
NULL == nn->next) | |||
term_flushln(p); | term_flushln(p); | ||
} | } | ||
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) | ||
{ | { | ||
size_t rm, rmax; | |||
if (MDOC_BODY != node->type) | if (MDOC_BODY != n->type) | ||
return; | return; | ||
rm = p->rmargin; | |||
rmax = p->maxrmargin; | |||
if (DISP_literal == n->data.Bd.type || | |||
DISP_unfilled == n->data.Bd.type) | |||
p->rmargin = p->maxrmargin = TERM_MAXMARGIN; | |||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_flushln(p); | 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): | ||
p->bold++; | term_fontpush(p, TERMFONT_BOLD); | ||
p->offset = HALFINDENT; | p->offset = term_len(p, HALFINDENT); | ||
break; | break; | ||
default: | default: | ||
break; | break; | ||
|
|
||
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); | ||
} | } | ||
|
|
||
termp_cd_pre(DECL_ARGS) | termp_cd_pre(DECL_ARGS) | ||
{ | { | ||
p->bold++; | synopsis_pre(p, n); | ||
term_newln(p); | term_fontpush(p, TERMFONT_BOLD); | ||
return(1); | return(1); | ||
} | } | ||
|
|
||
termp_in_pre(DECL_ARGS) | termp_in_pre(DECL_ARGS) | ||
{ | { | ||
p->bold++; | synopsis_pre(p, n); | ||
if (SEC_SYNOPSIS == node->sec) | |||
if (MDOC_SYNPRETTY & n->flags && MDOC_LINE & n->flags) { | |||
term_fontpush(p, TERMFONT_BOLD); | |||
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->bold++; | if (MDOC_SYNPRETTY & n->flags) | ||
term_fontpush(p, TERMFONT_BOLD); | |||
p->flags |= TERMP_NOSPACE; | |||
term_word(p, ">"); | term_word(p, ">"); | ||
p->bold--; | |||
if (SEC_SYNOPSIS != node->sec) | if (MDOC_SYNPRETTY & n->flags) | ||
return; | term_fontpop(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; | ||
switch (node->tok) { | switch (n->tok) { | ||
case (MDOC_sp): | case (MDOC_sp): | ||
len = node->child ? atoi(node->child->string) : 1; | len = n->child ? a2height(p, n->child->string) : 1; | ||
break; | break; | ||
case (MDOC_br): | case (MDOC_br): | ||
len = 0; | len = 0; | ||
|
|
||
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; | |||
if (MDOC_BODY == node->type) { | if (MDOC_BLOCK == n->type) { | ||
synopsis_pre(p, n); | |||
return(1); | |||
} else 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) | } | ||
return(1); | |||
p->bold++; | /* XXX: we drop non-initial arguments as per groff. */ | ||
for (n = node->child; n; n = n->next) { | |||
assert(MDOC_TEXT == n->type); | |||
term_word(p, n->string); | |||
} | |||
p->bold--; | |||
assert(n->child); | |||
assert(n->child->string); | |||
term_fontpush(p, TERMFONT_BOLD); | |||
term_word(p, n->child->string); | |||
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, ")"); | ||
p->flags |= TERMP_NOSPACE; | |||
term_word(p, ";"); | if (MDOC_SYNPRETTY & n->flags) { | ||
term_newln(p); | p->flags |= TERMP_NOSPACE; | ||
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)) | ||
p->under++; | term_fontpush(p, TERMFONT_UNDER); | ||
else if (arg_hasattr(MDOC_Symbolic, node)) | else if (arg_hasattr(MDOC_Symbolic, n)) | ||
p->bold++; | 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)) | ||
p->under++; | term_fontpush(p, TERMFONT_UNDER); | ||
else if (0 == strcmp("Sy", n->string)) | else if (0 == strcmp("Sy", nn->string)) | ||
p->bold++; | term_fontpush(p, TERMFONT_BOLD); | ||
else | |||
term_fontpush(p, TERMFONT_NONE); | |||
return(1); | return(1); | ||
} | } | ||
|
|
||
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); | ||
|
|
||
termp____post(DECL_ARGS) | termp____post(DECL_ARGS) | ||
{ | { | ||
/* TODO: %U. */ | |||
p->flags |= TERMP_NOSPACE; | p->flags |= TERMP_NOSPACE; | ||
term_word(p, node->next ? "," : "."); | term_word(p, n->next ? "," : "."); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_li_pre(DECL_ARGS) | |||
{ | |||
term_fontpush(p, TERMFONT_NONE); | |||
return(1); | |||
} | |||
/* ARGSUSED */ | |||
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) | ||
p->under++; | |||
return(1); | return(1); | ||
} | |||
p->under++; | 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->under--; | |||
p->bold++; | 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); | ||
p->bold--; | term_fontpop(p); | ||
return(0); | return(0); | ||
} | } | ||
|
|
||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static int | static int | ||
termp_bk_pre(DECL_ARGS) | |||
{ | |||
switch (n->type) { | |||
case (MDOC_BLOCK): | |||
return(1); | |||
case (MDOC_HEAD): | |||
return(0); | |||
case (MDOC_BODY): | |||
p->flags |= TERMP_PREKEEP; | |||
return(1); | |||
default: | |||
abort(); | |||
} | |||
} | |||
/* ARGSUSED */ | |||
static void | |||
termp_bk_post(DECL_ARGS) | |||
{ | |||
if (MDOC_BODY == n->type) | |||
p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP); | |||
} | |||
/* ARGSUSED */ | |||
static int | |||
termp_under_pre(DECL_ARGS) | termp_under_pre(DECL_ARGS) | ||
{ | { | ||
p->under++; | term_fontpush(p, TERMFONT_UNDER); | ||
return(1); | return(1); | ||
} | } |