mandoc/mdoc_man.c - diff

Return to mdoc_man.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mdoc_man.c between version 1.14 and 1.26

version 1.14, 2012/07/07 14:05:40

version 1.26, 2012/07/09 17:53:01

Line 29

#include "main.h"

#define DECL_ARGS const struct mdoc_meta *m, \

const struct mdoc_node *n, \

const struct mdoc_node *n

struct mman *mm

struct mman {

int mode_space; /* spacing mode: 1 = on */

int need_space; /* next word needs prior ws */

int mode_keep; /* currently inside a keep */

int need_nl; /* next word needs prior nl */

};

struct manact {

int (*cond)(DECL_ARGS); /* DON'T run actions */

int (*pre)(DECL_ARGS); /* pre-node action */

Line 49 struct manact {

Line 41 struct manact {

static int cond_body(DECL_ARGS);

static int cond_head(DECL_ARGS);

static void font_push(char);

static void font_pop(void);

static void post_bd(DECL_ARGS);

static void post_bk(DECL_ARGS);

static void post_dl(DECL_ARGS);

static void post_enc(DECL_ARGS);

static void post_fa(DECL_ARGS);

static void post_fl(DECL_ARGS);

static void post_fn(DECL_ARGS);

static void post_fo(DECL_ARGS);

static void post_font(DECL_ARGS);

static void post_in(DECL_ARGS);

static void post_lb(DECL_ARGS);

static void post_nm(DECL_ARGS);

static void post_percent(DECL_ARGS);

static void post_pf(DECL_ARGS);

static void post_sect(DECL_ARGS);

static void post_sp(DECL_ARGS);

static void post_vt(DECL_ARGS);

static int pre_an(DECL_ARGS);

static int pre_ap(DECL_ARGS);

static int pre_bd(DECL_ARGS);

static int pre_bk(DECL_ARGS);

Line 66 static int pre_br(DECL_ARGS);

Line 68 static int pre_br(DECL_ARGS);

static int pre_bx(DECL_ARGS);

static int pre_dl(DECL_ARGS);

static int pre_enc(DECL_ARGS);

static int pre_em(DECL_ARGS);

static int pre_fa(DECL_ARGS);

static int pre_fl(DECL_ARGS);

static int pre_fn(DECL_ARGS);

static int pre_fo(DECL_ARGS);

static int pre_ft(DECL_ARGS);

static int pre_in(DECL_ARGS);

static int pre_it(DECL_ARGS);

static int pre_lk(DECL_ARGS);

static int pre_li(DECL_ARGS);

static int pre_nm(DECL_ARGS);

static int pre_no(DECL_ARGS);

static int pre_ns(DECL_ARGS);

static int pre_pp(DECL_ARGS);

static int pre_sm(DECL_ARGS);

static int pre_sp(DECL_ARGS);

static int pre_sect(DECL_ARGS);

static int pre_sy(DECL_ARGS);

static void pre_syn(const struct mdoc_node *);

static int pre_vt(DECL_ARGS);

static int pre_ux(DECL_ARGS);

static int pre_xr(DECL_ARGS);

static void print_word(struct mman *, const char *);

static void print_word(const char *);

static void print_offs(struct mman *, const char *);

static void print_offs(const char *);

static void print_node(DECL_ARGS);

static const struct manact manacts[MDOC_MAX + 1] = {

Line 94 static const struct manact manacts[MDOC_MAX + 1] = {

Line 109 static const struct manact manacts[MDOC_MAX + 1] = {

{ NULL, NULL, NULL, NULL, NULL }, /* Bl */

{ NULL, NULL, NULL, NULL, NULL }, /* El */

{ NULL, pre_it, NULL, NULL, NULL }, /* _It */

{ NULL, pre_enc, post_enc, "\\fI", "\\fP" }, /* Ad */

{ NULL, pre_em, post_font, NULL, NULL }, /* Ad */

{ NULL, NULL, NULL, NULL, NULL }, /* _An */

{ NULL, pre_an, NULL, NULL, NULL }, /* An */

{ NULL, pre_enc, post_enc, "\\fI", "\\fP" }, /* Ar */

{ NULL, pre_em, post_font, NULL, NULL }, /* Ar */

{ NULL, pre_enc, post_enc, "\\fB", "\\fP" }, /* Cd */

{ NULL, pre_sy, post_font, NULL, NULL }, /* Cd */

{ NULL, pre_enc, post_enc, "\\fB", "\\fP" }, /* Cm */

{ NULL, pre_sy, post_font, NULL, NULL }, /* Cm */

{ NULL, pre_enc, post_enc, "\\fR", "\\fP" }, /* Dv */

{ NULL, pre_li, post_font, NULL, NULL }, /* Dv */

{ NULL, pre_enc, post_enc, "\\fR", "\\fP" }, /* Er */

{ NULL, pre_li, post_font, NULL, NULL }, /* Er */

{ NULL, pre_enc, post_enc, "\\fR", "\\fP" }, /* Ev */

{ NULL, pre_li, post_font, NULL, NULL }, /* Ev */

{ NULL, pre_enc, post_enc, "The \\fB",

"\\fP\nutility exits 0 on success, and >0 if an error occurs."

}, /* Ex */

{ NULL, NULL, NULL, NULL, NULL }, /* _Fa */

{ NULL, pre_fa, post_fa, NULL, NULL }, /* Fa */

{ NULL, NULL, NULL, NULL, NULL }, /* _Fd */

{ NULL, pre_enc, post_enc, "\\fB-", "\\fP" }, /* Fl */

{ NULL, pre_fl, post_fl, NULL, NULL }, /* Fl */

{ NULL, NULL, NULL, NULL, NULL }, /* _Fn */

{ NULL, pre_fn, post_fn, NULL, NULL }, /* Fn */

{ NULL, NULL, NULL, NULL, NULL }, /* _Ft */

{ NULL, pre_ft, post_font, NULL, NULL }, /* Ft */

{ NULL, pre_enc, post_enc, "\\fB", "\\fP" }, /* Ic */

{ NULL, pre_sy, post_font, NULL, NULL }, /* Ic */

{ NULL, NULL, NULL, NULL, NULL }, /* _In */

{ NULL, pre_in, post_in, NULL, NULL }, /* In */

{ NULL, pre_enc, post_enc, "\\fR", "\\fP" }, /* Li */

{ NULL, pre_li, post_font, NULL, NULL }, /* Li */

{ cond_head, pre_enc, NULL, "\\- ", NULL }, /* Nd */

{ NULL, pre_nm, post_nm, NULL, NULL }, /* Nm */

{ cond_body, pre_enc, post_enc, "[", "]" }, /* Op */

{ NULL, NULL, NULL, NULL, NULL }, /* Ot */

{ NULL, pre_enc, post_enc, "\\fI", "\\fP" }, /* Pa */

{ NULL, pre_em, post_font, NULL, NULL }, /* Pa */

{ NULL, pre_enc, post_enc, "The \\fB",

"\\fP\nfunction returns the value 0 if successful;\n"

"otherwise the value -1 is returned and the global\n"

"variable \\fIerrno\\fP is set to indicate the error."

}, /* Rv */

{ NULL, NULL, NULL, NULL, NULL }, /* St */

{ NULL, NULL, NULL, NULL, NULL }, /* _Va */

{ NULL, pre_em, post_font, NULL, NULL }, /* Va */

{ NULL, NULL, NULL, NULL, NULL }, /* _Vt */

{ NULL, pre_vt, post_vt, NULL, NULL }, /* Vt */

{ NULL, pre_xr, NULL, NULL, NULL }, /* Xr */

{ NULL, NULL, post_percent, NULL, NULL }, /* _%A */

{ NULL, NULL, NULL, NULL, NULL }, /* _%B */

Line 154 static const struct manact manacts[MDOC_MAX + 1] = {

Line 169 static const struct manact manacts[MDOC_MAX + 1] = {

{ cond_body, pre_enc, post_enc, "``", "''" }, /* Dq */

{ NULL, NULL, NULL, NULL, NULL }, /* _Ec */

{ NULL, NULL, NULL, NULL, NULL }, /* _Ef */

{ NULL, pre_enc, post_enc, "\\fI", "\\fP" }, /* Em */

{ NULL, pre_em, post_font, NULL, NULL }, /* Em */

{ NULL, NULL, NULL, NULL, NULL }, /* _Eo */

{ NULL, pre_ux, NULL, "FreeBSD", NULL }, /* Fx */

{ NULL, pre_enc, post_enc, "\\fB", "\\fP" }, /* Ms */

{ NULL, pre_sy, post_font, NULL, NULL }, /* Ms */

{ NULL, NULL, NULL, NULL, NULL }, /* No */

{ NULL, pre_no, NULL, NULL, NULL }, /* No */

{ NULL, pre_ns, NULL, NULL, NULL }, /* Ns */

{ NULL, pre_ux, NULL, "NetBSD", NULL }, /* Nx */

{ NULL, pre_ux, NULL, "OpenBSD", NULL }, /* Ox */

Line 176 static const struct manact manacts[MDOC_MAX + 1] = {

Line 191 static const struct manact manacts[MDOC_MAX + 1] = {

{ cond_body, pre_enc, post_enc, "`", "'" }, /* So */

{ cond_body, pre_enc, post_enc, "`", "'" }, /* Sq */

{ NULL, pre_sm, NULL, NULL, NULL }, /* Sm */

{ NULL, pre_enc, post_enc, "\\fI", "\\fP" }, /* Sx */

{ NULL, pre_em, post_font, NULL, NULL }, /* Sx */

{ NULL, pre_enc, post_enc, "\\fB", "\\fP" }, /* Sy */

{ NULL, pre_sy, post_font, NULL, NULL }, /* Sy */

{ NULL, pre_enc, post_enc, "\\fR", "\\fP" }, /* Tn */

{ NULL, pre_li, post_font, NULL, NULL }, /* Tn */

{ NULL, pre_ux, NULL, "UNIX", NULL }, /* Ux */

{ NULL, NULL, NULL, NULL, NULL }, /* _Xc */

{ NULL, NULL, NULL, NULL, NULL }, /* _Xo */

{ NULL, NULL, NULL, NULL, NULL }, /* _Fo */

{ NULL, pre_fo, post_fo, NULL, NULL }, /* Fo */

{ NULL, NULL, NULL, NULL, NULL }, /* _Fc */

{ NULL, NULL, NULL, NULL, NULL }, /* Fc */

{ cond_body, pre_enc, post_enc, "[", "]" }, /* Oo */

{ NULL, NULL, NULL, NULL, NULL }, /* Oc */

{ NULL, pre_bk, post_bk, NULL, NULL }, /* Bk */

Line 194 static const struct manact manacts[MDOC_MAX + 1] = {

Line 209 static const struct manact manacts[MDOC_MAX + 1] = {

{ NULL, pre_ux, NULL, "currently under development.", NULL }, /* Ud */

{ NULL, NULL, post_lb, NULL, NULL }, /* Lb */

{ NULL, pre_pp, NULL, NULL, NULL }, /* Lp */

{ NULL, NULL, NULL, NULL, NULL }, /* _Lk */

{ NULL, pre_lk, NULL, NULL, NULL }, /* Lk */

{ NULL, NULL, NULL, NULL, NULL }, /* _Mt */

{ NULL, pre_em, post_font, NULL, NULL }, /* Mt */

{ cond_body, pre_enc, post_enc, "{", "}" }, /* Brq */

{ cond_body, pre_enc, post_enc, "{", "}" }, /* Bro */

{ NULL, NULL, NULL, NULL, NULL }, /* Brc */

Line 211 static const struct manact manacts[MDOC_MAX + 1] = {

Line 226 static const struct manact manacts[MDOC_MAX + 1] = {

{ NULL, NULL, NULL, NULL, NULL }, /* ROOT */

};

static int outflags;

#define MMAN_spc (1 << 0)

#define MMAN_spc_force (1 << 1)

#define MMAN_nl (1 << 2)

#define MMAN_br (1 << 3)

#define MMAN_sp (1 << 4)

#define MMAN_Sm (1 << 5)

#define MMAN_Bk (1 << 6)

#define MMAN_An_split (1 << 7)

#define MMAN_An_nosplit (1 << 8)

static struct {

char *head;

char *tail;

size_t size;

} fontqueue;

static void

print_word(struct mman *mm, const char *s)

font_push(char newfont)

{

if (mm->need_nl) {

if (fontqueue.head + fontqueue.size <= ++fontqueue.tail) {

fontqueue.size += 8;

fontqueue.head = mandoc_realloc(fontqueue.head,

fontqueue.size);

}

*fontqueue.tail = newfont;

print_word("\\f");

putchar(newfont);

outflags &= ~MMAN_spc;

}

static void

font_pop(void)

{

if (fontqueue.tail > fontqueue.head)

fontqueue.tail--;

outflags &= ~MMAN_spc;

print_word("\\f");

putchar(*fontqueue.tail);

}

static void

print_word(const char *s)

{

if ((MMAN_sp | MMAN_br | MMAN_nl) & outflags) {

* If we need a newline, print it now and start afresh.

putchar('\n');

if (MMAN_sp & outflags)

mm->need_space = 0;

printf("\n.sp\n");

mm->need_nl = 0;

else if (MMAN_br & outflags)

} else if (mm->need_space && '\0' != s[0])

printf("\n.br\n");

else if (MMAN_nl & outflags)

putchar('\n');

outflags &= ~(MMAN_sp|MMAN_br|MMAN_nl|MMAN_spc);

} else if (MMAN_spc & outflags && '\0' != s[0])

* If we need a space, only print it before

* If we need a space, only print it if

* (1) a nonzero length word;

* (1) it is forced by `No' or

* (2) a word that is non-punctuation; and

* (2) what follows is not terminating punctuation or

* (3) if punctuation, non-terminating puncutation.

* (3) what follows is longer than one character.

if (NULL == strchr(".,:;)]?!", s[0]) || '\0' != s[1]) {

if (MMAN_spc_force & outflags ||

if (mm->mode_keep) {

NULL == strchr(".,:;)]?!", s[0]) || '\0' != s[1]) {

if (MMAN_Bk & outflags) {

putchar('\\');

putchar('~');

} else

Line 241 print_word(struct mman *mm, const char *s)

Line 304 print_word(struct mman *mm, const char *s)

* Reassign needing space if we're not following opening

* punctuation.

mm->need_space = mm->mode_space &&

if (MMAN_Sm & outflags &&

(('(' != s[0] && '[' != s[0]) || '\0' != s[1]);

(('(' != s[0] && '[' != s[0]) || '\0' != s[1]))

outflags |= MMAN_spc;

else

outflags &= ~MMAN_spc;

outflags &= ~MMAN_spc_force;

for ( ; *s; s++) {

switch (*s) {

Line 260 print_word(struct mman *mm, const char *s)

Line 327 print_word(struct mman *mm, const char *s)

}

static void

print_offs(struct mman *mm, const char *v)

print_offs(const char *v)

{

char buf[24];

struct roffsu su;

Line 273 print_offs(struct mman *mm, const char *v)

Line 340 print_offs(struct mman *mm, const char *v)

else if (0 == strcmp(v, "indent-two"))

sz = 12;

else if (a2roffsu(v, &su, SCALE_MAX)) {

print_word(mm, v);

print_word(v);

return;

} else

sz = strlen(v);

snprintf(buf, sizeof(buf), "%ldn", sz);

print_word(mm, buf);

print_word(buf);

}

void

Line 300 man_mdoc(void *arg, const struct mdoc *mdoc)

Line 367 man_mdoc(void *arg, const struct mdoc *mdoc)

{

const struct mdoc_meta *m;

const struct mdoc_node *n;

struct mman mm;

m = mdoc_meta(mdoc);

n = mdoc_node(mdoc);

Line 308 man_mdoc(void *arg, const struct mdoc *mdoc)

Line 374 man_mdoc(void *arg, const struct mdoc *mdoc)

printf(".TH \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",

m->title, m->msec, m->date, m->os, m->vol);

memset(&mm, 0, sizeof(struct mman));

outflags = MMAN_nl | MMAN_Sm;

if (0 == fontqueue.size) {

mm.mode_space = 1;

fontqueue.size = 8;

mm.need_nl = 1;

fontqueue.head = fontqueue.tail = mandoc_malloc(8);

print_node(m, n, &mm);

*fontqueue.tail = 'R';

}

print_node(m, n);

putchar('\n');

}

Line 328 print_node(DECL_ARGS)

Line 396 print_node(DECL_ARGS)

* This makes the page structure be more consistent.

prev = n->prev ? n->prev : n->parent;

if (prev && prev->line < n->line && MDOC_Ns != prev->tok)

if (prev && prev->line < n->line &&

mm->need_nl = 1;

MDOC_Fo != prev->tok && MDOC_Ns != prev->tok)

outflags |= MMAN_nl;

act = NULL;

cond = 0;

Line 340 print_node(DECL_ARGS)

Line 409 print_node(DECL_ARGS)

* Make sure that we don't happen to start with a

* control character at the start of a line.

if (mm->need_nl && ('.' == *n->string ||

if (MMAN_nl & outflags && ('.' == *n->string ||

'\'' == *n->string)) {

print_word(mm, "\\&");

print_word("\\&");

mm->need_space = 0;

outflags &= ~MMAN_spc;

}

print_word(mm, n->string);

print_word(n->string);

} else {

* Conditionally run the pre-node action handler for a

* node.

act = manacts + n->tok;

cond = NULL == act->cond || (*act->cond)(m, n, mm);

cond = NULL == act->cond || (*act->cond)(m, n);

if (cond && act->pre)

do_sub = (*act->pre)(m, n, mm);

do_sub = (*act->pre)(m, n);

}

Line 364 print_node(DECL_ARGS)

Line 433 print_node(DECL_ARGS)

if (do_sub)

for (sub = n->child; sub; sub = sub->next)

print_node(m, sub, mm);

print_node(m, sub);

* Lastly, conditionally run the post-node handler.

if (cond && act->post)

(*act->post)(m, n, mm);

(*act->post)(m, n);

}

static int

Line 387 cond_body(DECL_ARGS)

Line 456 cond_body(DECL_ARGS)

return(MDOC_BODY == n->type);

}

* Output a font encoding before a node, e.g., \fR.

* This obviously has no trailing space.

static int

pre_enc(DECL_ARGS)

{

Line 399 pre_enc(DECL_ARGS)

Line 464 pre_enc(DECL_ARGS)

prefix = manacts[n->tok].prefix;

if (NULL == prefix)

return(1);

print_word(mm, prefix);

print_word(prefix);

mm->need_space = 0;

outflags &= ~MMAN_spc;

return(1);

}

* Output a font encoding subsequent a node, e.g., \fP.

static void

post_enc(DECL_ARGS)

{

Line 415 post_enc(DECL_ARGS)

Line 477 post_enc(DECL_ARGS)

suffix = manacts[n->tok].suffix;

if (NULL == suffix)

return;

mm->need_space = 0;

outflags &= ~MMAN_spc;

print_word(mm, suffix);

print_word(suffix);

if (MDOC_Fl == n->tok && 0 == n->nchild)

mm->need_space = 0;

}

static void

post_font(DECL_ARGS)

{

font_pop();

}

* Used in listings (percent = %A, e.g.).

* FIXME: this is incomplete.

Line 430 static void

Line 497 static void

post_percent(DECL_ARGS)

{

post_enc(m, n, mm);

post_enc(m, n);

if (n->next)

print_word(mm, ",");

print_word(",");

else {

print_word(mm, ".");

print_word(".");

mm->need_nl = 1;

outflags |= MMAN_nl;

}

Line 448 pre_sect(DECL_ARGS)

Line 515 pre_sect(DECL_ARGS)

if (MDOC_HEAD != n->type)

return(1);

mm->need_nl = 1;

outflags |= MMAN_nl;

print_word(mm, manacts[n->tok].prefix);

print_word(manacts[n->tok].prefix);

print_word(mm, "\"");

print_word("\"");

mm->need_space = 0;

outflags &= ~MMAN_spc;

return(1);

}

Line 464 post_sect(DECL_ARGS)

Line 531 post_sect(DECL_ARGS)

if (MDOC_HEAD != n->type)

return;

mm->need_space = 0;

outflags &= ~MMAN_spc;

print_word(mm, "\"");

print_word("\"");

mm->need_nl = 1;

outflags |= MMAN_nl;

if (MDOC_Sh == n->tok && SEC_AUTHORS == n->sec)

outflags &= ~(MMAN_An_split | MMAN_An_nosplit);

}

/* See mdoc_term.c, synopsis_pre() for comments. */

static void

pre_syn(const struct mdoc_node *n)

{

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

return;

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

MDOC_Ft != n->tok &&

MDOC_Fo != n->tok &&

MDOC_Fn != n->tok) {

outflags |= MMAN_br;

return;

}

switch (n->prev->tok) {

case (MDOC_Fd):

/* FALLTHROUGH */

case (MDOC_Fn):

/* FALLTHROUGH */

case (MDOC_Fo):

/* FALLTHROUGH */

case (MDOC_In):

/* FALLTHROUGH */

case (MDOC_Vt):

outflags |= MMAN_sp;

break;

case (MDOC_Ft):

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

outflags |= MMAN_sp;

break;

}

/* FALLTHROUGH */

default:

outflags |= MMAN_br;

break;

}

static int

pre_an(DECL_ARGS)

{

switch (n->norm->An.auth) {

case (AUTH_split):

outflags &= ~MMAN_An_nosplit;

outflags |= MMAN_An_split;

return(0);

case (AUTH_nosplit):

outflags &= ~MMAN_An_split;

outflags |= MMAN_An_nosplit;

return(0);

default:

if (MMAN_An_split & outflags)

outflags |= MMAN_br;

else if (SEC_AUTHORS == n->sec &&

! (MMAN_An_nosplit & outflags))

outflags |= MMAN_An_split;

return(1);

}

static int

pre_ap(DECL_ARGS)

{

mm->need_space = 0;

outflags &= ~MMAN_spc;

print_word(mm, "'");

print_word("'");

mm->need_space = 0;

outflags &= ~MMAN_spc;

return(0);

}

Line 483 static int

Line 615 static int

pre_bd(DECL_ARGS)

{

if (0 == n->norm->Bd.comp) {

if (0 == n->norm->Bd.comp)

mm->need_nl = 1;

outflags |= MMAN_sp;

print_word(mm, ".sp");

}

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

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

mm->need_nl = 1;

outflags |= MMAN_nl;

print_word(mm, ".nf");

print_word(".nf");

}

mm->need_nl = 1;

outflags |= MMAN_nl;

print_word(mm, ".RS");

print_word(".RS");

print_offs(mm, n->norm->Bd.offs);

print_offs(n->norm->Bd.offs);

mm->need_nl = 1;

outflags |= MMAN_nl;

return(1);

}

Line 503 static void

Line 633 static void

post_bd(DECL_ARGS)

{

mm->need_nl = 1;

outflags |= MMAN_nl;

print_word(mm, ".RE");

print_word(".RE");

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

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

mm->need_nl = 1;

outflags |= MMAN_nl;

print_word(mm, ".fi");

print_word(".fi");

}

mm->need_nl = 1;

outflags |= MMAN_nl;

}

static int

Line 521 pre_bk(DECL_ARGS)

Line 651 pre_bk(DECL_ARGS)

case (MDOC_BLOCK):

return(1);

case (MDOC_BODY):

mm->mode_keep = 1;

outflags |= MMAN_Bk;

return(1);

default:

return(0);

Line 533 post_bk(DECL_ARGS)

Line 663 post_bk(DECL_ARGS)

{

if (MDOC_BODY == n->type)

mm->mode_keep = 0;

outflags &= ~MMAN_Bk;

}

static int

pre_br(DECL_ARGS)

{

mm->need_nl = 1;

outflags |= MMAN_br;

print_word(mm, ".br");

mm->need_nl = 1;

return(0);

}

Line 552 pre_bx(DECL_ARGS)

Line 680 pre_bx(DECL_ARGS)

n = n->child;

if (n) {

print_word(mm, n->string);

print_word(n->string);

mm->need_space = 0;

outflags &= ~MMAN_spc;

n = n->next;

}

print_word(mm, "BSD");

print_word("BSD");

if (NULL == n)

return(0);

mm->need_space = 0;

outflags &= ~MMAN_spc;

print_word(mm, "-");

print_word("-");

mm->need_space = 0;

outflags &= ~MMAN_spc;

print_word(mm, n->string);

print_word(n->string);

return(0);

}

Line 570 static int

Line 698 static int

pre_dl(DECL_ARGS)

{

mm->need_nl = 1;

outflags |= MMAN_nl;

print_word(mm, ".RS 6n");

print_word(".RS 6n");

mm->need_nl = 1;

outflags |= MMAN_nl;

return(1);

}

Line 580 static void

Line 708 static void

post_dl(DECL_ARGS)

{

mm->need_nl = 1;

outflags |= MMAN_nl;

print_word(mm, ".RE");

print_word(".RE");

mm->need_nl = 1;

outflags |= MMAN_nl;

}

static int

pre_em(DECL_ARGS)

{

font_push('I');

return(1);

}

static int

pre_fa(DECL_ARGS)

{

if (MDOC_Fa == n->tok)

n = n->child;

while (NULL != n) {

font_push('I');

print_node(m, n);

font_pop();

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

print_word(",");

}

return(0);

}

static void

post_fa(DECL_ARGS)

{

if (NULL != n->next && MDOC_Fa == n->next->tok)

print_word(",");

}

static int

pre_fl(DECL_ARGS)

{

font_push('B');

print_word("-");

outflags &= ~MMAN_spc;

return(1);

}

static void

post_fl(DECL_ARGS)

{

font_pop();

if (0 == n->nchild)

outflags &= ~MMAN_spc;

}

static int

pre_fn(DECL_ARGS)

{

pre_syn(n);

n = n->child;

if (NULL == n)

return(0);

font_push('B');

print_node(m, n);

font_pop();

outflags &= ~MMAN_spc;

print_word("(");

outflags &= ~MMAN_spc;

return(pre_fa(m, n->next));

}

static void

post_fn(DECL_ARGS)

{

print_word(")");

if (MDOC_SYNPRETTY & n->flags) {

print_word(";");

outflags |= MMAN_br;

}

static int

pre_fo(DECL_ARGS)

{

switch (n->type) {

case (MDOC_BLOCK):

pre_syn(n);

break;

case (MDOC_HEAD):

font_push('B');

break;

case (MDOC_BODY):

outflags &= ~MMAN_spc;

print_word("(");

outflags &= ~MMAN_spc;

break;

default:

break;

}

return(1);

}

static void

post_fo(DECL_ARGS)

{

switch (n->type) {

case (MDOC_HEAD):

font_pop();

break;

case (MDOC_BODY):

post_fn(m, n);

break;

default:

break;

}

static int

pre_ft(DECL_ARGS)

{

pre_syn(n);

font_push('I');

return(1);

}

static int

pre_in(DECL_ARGS)

{

if (MDOC_SYNPRETTY & n->flags) {

pre_syn(n);

font_push('B');

print_word("#include <");

outflags &= ~MMAN_spc;

} else {

print_word("<");

outflags &= ~MMAN_spc;

font_push('I');

}

return(1);

}

static void

post_in(DECL_ARGS)

{

if (MDOC_SYNPRETTY & n->flags) {

outflags &= ~MMAN_spc;

print_word(">");

font_pop();

outflags |= MMAN_br;

} else {

font_pop();

outflags &= ~MMAN_spc;

print_word(">");

}

static int

pre_it(DECL_ARGS)

{

const struct mdoc_node *bln;

if (MDOC_HEAD == n->type) {

mm->need_nl = 1;

outflags |= MMAN_nl;

print_word(mm, ".TP");

print_word(".TP");

bln = n->parent->parent->prev;

switch (bln->norm->Bl.type) {

case (LIST_bullet):

print_word(mm, "4n");

print_word("4n");

mm->need_nl = 1;

outflags |= MMAN_nl;

print_word(mm, "\\fBo\\fP");

print_word("\\fBo\\fP");

break;

default:

if (bln->norm->Bl.width)

print_word(mm, bln->norm->Bl.width);

print_word(bln->norm->Bl.width);

break;

}

mm->need_nl = 1;

outflags |= MMAN_nl;

}

return(1);

}

Line 614 static void

Line 904 static void

post_lb(DECL_ARGS)

{

if (SEC_LIBRARY == n->sec) {

if (SEC_LIBRARY == n->sec)

mm->need_nl = 1;

outflags |= MMAN_br;

print_word(mm, ".br");

}

mm->need_nl = 1;

static int

pre_lk(DECL_ARGS)

{

const struct mdoc_node *link, *descr;

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

return(0);

if (NULL != (descr = link->next)) {

font_push('I');

while (NULL != descr) {

print_word(descr->string);

descr = descr->next;

}

print_word(":");

font_pop();

}

font_push('B');

print_word(link->string);

font_pop();

return(0);

}

static int

pre_li(DECL_ARGS)

{

font_push('R');

return(1);

}

static int

pre_nm(DECL_ARGS)

{

if (MDOC_BLOCK == n->type)

pre_syn(n);

if (MDOC_ELEM != n->type && MDOC_HEAD != n->type)

return(1);

if (MDOC_SYNPRETTY & n->flags) {

if (NULL == n->child && NULL == m->name)

mm->need_nl = 1;

return(0);

print_word(mm, ".br");

font_push('B');

mm->need_nl = 1;

}

print_word(mm, "\\fB");

mm->need_space = 0;

if (NULL == n->child)

print_word(mm, m->name);

print_word(m->name);

return(1);

}

Line 645 post_nm(DECL_ARGS)

Line 962 post_nm(DECL_ARGS)

if (MDOC_ELEM != n->type && MDOC_HEAD != n->type)

return;

mm->need_space = 0;

font_pop();

print_word(mm, "\\fP");

}

static int

pre_no(DECL_ARGS)

{

outflags |= MMAN_spc_force;

return(1);

}

static int

pre_ns(DECL_ARGS)

{

mm->need_space = 0;

outflags &= ~MMAN_spc;

return(0);

}

Line 661 static void

Line 985 static void

post_pf(DECL_ARGS)

{

mm->need_space = 0;

outflags &= ~MMAN_spc;

}

static int

pre_pp(DECL_ARGS)

{

mm->need_nl = 1;

outflags |= MMAN_nl;

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

print_word(mm, ".sp");

print_word(".sp");

else

print_word(mm, ".PP");

print_word(".PP");

mm->need_nl = 1;

outflags |= MMAN_nl;

return(MDOC_Rs == n->tok);

}

Line 683 pre_sm(DECL_ARGS)

Line 1007 pre_sm(DECL_ARGS)

assert(n->child && MDOC_TEXT == n->child->type);

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

mm->mode_space = 1;

outflags |= MMAN_Sm;

else

mm->mode_space = 0;

outflags &= ~MMAN_Sm;

return(0);

}

Line 693 static int

Line 1017 static int

pre_sp(DECL_ARGS)

{

mm->need_nl = 1;

outflags |= MMAN_nl;

print_word(mm, ".sp");

print_word(".sp");

return(1);

}

Line 702 static void

Line 1026 static void

post_sp(DECL_ARGS)

{

mm->need_nl = 1;

outflags |= MMAN_nl;

}

static int

pre_sy(DECL_ARGS)

{

font_push('B');

return(1);

}

static int

pre_vt(DECL_ARGS)

{

if (MDOC_SYNPRETTY & n->flags) {

switch (n->type) {

case (MDOC_BLOCK):

pre_syn(n);

return(1);

case (MDOC_BODY):

break;

default:

return(0);

}

font_push('I');

return(1);

}

static void

post_vt(DECL_ARGS)

{

if (MDOC_SYNPRETTY & n->flags && MDOC_BODY != n->type)

return;

font_pop();

}

static int

pre_xr(DECL_ARGS)

{

n = n->child;

if (NULL == n)

return(0);

print_node(m, n, mm);

print_node(m, n);

n = n->next;

if (NULL == n)

return(0);

mm->need_space = 0;

outflags &= ~MMAN_spc;

print_word(mm, "(");

print_word("(");

print_node(m, n, mm);

print_node(m, n);

print_word(mm, ")");

print_word(")");

return(0);

}

Line 727 static int

Line 1087 static int

pre_ux(DECL_ARGS)

{

print_word(mm, manacts[n->tok].prefix);

print_word(manacts[n->tok].prefix);

if (NULL == n->child)

return(0);

mm->need_space = 0;

outflags &= ~MMAN_spc;

print_word(mm, "\\~");

print_word("\\~");

mm->need_space = 0;

outflags &= ~MMAN_spc;

return(1);

}

CVSweb