mandoc/mdoc_term.c - diff

Return to mdoc_term.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mdoc_term.c between version 1.363 and 1.379

version 1.363, 2017/06/08 12:54:58

version 1.379, 2020/03/13 15:32:28

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

Line 15

* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

* Plain text formatter for mdoc(7), used by mandoc(1)

* for ASCII, UTF-8, PostScript, and PDF output.

#include "config.h"

Line 29

Line 32

#include <string.h>

#include "mandoc_aux.h"

#include "mandoc.h"

#include "roff.h"

#include "mdoc.h"

#include "out.h"

#include "term.h"

#include "tag.h"

#include "term_tag.h"

#include "main.h"

struct termpair {

Line 47 struct termpair {

Line 49 struct termpair {

const struct roff_meta *meta, \

struct roff_node *n

struct termact {

struct mdoc_term_act {

int (*pre)(DECL_ARGS);

void (*post)(DECL_ARGS);

};

Line 55 struct termact {

Line 57 struct termact {

static int a2width(const struct termp *, const char *);

static void print_bvspace(struct termp *,

const struct roff_node *,

struct roff_node *, struct roff_node *);

const struct roff_node *);

static void print_mdoc_node(DECL_ARGS);

static void print_mdoc_nodelist(DECL_ARGS);

static void print_mdoc_head(struct termp *, const struct roff_meta *);

static void print_mdoc_foot(struct termp *, const struct roff_meta *);

static void synopsis_pre(struct termp *,

static void synopsis_pre(struct termp *, struct roff_node *);

const struct roff_node *);

static void termp____post(DECL_ARGS);

static void termp__t_post(DECL_ARGS);

Line 84 static void termp_xx_post(DECL_ARGS);

static int termp__a_pre(DECL_ARGS);

static int termp__t_pre(DECL_ARGS);

static int termp_abort_pre(DECL_ARGS);

static int termp_an_pre(DECL_ARGS);

static int termp_ap_pre(DECL_ARGS);

static int termp_bd_pre(DECL_ARGS);

Line 91 static int termp_bf_pre(DECL_ARGS);

Line 92 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_cd_pre(DECL_ARGS);

static int termp_d1_pre(DECL_ARGS);

static int termp_eo_pre(DECL_ARGS);

static int termp_em_pre(DECL_ARGS);

static int termp_er_pre(DECL_ARGS);

static int termp_ex_pre(DECL_ARGS);

static int termp_fa_pre(DECL_ARGS);

static int termp_fd_pre(DECL_ARGS);

Line 117 static int termp_skip_pre(DECL_ARGS);

Line 115 static int termp_skip_pre(DECL_ARGS);

static int termp_sm_pre(DECL_ARGS);

static int termp_pp_pre(DECL_ARGS);

static int termp_ss_pre(DECL_ARGS);

static int termp_sy_pre(DECL_ARGS);

static int termp_tag_pre(DECL_ARGS);

static int termp_under_pre(DECL_ARGS);

static int termp_vt_pre(DECL_ARGS);

static int termp_xr_pre(DECL_ARGS);

static int termp_xx_pre(DECL_ARGS);

static const struct termact __termacts[MDOC_MAX - MDOC_Dd] = {

static const struct mdoc_term_act mdoc_term_acts[MDOC_MAX - MDOC_Dd] = {

{ NULL, NULL }, /* Dd */

{ NULL, NULL }, /* Dt */

{ NULL, NULL }, /* Os */

Line 142 static const struct termact __termacts[MDOC_MAX - MDOC

Line 138 static const struct termact __termacts[MDOC_MAX - MDOC

{ termp_an_pre, NULL }, /* An */

{ termp_ap_pre, NULL }, /* Ap */

{ termp_under_pre, NULL }, /* Ar */

{ termp_cd_pre, NULL }, /* Cd */

{ termp_fd_pre, NULL }, /* Cd */

{ termp_bold_pre, NULL }, /* Cm */

{ termp_li_pre, NULL }, /* Dv */

{ termp_er_pre, NULL }, /* Er */

{ NULL, NULL }, /* Er */

{ termp_tag_pre, NULL }, /* Ev */

{ NULL, NULL }, /* Ev */

{ termp_ex_pre, NULL }, /* Ex */

{ termp_fa_pre, NULL }, /* Fa */

{ termp_fd_pre, termp_fd_post }, /* Fd */

Line 159 static const struct termact __termacts[MDOC_MAX - MDOC

Line 155 static const struct termact __termacts[MDOC_MAX - MDOC

{ termp_nd_pre, NULL }, /* Nd */

{ termp_nm_pre, termp_nm_post }, /* Nm */

{ termp_quote_pre, termp_quote_post }, /* Op */

{ termp_ft_pre, NULL }, /* Ot */

{ termp_abort_pre, NULL }, /* Ot */

{ termp_under_pre, NULL }, /* Pa */

{ termp_ex_pre, NULL }, /* Rv */

{ NULL, NULL }, /* St */

Line 193 static const struct termact __termacts[MDOC_MAX - MDOC

Line 189 static const struct termact __termacts[MDOC_MAX - MDOC

{ termp_quote_pre, termp_quote_post }, /* Dq */

{ NULL, NULL }, /* Ec */ /* FIXME: no space */

{ NULL, NULL }, /* Ef */

{ termp_em_pre, NULL }, /* Em */

{ termp_under_pre, NULL }, /* Em */

{ termp_eo_pre, termp_eo_post }, /* Eo */

{ termp_xx_pre, termp_xx_post }, /* Fx */

{ termp_bold_pre, NULL }, /* Ms */

Line 216 static const struct termact __termacts[MDOC_MAX - MDOC

Line 212 static const struct termact __termacts[MDOC_MAX - MDOC

{ termp_quote_pre, termp_quote_post }, /* Sq */

{ termp_sm_pre, NULL }, /* Sm */

{ termp_under_pre, NULL }, /* Sx */

{ termp_sy_pre, NULL }, /* Sy */

{ termp_bold_pre, NULL }, /* Sy */

{ NULL, NULL }, /* Tn */

{ termp_xx_pre, termp_xx_post }, /* Ux */

{ NULL, NULL }, /* Xc */

Line 232 static const struct termact __termacts[MDOC_MAX - MDOC

Line 228 static const struct termact __termacts[MDOC_MAX - MDOC

{ termp_under_pre, NULL }, /* Fr */

{ NULL, NULL }, /* Ud */

{ NULL, termp_lb_post }, /* Lb */

{ termp_pp_pre, NULL }, /* Lp */

{ termp_abort_pre, NULL }, /* Lp */

{ termp_lk_pre, NULL }, /* Lk */

{ termp_under_pre, NULL }, /* Mt */

{ termp_quote_pre, termp_quote_post }, /* Brq */

Line 245 static const struct termact __termacts[MDOC_MAX - MDOC

Line 241 static const struct termact __termacts[MDOC_MAX - MDOC

{ NULL, termp____post }, /* %Q */

{ NULL, termp____post }, /* %U */

{ NULL, NULL }, /* Ta */

{ termp_skip_pre, NULL }, /* Tg */

};

static const struct termact *const termacts = __termacts - MDOC_Dd;

static int fn_prio;

void

terminal_mdoc(void *arg, const struct roff_man *mdoc)

terminal_mdoc(void *arg, const struct roff_meta *mdoc)

{

struct roff_node *n;

struct roff_node *n, *nn;

struct termp *p;

size_t save_defindent;

Line 266 terminal_mdoc(void *arg, const struct roff_man *mdoc)

Line 260 terminal_mdoc(void *arg, const struct roff_man *mdoc)

n = mdoc->first->child;

if (p->synopsisonly) {

while (n != NULL) {

for (nn = NULL; n != NULL; n = n->next) {

if (n->tok == MDOC_Sh && n->sec == SEC_SYNOPSIS) {

if (n->tok != MDOC_Sh)

if (n->child->next->child != NULL)

continue;

print_mdoc_nodelist(p, NULL,

if (n->sec == SEC_SYNOPSIS)

&mdoc->meta,

n->child->next->child);

term_newln(p);

break;

}

if (nn == NULL && n->sec == SEC_NAME)

n = n->next;

nn = n;

}

if (n == NULL)

n = nn;

p->flags |= TERMP_NOSPACE;

if (n != NULL && (n = n->child->next->child) != NULL)

print_mdoc_nodelist(p, NULL, mdoc, n);

term_newln(p);

} else {

save_defindent = p->defindent;

if (p->defindent == 0)

p->defindent = 5;

term_begin(p, print_mdoc_head, print_mdoc_foot,

term_begin(p, print_mdoc_head, print_mdoc_foot, mdoc);

&mdoc->meta);

while (n != NULL &&

while (n != NULL && n->flags & NODE_NOPRT)

(n->type == ROFFT_COMMENT ||

n->flags & NODE_NOPRT))

n = n->next;

if (n != NULL) {

if (n->tok != MDOC_Sh)

term_vspace(p);

print_mdoc_nodelist(p, NULL, &mdoc->meta, n);

print_mdoc_nodelist(p, NULL, mdoc, n);

}

term_end(p);

p->defindent = save_defindent;

Line 298 terminal_mdoc(void *arg, const struct roff_man *mdoc)

Line 296 terminal_mdoc(void *arg, const struct roff_man *mdoc)

static void

print_mdoc_nodelist(DECL_ARGS)

{

while (n != NULL) {

print_mdoc_node(p, pair, meta, n);

n = n->next;

Line 308 print_mdoc_nodelist(DECL_ARGS)

Line 305 print_mdoc_nodelist(DECL_ARGS)

static void

print_mdoc_node(DECL_ARGS)

{

int chld;

const struct mdoc_term_act *act;

struct termpair npair;

size_t offset, rmargin;

int chld;

if (n->flags & NODE_NOPRT)

* In no-fill mode, break the output line at the beginning

* of new input lines except after \c, and nowhere else.

if (n->flags & NODE_NOFILL) {

if (n->flags & NODE_LINE &&

(p->flags & TERMP_NONEWLINE) == 0)

term_newln(p);

p->flags |= TERMP_BRNEVER;

} else

p->flags &= ~TERMP_BRNEVER;

if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)

return;

chld = 1;

Line 324 print_mdoc_node(DECL_ARGS)

Line 335 print_mdoc_node(DECL_ARGS)

memset(&npair, 0, sizeof(struct termpair));

npair.ppair = pair;

if (n->flags & NODE_ID)

term_tag_write(n, p->line);

* Keeps only work until the end of a line. If a keep was

* invoked in a prior line, revert it to PREKEEP.

Line 339 print_mdoc_node(DECL_ARGS)

Line 353 print_mdoc_node(DECL_ARGS)

* produce output. Note that some pre-handlers do so.

act = NULL;

switch (n->type) {

case ROFFT_TEXT:

if (*n->string == ' ' && n->flags & NODE_LINE &&

if (n->flags & NODE_LINE) {

(p->flags & TERMP_NONEWLINE) == 0)

switch (*n->string) {

term_newln(p);

case '\0':

if (p->flags & TERMP_NONEWLINE)

term_newln(p);

else

term_vspace(p);

return;

case ' ':

if ((p->flags & TERMP_NONEWLINE) == 0)

term_newln(p);

break;

default:

break;

}

if (NODE_DELIMC & n->flags)

p->flags |= TERMP_NOSPACE;

term_word(p, n->string);

Line 368 print_mdoc_node(DECL_ARGS)

Line 396 print_mdoc_node(DECL_ARGS)

return;

}

assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);

if (termacts[n->tok].pre != NULL &&

act = mdoc_term_acts + (n->tok - MDOC_Dd);

if (act->pre != NULL &&

(n->end == ENDBODY_NOT || n->child != NULL))

chld = (*termacts[n->tok].pre)

chld = (*act->pre)(p, &npair, meta, n);

(p, &npair, meta, n);

break;

}

Line 389 print_mdoc_node(DECL_ARGS)

Line 417 print_mdoc_node(DECL_ARGS)

case ROFFT_EQN:

break;

default:

if (termacts[n->tok].post == NULL || n->flags & NODE_ENDED)

if (act->post == NULL || n->flags & NODE_ENDED)

break;

(void)(*termacts[n->tok].post)(p, &npair, meta, n);

(void)(*act->post)(p, &npair, meta, n);

* Explicit end tokens not only call the post

Line 540 a2width(const struct termp *p, const char *v)

Line 568 a2width(const struct termp *p, const char *v)

SCALE_HS_INIT(&su, term_strlen(p, v));

su.scale /= term_strlen(p, "0");

}

return term_hspan(p, &su) / 24;

return term_hen(p, &su);

}

Line 549 a2width(const struct termp *p, const char *v)

Line 577 a2width(const struct termp *p, const char *v)

* too.

static void

print_bvspace(struct termp *p,

print_bvspace(struct termp *p, struct roff_node *bl, struct roff_node *n)

const struct roff_node *bl,

const struct roff_node *n)

{

const struct roff_node *nn;

struct roff_node *nn;

assert(n);

term_newln(p);

if (MDOC_Bd == bl->tok && bl->norm->Bd.comp)

if ((bl->tok == MDOC_Bd && bl->norm->Bd.comp) ||

(bl->tok == MDOC_Bl && bl->norm->Bl.comp))

return;

if (MDOC_Bl == bl->tok && bl->norm->Bl.comp)

return;

/* Do not vspace directly after Ss/Sh. */

nn = n;

while (nn->prev != NULL && nn->prev->flags & NODE_NOPRT)

while (roff_node_prev(nn) == NULL) {

nn = nn->prev;

while (nn->prev == NULL) {

do {

nn = nn->parent;

if (nn->type == ROFFT_ROOT)

Line 582 print_bvspace(struct termp *p,

Line 603 print_bvspace(struct termp *p,

break;

}

/* A `-column' does not assert vspace within the list. */

* No vertical space after:

* items in .Bl -column

* items without a body in .Bl -diag

if (MDOC_Bl == bl->tok && LIST_column == bl->norm->Bl.type)

if (bl->tok != MDOC_Bl ||

if (n->prev && MDOC_It == n->prev->tok)

n->prev == NULL || n->prev->tok != MDOC_It ||

return;

(bl->norm->Bl.type != LIST_column &&

(bl->norm->Bl.type != LIST_diag ||

/* A `-diag' without body does not vspace. */

n->prev->body->child != NULL)))

term_vspace(p);

if (MDOC_Bl == bl->tok && LIST_diag == bl->norm->Bl.type)

if (n->prev && MDOC_It == n->prev->tok) {

assert(n->prev->body);

if (NULL == n->prev->body->child)

return;

}

term_vspace(p);

}

Line 686 termp_it_pre(DECL_ARGS)

Line 703 termp_it_pre(DECL_ARGS)

SCALE_HS_INIT(&su,

term_strlen(p, bl->norm->Bl.cols[i]));

su.scale /= term_strlen(p, "0");

offset += term_hspan(p, &su) / 24 + dcol;

offset += term_hen(p, &su) + dcol;

}

Line 704 termp_it_pre(DECL_ARGS)

Line 721 termp_it_pre(DECL_ARGS)

SCALE_HS_INIT(&su, term_strlen(p, bl->norm->Bl.cols[i]));

su.scale /= term_strlen(p, "0");

width = term_hspan(p, &su) / 24 + dcol;

width = term_hen(p, &su) + dcol;

break;

default:

if (NULL == bl->norm->Bl.width)

Line 985 termp_nm_pre(DECL_ARGS)

Line 1002 termp_nm_pre(DECL_ARGS)

p->flags |= TERMP_HANG;

}

return termp_bold_pre(p, pair, meta, n);

term_fontpush(p, TERMFONT_BOLD);

return 1;

}

static void

termp_nm_post(DECL_ARGS)

{

switch (n->type) {

if (n->type == ROFFT_BLOCK) {

case ROFFT_BLOCK:

p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);

} else if (n->type == ROFFT_HEAD &&

break;

NULL != n->next && NULL != n->next->child) {

case ROFFT_HEAD:

if (n->next == NULL || n->next->child == NULL)

break;

term_flushln(p);

p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG);

p->trailspace = 0;

} else if (n->type == ROFFT_BODY && n->child != NULL)

break;

term_flushln(p);

case ROFFT_BODY:

if (n->child != NULL)

term_flushln(p);

break;

default:

break;

}

static int

termp_fl_pre(DECL_ARGS)

{

struct roff_node *nn;

termp_tag_pre(p, pair, meta, n);

term_fontpush(p, TERMFONT_BOLD);

term_word(p, "\\-");

if (!(n->child == NULL &&

if (n->child != NULL ||

(n->next == NULL ||

((nn = roff_node_next(n)) != NULL &&

n->next->type == ROFFT_TEXT ||

nn->type != ROFFT_TEXT &&

n->next->flags & NODE_LINE)))

(nn->flags & NODE_LINE) == 0))

p->flags |= TERMP_NOSPACE;

return 1;

Line 1025 termp_fl_pre(DECL_ARGS)

Line 1048 termp_fl_pre(DECL_ARGS)

static int

termp__a_pre(DECL_ARGS)

{

struct roff_node *nn;

if (n->prev && MDOC__A == n->prev->tok)

if ((nn = roff_node_prev(n)) != NULL && nn->tok == MDOC__A &&

if (NULL == n->next || MDOC__A != n->next->tok)

((nn = roff_node_next(n)) == NULL || nn->tok != MDOC__A))

term_word(p, "and");

return 1;

}

Line 1069 termp_ns_pre(DECL_ARGS)

Line 1093 termp_ns_pre(DECL_ARGS)

static int

termp_rs_pre(DECL_ARGS)

{

if (SEC_SEE_ALSO != n->sec)

return 1;

if (n->type == ROFFT_BLOCK && n->prev != NULL)

if (n->type == ROFFT_BLOCK && roff_node_prev(n) != NULL)

term_vspace(p);

return 1;

}

Line 1146 termp_xr_pre(DECL_ARGS)

Line 1169 termp_xr_pre(DECL_ARGS)

* macro combos).

static void

synopsis_pre(struct termp *p, const struct roff_node *n)

synopsis_pre(struct termp *p, struct roff_node *n)

{

struct roff_node *np;

* Obviously, if we're not in a SYNOPSIS or no prior macros

* exist, do nothing.

if ((n->flags & NODE_SYNPRETTY) == 0 ||

(np = roff_node_prev(n)) == NULL)

if (NULL == n->prev || ! (NODE_SYNPRETTY & n->flags))

return;

Line 1160 synopsis_pre(struct termp *p, const struct roff_node *

Line 1182 synopsis_pre(struct termp *p, const struct roff_node *

* newline and return. UNLESS we're `Fo', `Fn', `Fn', in which

* case we soldier on.

if (n->prev->tok == n->tok &&

if (np->tok == n->tok &&

MDOC_Ft != n->tok &&

MDOC_Fo != n->tok &&

MDOC_Fn != n->tok) {

Line 1173 synopsis_pre(struct termp *p, const struct roff_node *

Line 1195 synopsis_pre(struct termp *p, const struct roff_node *

* another (or Fn/Fo, which we've let slip through) then assert

* vertical space, else only newline and move on.

switch (n->prev->tok) {

switch (np->tok) {

case MDOC_Fd:

case MDOC_Fn:

case MDOC_Fo:

Line 1182 synopsis_pre(struct termp *p, const struct roff_node *

Line 1204 synopsis_pre(struct termp *p, const struct roff_node *

term_vspace(p);

break;

case MDOC_Ft:

if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {

if (n->tok != MDOC_Fn && n->tok != MDOC_Fo) {

term_vspace(p);

break;

}

Line 1196 synopsis_pre(struct termp *p, const struct roff_node *

Line 1218 synopsis_pre(struct termp *p, const struct roff_node *

static int

termp_vt_pre(DECL_ARGS)

{

switch (n->type) {

if (n->type == ROFFT_ELEM) {

case ROFFT_ELEM:

return termp_ft_pre(p, pair, meta, n);

case ROFFT_BLOCK:

synopsis_pre(p, n);

return termp_under_pre(p, pair, meta, n);

} else if (n->type == ROFFT_BLOCK) {

synopsis_pre(p, n);

return 1;

} else if (n->type == ROFFT_HEAD)

case ROFFT_HEAD:

return 0;

default:

return termp_under_pre(p, pair, meta, n);

}

static int

termp_bold_pre(DECL_ARGS)

{

termp_tag_pre(p, pair, meta, n);

term_fontpush(p, TERMFONT_BOLD);

return 1;

}

Line 1221 termp_bold_pre(DECL_ARGS)

Line 1241 termp_bold_pre(DECL_ARGS)

static int

termp_fd_pre(DECL_ARGS)

{

synopsis_pre(p, n);

return termp_bold_pre(p, pair, meta, n);

}

Line 1229 termp_fd_pre(DECL_ARGS)

Line 1248 termp_fd_pre(DECL_ARGS)

static void

termp_fd_post(DECL_ARGS)

{

term_newln(p);

}

static int

termp_sh_pre(DECL_ARGS)

{

struct roff_node *np;

switch (n->type) {

case ROFFT_BLOCK:

Line 1243 termp_sh_pre(DECL_ARGS)

Line 1262 termp_sh_pre(DECL_ARGS)

* Vertical space before sections, except

* when the previous section was empty.

if (n->prev == NULL ||

if ((np = roff_node_prev(n)) == NULL ||

n->prev->tok != MDOC_Sh ||

np->tok != MDOC_Sh ||

(n->prev->body != NULL &&

(np->body != NULL && np->body->child != NULL))

n->prev->body->child != NULL))

term_vspace(p);

break;

case ROFFT_HEAD:

term_fontpush(p, TERMFONT_BOLD);

return termp_bold_pre(p, pair, meta, n);

break;

case ROFFT_BODY:

p->tcol->offset = term_len(p, p->defindent);

term_tab_set(p, NULL);

term_tab_set(p, "T");

term_tab_set(p, ".5i");

switch (n->sec) {

if (n->sec == SEC_AUTHORS)

case SEC_DESCRIPTION:

fn_prio = 0;

break;

case SEC_AUTHORS:

p->flags &= ~(TERMP_SPLIT|TERMP_NOSPLIT);

break;

default:

break;

}

break;

default:

break;

Line 1277 termp_sh_pre(DECL_ARGS)

Line 1286 termp_sh_pre(DECL_ARGS)

static void

termp_sh_post(DECL_ARGS)

{

switch (n->type) {

case ROFFT_HEAD:

term_newln(p);

Line 1294 termp_sh_post(DECL_ARGS)

Line 1302 termp_sh_post(DECL_ARGS)

static void

termp_lb_post(DECL_ARGS)

{

if (n->sec == SEC_LIBRARY && n->flags & NODE_LINE)

if (SEC_LIBRARY == n->sec && NODE_LINE & n->flags)

term_newln(p);

}

static int

termp_d1_pre(DECL_ARGS)

{

if (n->type != ROFFT_BLOCK)

return 1;

term_newln(p);

Line 1316 termp_d1_pre(DECL_ARGS)

Line 1322 termp_d1_pre(DECL_ARGS)

static int

termp_ft_pre(DECL_ARGS)

{

/* NB: NODE_LINE does not effect this! */

synopsis_pre(p, n);

term_fontpush(p, TERMFONT_UNDER);

return termp_under_pre(p, pair, meta, n);

return 1;

}

static int

Line 1329 termp_fn_pre(DECL_ARGS)

Line 1332 termp_fn_pre(DECL_ARGS)

size_t rmargin = 0;

int pretty;

pretty = NODE_SYNPRETTY & n->flags;

synopsis_pre(p, n);

pretty = n->flags & NODE_SYNPRETTY;

if (NULL == (n = n->child))

if ((n = n->child) == NULL)

return 0;

if (pretty) {

Line 1347 termp_fn_pre(DECL_ARGS)

Line 1348 termp_fn_pre(DECL_ARGS)

term_word(p, n->string);

term_fontpop(p);

if (n->sec == SEC_DESCRIPTION || n->sec == SEC_CUSTOM)

tag_put(n->string, ++fn_prio, p->line);

if (pretty) {

term_flushln(p);

p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG);

Line 1384 termp_fn_pre(DECL_ARGS)

Line 1382 termp_fn_pre(DECL_ARGS)

term_word(p, ";");

term_flushln(p);

}

return 0;

}

Line 1393 termp_fa_pre(DECL_ARGS)

Line 1390 termp_fa_pre(DECL_ARGS)

{

const struct roff_node *nn;

if (n->parent->tok != MDOC_Fo) {

if (n->parent->tok != MDOC_Fo)

term_fontpush(p, TERMFONT_UNDER);

return termp_under_pre(p, pair, meta, n);

return 1;

}

for (nn = n->child; nn; nn = nn->next) {

for (nn = n->child; nn != NULL; nn = nn->next) {

term_fontpush(p, TERMFONT_UNDER);

p->flags |= TERMP_NBRWORD;

term_word(p, nn->string);

term_fontpop(p);

if (nn->next != NULL) {

if (nn->next || (n->next && n->next->tok == MDOC_Fa)) {

p->flags |= TERMP_NOSPACE;

term_word(p, ",");

}

if (n->child != NULL &&

(nn = roff_node_next(n)) != NULL &&

nn->tok == MDOC_Fa) {

p->flags |= TERMP_NOSPACE;

term_word(p, ",");

}

return 0;

}

static int

termp_bd_pre(DECL_ARGS)

{

size_t lm, len;

struct roff_node *nn;

int offset;

if (n->type == ROFFT_BLOCK) {

Line 1443 termp_bd_pre(DECL_ARGS)

Line 1440 termp_bd_pre(DECL_ARGS)

p->tcol->offset += offset;

}

switch (n->norm->Bd.type) {

* If -ragged or -filled are specified, the block does nothing

case DISP_literal:

* but change the indentation. If -unfilled or -literal are

* specified, text is printed exactly as entered in the display:

* for macro lines, a newline is appended to the line. Blank

* lines are allowed.

if (n->norm->Bd.type != DISP_literal &&

n->norm->Bd.type != DISP_unfilled &&

n->norm->Bd.type != DISP_centered)

return 1;

if (n->norm->Bd.type == DISP_literal) {

term_tab_set(p, NULL);

term_tab_set(p, "T");

term_tab_set(p, "8n");

break;

case DISP_centered:

p->flags |= TERMP_CENTER;

break;

default:

break;

}

return 1;

lm = p->tcol->offset;

p->flags |= TERMP_BRNEVER;

for (nn = n->child; nn != NULL; nn = nn->next) {

if (n->norm->Bd.type == DISP_centered) {

if (nn->type == ROFFT_TEXT) {

len = term_strlen(p, nn->string);

p->tcol->offset = len >= p->tcol->rmargin ?

0 : lm + len >= p->tcol->rmargin ?

p->tcol->rmargin - len :

(lm + p->tcol->rmargin - len) / 2;

} else

p->tcol->offset = lm;

}

print_mdoc_node(p, pair, meta, nn);

* If the printed node flushes its own line, then we

* needn't do it here as well. This is hacky, but the

* notion of selective eoln whitespace is pretty dumb

* anyway, so don't sweat it.

if (nn->tok < ROFF_MAX)

continue;

switch (nn->tok) {

case MDOC_Sm:

case MDOC_Bl:

case MDOC_D1:

case MDOC_Dl:

case MDOC_Lp:

case MDOC_Pp:

continue;

default:

break;

}

if (p->flags & TERMP_NONEWLINE ||

(nn->next && ! (nn->next->flags & NODE_LINE)))

continue;

term_flushln(p);

p->flags |= TERMP_NOSPACE;

}

p->flags &= ~TERMP_BRNEVER;

return 0;

}

static void

Line 1510 termp_bd_post(DECL_ARGS)

Line 1460 termp_bd_post(DECL_ARGS)

{

if (n->type != ROFFT_BODY)

return;

if (DISP_literal == n->norm->Bd.type ||

if (n->norm->Bd.type == DISP_unfilled ||

DISP_unfilled == n->norm->Bd.type)

n->norm->Bd.type == DISP_literal)

p->flags |= TERMP_BRNEVER;

p->flags |= TERMP_NOSPACE;

term_newln(p);

p->flags &= ~TERMP_BRNEVER;

if (n->norm->Bd.type == DISP_centered)

p->flags &= ~TERMP_CENTER;

}

static int

Line 1536 termp_xx_post(DECL_ARGS)

Line 1488 termp_xx_post(DECL_ARGS)

static void

termp_pf_post(DECL_ARGS)

{

if (n->next != NULL && (n->next->flags & NODE_LINE) == 0)

if ( ! (n->next == NULL || n->next->flags & NODE_LINE))

p->flags |= TERMP_NOSPACE;

}

static int

termp_ss_pre(DECL_ARGS)

{

struct roff_node *nn;

switch (n->type) {

case ROFFT_BLOCK:

term_newln(p);

if (roff_node_prev(n) == NULL)

for (nn = n->prev; nn != NULL; nn = nn->prev)

term_newln(p);

if ((nn->flags & NODE_NOPRT) == 0)

else

break;

if (nn != NULL)

term_vspace(p);

break;

case ROFFT_HEAD:

term_fontpush(p, TERMFONT_BOLD);

p->tcol->offset = term_len(p, (p->defindent+1)/2);

break;

return termp_bold_pre(p, pair, meta, n);

case ROFFT_BODY:

p->tcol->offset = term_len(p, p->defindent);

term_tab_set(p, NULL);

Line 1568 termp_ss_pre(DECL_ARGS)

Line 1514 termp_ss_pre(DECL_ARGS)

default:

break;

}

return 1;

}

static void

termp_ss_post(DECL_ARGS)

{

if (n->type == ROFFT_HEAD || n->type == ROFFT_BODY)

term_newln(p);

}

static int

termp_cd_pre(DECL_ARGS)

{

synopsis_pre(p, n);

term_fontpush(p, TERMFONT_BOLD);

return 1;

}

static int

termp_in_pre(DECL_ARGS)

{

synopsis_pre(p, n);

if (n->flags & NODE_SYNPRETTY && n->flags & NODE_LINE) {

if (NODE_SYNPRETTY & n->flags && NODE_LINE & n->flags) {

term_fontpush(p, TERMFONT_BOLD);

term_word(p, "#include");

term_word(p, "<");

Line 1603 termp_in_pre(DECL_ARGS)

Line 1536 termp_in_pre(DECL_ARGS)

term_word(p, "<");

term_fontpush(p, TERMFONT_UNDER);

}

p->flags |= TERMP_NOSPACE;

return 1;

}

Line 1611 termp_in_pre(DECL_ARGS)

Line 1543 termp_in_pre(DECL_ARGS)

static void

termp_in_post(DECL_ARGS)

{

if (n->flags & NODE_SYNPRETTY)

if (NODE_SYNPRETTY & n->flags)

term_fontpush(p, TERMFONT_BOLD);

p->flags |= TERMP_NOSPACE;

term_word(p, ">");

if (n->flags & NODE_SYNPRETTY)

if (NODE_SYNPRETTY & n->flags)

term_fontpop(p);

}

static int

termp_pp_pre(DECL_ARGS)

{

fn_prio = 0;

term_vspace(p);

return 0;

}

Line 1633 termp_pp_pre(DECL_ARGS)

Line 1561 termp_pp_pre(DECL_ARGS)

static int

termp_skip_pre(DECL_ARGS)

{

return 0;

}

static int

termp_quote_pre(DECL_ARGS)

{

if (n->type != ROFFT_BODY && n->type != ROFFT_ELEM)

return 1;

Line 1664 termp_quote_pre(DECL_ARGS)

Line 1590 termp_quote_pre(DECL_ARGS)

/* FALLTHROUGH */

case MDOC_Do:

case MDOC_Dq:

term_word(p, "\\(Lq");

term_word(p, "\\(lq");

break;

case MDOC_En:

if (NULL == n->norm->Es ||

Line 1722 termp_quote_post(DECL_ARGS)

Line 1648 termp_quote_post(DECL_ARGS)

/* FALLTHROUGH */

case MDOC_Do:

case MDOC_Dq:

term_word(p, "\\(Rq");

term_word(p, "\\(rq");

break;

case MDOC_En:

if (n->norm->Es == NULL ||

Line 1797 termp_eo_post(DECL_ARGS)

Line 1723 termp_eo_post(DECL_ARGS)

static int

termp_fo_pre(DECL_ARGS)

{

size_t rmargin = 0;

size_t rmargin;

int pretty;

pretty = NODE_SYNPRETTY & n->flags;

switch (n->type) {

case ROFFT_BLOCK:

if (n->type == ROFFT_BLOCK) {

synopsis_pre(p, n);

return 1;

} else if (n->type == ROFFT_BODY) {

case ROFFT_BODY:

if (pretty) {

rmargin = p->tcol->rmargin;

if (n->flags & NODE_SYNPRETTY) {

p->tcol->rmargin = p->tcol->offset + term_len(p, 4);

p->flags |= TERMP_NOBREAK | TERMP_BRIND |

TERMP_HANG;

Line 1815 termp_fo_pre(DECL_ARGS)

Line 1739 termp_fo_pre(DECL_ARGS)

p->flags |= TERMP_NOSPACE;

term_word(p, "(");

p->flags |= TERMP_NOSPACE;

if (pretty) {

if (n->flags & NODE_SYNPRETTY) {

term_flushln(p);

p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND |

TERMP_HANG);

Line 1824 termp_fo_pre(DECL_ARGS)

Line 1748 termp_fo_pre(DECL_ARGS)

p->tcol->rmargin = rmargin;

}

return 1;

default:

return termp_bold_pre(p, pair, meta, n);

}

if (NULL == n->child)

return 0;

/* XXX: we drop non-initial arguments as per groff. */

assert(n->child->string);

term_fontpush(p, TERMFONT_BOLD);

term_word(p, n->child->string);

return 0;

}

static void

termp_fo_post(DECL_ARGS)

{

if (n->type != ROFFT_BODY)

return;

p->flags |= TERMP_NOSPACE;

term_word(p, ")");

if (NODE_SYNPRETTY & n->flags) {

if (n->flags & NODE_SYNPRETTY) {

p->flags |= TERMP_NOSPACE;

term_word(p, ";");

term_flushln(p);

Line 1857 termp_fo_post(DECL_ARGS)

Line 1772 termp_fo_post(DECL_ARGS)

static int

termp_bf_pre(DECL_ARGS)

{

switch (n->type) {

if (n->type == ROFFT_HEAD)

case ROFFT_HEAD:

return 0;

else if (n->type != ROFFT_BODY)

case ROFFT_BODY:

break;

default:

return 1;

}

if (FONT_Em == n->norm->Bf.font)

switch (n->norm->Bf.font) {

term_fontpush(p, TERMFONT_UNDER);

case FONT_Em:

else if (FONT_Sy == n->norm->Bf.font)

return termp_under_pre(p, pair, meta, n);

term_fontpush(p, TERMFONT_BOLD);

case FONT_Sy:

else

return termp_bold_pre(p, pair, meta, n);

term_fontpush(p, TERMFONT_NONE);

default:

return termp_li_pre(p, pair, meta, n);

return 1;

}

static int

termp_sm_pre(DECL_ARGS)

{

if (n->child == NULL)

if (NULL == n->child)

p->flags ^= TERMP_NONOSPACE;

else if (0 == strcmp("on", n->child->string))

else if (strcmp(n->child->string, "on") == 0)

p->flags &= ~TERMP_NONOSPACE;

else

p->flags |= TERMP_NONOSPACE;

Line 1893 termp_sm_pre(DECL_ARGS)

Line 1809 termp_sm_pre(DECL_ARGS)

static int

termp_ap_pre(DECL_ARGS)

{

p->flags |= TERMP_NOSPACE;

term_word(p, "'");

p->flags |= TERMP_NOSPACE;

Line 1903 termp_ap_pre(DECL_ARGS)

Line 1818 termp_ap_pre(DECL_ARGS)

static void

termp____post(DECL_ARGS)

{

struct roff_node *nn;

* Handle lists of authors. In general, print each followed by

* a comma. Don't print the comma if there are only two

* authors.

if (MDOC__A == n->tok && n->next && MDOC__A == n->next->tok)

if (n->tok == MDOC__A &&

if (NULL == n->next->next || MDOC__A != n->next->next->tok)

(nn = roff_node_next(n)) != NULL && nn->tok == MDOC__A &&

if (NULL == n->prev || MDOC__A != n->prev->tok)

((nn = roff_node_next(nn)) == NULL || nn->tok != MDOC__A) &&

return;

((nn = roff_node_prev(n)) == NULL || nn->tok != MDOC__A))

return;

/* TODO: %U. */

if (NULL == n->parent || MDOC_Rs != n->parent->tok)

if (n->parent == NULL || n->parent->tok != MDOC_Rs)

return;

p->flags |= TERMP_NOSPACE;

if (NULL == n->next) {

if (roff_node_next(n) == NULL) {

term_word(p, ".");

p->flags |= TERMP_SENTENCE;

} else

Line 1930 termp____post(DECL_ARGS)

Line 1847 termp____post(DECL_ARGS)

static int

termp_li_pre(DECL_ARGS)

{

termp_tag_pre(p, pair, meta, n);

term_fontpush(p, TERMFONT_NONE);

return 1;

}

Line 1940 static int

Line 1855 static int

termp_lk_pre(DECL_ARGS)

{

const struct roff_node *link, *descr, *punct;

int display;

if ((link = n->child) == NULL)

return 0;

Line 1966 termp_lk_pre(DECL_ARGS)

Line 1880 termp_lk_pre(DECL_ARGS)

}

/* Link target. */

display = term_strlen(p, link->string) >= 26;

if (display) {

term_newln(p);

p->tcol->offset += term_len(p, p->defindent + 1);

}

term_fontpush(p, TERMFONT_BOLD);

term_word(p, link->string);

term_fontpop(p);

Line 1981 termp_lk_pre(DECL_ARGS)

Line 1890 termp_lk_pre(DECL_ARGS)

term_word(p, punct->string);

punct = punct->next;

}

if (display)

term_newln(p);

return 0;

}

static int

termp_bk_pre(DECL_ARGS)

{

switch (n->type) {

case ROFFT_BLOCK:

break;

Line 2002 termp_bk_pre(DECL_ARGS)

Line 1908 termp_bk_pre(DECL_ARGS)

default:

abort();

}

return 1;

}

static void

termp_bk_post(DECL_ARGS)

{

if (n->type == ROFFT_BODY)

p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);

}

* If we are in an `Rs' and there is a journal present,

* then quote us instead of underlining us (for disambiguation).

static void

termp__t_post(DECL_ARGS)

{

if (n->parent != NULL && n->parent->tok == MDOC_Rs &&

* If we're in an `Rs' and there's a journal present, then quote

* us instead of underlining us (for disambiguation).

if (n->parent && MDOC_Rs == n->parent->tok &&

n->parent->norm->Rs.quote_T)

termp_quote_post(p, pair, meta, n);

termp____post(p, pair, meta, n);

}

static int

termp__t_pre(DECL_ARGS)

{

if (n->parent != NULL && n->parent->tok == MDOC_Rs &&

* If we're in an `Rs' and there's a journal present, then quote

* us instead of underlining us (for disambiguation).

if (n->parent && MDOC_Rs == n->parent->tok &&

n->parent->norm->Rs.quote_T)

return termp_quote_pre(p, pair, meta, n);

else

term_fontpush(p, TERMFONT_UNDER);

return termp_under_pre(p, pair, meta, n);

return 1;

}

static int

termp_under_pre(DECL_ARGS)

{

term_fontpush(p, TERMFONT_UNDER);

return 1;

}

static int

termp_em_pre(DECL_ARGS)

termp_abort_pre(DECL_ARGS)

{

if (n->child != NULL &&

abort();

n->child->type == ROFFT_TEXT)

tag_put(n->child->string, 0, p->line);

term_fontpush(p, TERMFONT_UNDER);

return 1;

}

static int

termp_sy_pre(DECL_ARGS)

{

if (n->child != NULL &&

n->child->type == ROFFT_TEXT)

tag_put(n->child->string, 0, p->line);

term_fontpush(p, TERMFONT_BOLD);

return 1;

}

static int

termp_er_pre(DECL_ARGS)

{

if (n->sec == SEC_ERRORS &&

(n->parent->tok == MDOC_It ||

(n->parent->tok == MDOC_Bq &&

n->parent->parent->parent->tok == MDOC_It)))

tag_put(n->child->string, 1, p->line);

return 1;

}

static int

termp_tag_pre(DECL_ARGS)

{

if (n->child != NULL &&

n->child->type == ROFFT_TEXT &&

(n->prev == NULL ||

(n->prev->type == ROFFT_TEXT &&

strcmp(n->prev->string, "|") == 0)) &&

(n->parent->tok == MDOC_It ||

(n->parent->tok == MDOC_Xo &&

n->parent->parent->prev == NULL &&

n->parent->parent->parent->tok == MDOC_It)))

tag_put(n->child->string, 1, p->line);

return 1;

}

CVSweb