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.53 and 1.127

version 1.53, 2013/10/07 22:22:10

version 1.127, 2018/08/17 20:33:37

Line 1

/* $Id$ */

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

* purpose with or without fee is hereby granted, provided that the above

Line 14

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

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

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <sys/types.h>

#include <assert.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "mandoc_aux.h"

#include "mandoc.h"

#include "out.h"

#include "roff.h"

#include "man.h"

#include "mdoc.h"

#include "man.h"

#include "out.h"

#include "main.h"

#define DECL_ARGS const struct mdoc_meta *meta, \

#define DECL_ARGS const struct roff_meta *meta, struct roff_node *n

const struct mdoc_node *n

struct manact {

typedef int (*int_fp)(DECL_ARGS);

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

typedef void (*void_fp)(DECL_ARGS);

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

void (*post)(DECL_ARGS); /* post-node action */

struct mdoc_man_act {

int_fp cond; /* DON'T run actions */

int_fp pre; /* pre-node action */

void_fp post; /* post-node action */

const char *prefix; /* pre-node string constant */

const char *suffix; /* post-node string constant */

};

Line 43 static int cond_body(DECL_ARGS);

Line 48 static int cond_body(DECL_ARGS);

static int cond_head(DECL_ARGS);

static void font_push(char);

static void font_pop(void);

static int man_strlen(const char *);

static void mid_it(void);

static void post__t(DECL_ARGS);

static void post_aq(DECL_ARGS);

static void post_bd(DECL_ARGS);

static void post_bf(DECL_ARGS);

static void post_bk(DECL_ARGS);

static void post_bl(DECL_ARGS);

static void post_dl(DECL_ARGS);

static void post_en(DECL_ARGS);

static void post_enc(DECL_ARGS);

static void post_eo(DECL_ARGS);

static void post_fa(DECL_ARGS);

Line 65 static void post_nm(DECL_ARGS);

Line 73 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__t(DECL_ARGS);

static int pre_an(DECL_ARGS);

static int pre_ap(DECL_ARGS);

static int pre_aq(DECL_ARGS);

static int pre_bd(DECL_ARGS);

static int pre_bf(DECL_ARGS);

static int pre_bk(DECL_ARGS);

static int pre_bl(DECL_ARGS);

static int pre_br(DECL_ARGS);

static void pre_br(DECL_ARGS);

static int pre_bx(DECL_ARGS);

static int pre_dl(DECL_ARGS);

static int pre_en(DECL_ARGS);

static int pre_enc(DECL_ARGS);

static int pre_em(DECL_ARGS);

static int pre_skip(DECL_ARGS);

static int pre_eo(DECL_ARGS);

static int pre_ex(DECL_ARGS);

static int pre_fa(DECL_ARGS);

static int pre_fd(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 void pre_ft(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);

Line 92 static int pre_li(DECL_ARGS);

Line 104 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 void pre_onearg(DECL_ARGS);

static int pre_pp(DECL_ARGS);

static int pre_rs(DECL_ARGS);

static int pre_sm(DECL_ARGS);

static int pre_sp(DECL_ARGS);

static void 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 void pre_syn(const struct roff_node *);

static void pre_ta(DECL_ARGS);

static int pre_vt(DECL_ARGS);

static int pre_ux(DECL_ARGS);

static int pre_xr(DECL_ARGS);

static void print_word(const char *);

static void print_line(const char *, int);

static void print_block(const char *, int);

static void print_offs(const char *);

static void print_offs(const char *, int);

static void print_width(const char *,

static void print_width(const struct mdoc_bl *,

const struct mdoc_node *, size_t);

const struct roff_node *);

static void print_count(int *);

static void print_node(DECL_ARGS);

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

static const void_fp roff_man_acts[ROFF_MAX] = {

{ NULL, pre_ap, NULL, NULL, NULL }, /* Ap */

pre_br, /* br */

pre_onearg, /* ce */

pre_ft, /* ft */

pre_onearg, /* ll */

pre_onearg, /* mc */

pre_onearg, /* po */

pre_onearg, /* rj */

pre_sp, /* sp */

pre_ta, /* ta */

pre_onearg, /* ti */

};

static const struct mdoc_man_act mdoc_man_acts[MDOC_MAX - MDOC_Dd] = {

{ NULL, NULL, NULL, NULL, NULL }, /* Dd */

{ NULL, NULL, NULL, NULL, NULL }, /* Dt */

{ NULL, NULL, NULL, NULL, NULL }, /* Os */

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

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

{ NULL, pre_it, post_it, NULL, NULL }, /* It */

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

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

{ NULL, pre_ap, NULL, NULL, NULL }, /* Ap */

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

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

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

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

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

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

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

{ NULL, pre_ex, NULL, NULL, NULL }, /* Ex */

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

}, /* Ex */

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

{ NULL, pre_fd, post_fd, NULL, NULL }, /* Fd */

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

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

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

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

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

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

{ 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_Ft, post_font, NULL, NULL }, /* Ot */

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

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

{ NULL, pre_ex, NULL, NULL, NULL }, /* Rv */

"\\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, pre_em, post_font, NULL, NULL }, /* Va */

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

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

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

{ NULL, pre__t, post__t, NULL, NULL }, /* %T */

{ NULL, NULL, post_percent, NULL, NULL }, /* %V */

{ NULL, NULL, NULL, NULL, NULL }, /* Ac */

{ cond_body, pre_enc, post_enc, "<", ">" }, /* Ao */

{ cond_body, pre_aq, post_aq, NULL, NULL }, /* Ao */

{ cond_body, pre_enc, post_enc, "<", ">" }, /* Aq */

{ cond_body, pre_aq, post_aq, NULL, NULL }, /* Aq */

{ NULL, NULL, NULL, NULL, NULL }, /* At */

{ NULL, NULL, NULL, NULL, NULL }, /* Bc */

{ NULL, pre_bf, post_bf, NULL, NULL }, /* Bf */

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

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

{ NULL, pre_ux, NULL, "BSD/OS", NULL }, /* Bsx */

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

{ NULL, pre_bx, NULL, NULL, NULL }, /* Bx */

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

{ NULL, NULL, NULL, NULL, NULL }, /* Db */

{ NULL, pre_skip, NULL, NULL, NULL }, /* Db */

{ NULL, NULL, NULL, NULL, NULL }, /* Dc */

{ cond_body, pre_enc, post_enc, "\\(lq", "\\(rq" }, /* Do */

{ cond_body, pre_enc, post_enc, "\\(lq", "\\(rq" }, /* Dq */

{ NULL, NULL, NULL, NULL, NULL }, /* Ec */

{ NULL, NULL, NULL, NULL, NULL }, /* Ef */

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

{ NULL, NULL, post_eo, NULL, NULL }, /* Eo */

{ cond_body, pre_eo, post_eo, NULL, NULL }, /* Eo */

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

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

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

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

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

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

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

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

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

{ NULL, NULL, NULL, NULL, NULL }, /* Pc */

{ NULL, NULL, post_pf, NULL, NULL }, /* Pf */

{ cond_body, pre_enc, post_enc, "(", ")" }, /* Po */

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

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

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

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

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

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

{ NULL, NULL, NULL, NULL, NULL }, /* Ux */

{ NULL, NULL, NULL, NULL, NULL }, /* Xc */

{ NULL, NULL, NULL, NULL, NULL }, /* Xo */

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

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

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

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

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

{ NULL, NULL, NULL, NULL, NULL }, /* Ek */

{ NULL, pre_ux, NULL, "is currently in beta test.", NULL }, /* Bt */

{ NULL, NULL, NULL, NULL, NULL }, /* Bt */

{ NULL, NULL, NULL, NULL, NULL }, /* Hf */

{ NULL, NULL, NULL, NULL, NULL }, /* Fr */

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

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

{ NULL, NULL, NULL, NULL, NULL }, /* Ud */

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

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

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

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

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

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

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

{ NULL, NULL, post_percent, NULL, NULL }, /* %C */

{ NULL, NULL, NULL, NULL, NULL }, /* Es */

{ NULL, pre_skip, NULL, NULL, NULL }, /* Es */

{ NULL, NULL, NULL, NULL, NULL }, /* En */

{ cond_body, pre_en, post_en, NULL, NULL }, /* En */

{ NULL, pre_ux, NULL, "DragonFly", NULL }, /* Dx */

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

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

{ NULL, pre_br, NULL, NULL, NULL }, /* br */

{ NULL, pre_sp, post_sp, NULL, NULL }, /* sp */

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

{ NULL, NULL, NULL, NULL, NULL }, /* Ta */

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

};

static const struct mdoc_man_act *mdoc_man_act(enum roff_tok);

static int outflags;

#define MMAN_spc (1 << 0) /* blank character before next word */

Line 256 static int outflags;

Line 274 static int outflags;

#define MMAN_An_split (1 << 9) /* author mode is "split" */

#define MMAN_An_nosplit (1 << 10) /* author mode is "nosplit" */

#define MMAN_PD (1 << 11) /* inter-paragraph spacing disabled */

#define MMAN_nbrword (1 << 12) /* do not break the next word */

#define BL_STACK_MAX 32

static size_t Bl_stack[BL_STACK_MAX]; /* offsets [chars] */

static int Bl_stack[BL_STACK_MAX]; /* offsets [chars] */

static int Bl_stack_post[BL_STACK_MAX]; /* add final .RE */

static int Bl_stack_len; /* number of nested Bl blocks */

static int TPremain; /* characters before tag is full */

Line 270 static struct {

Line 289 static struct {

size_t size;

} fontqueue;

static const struct mdoc_man_act *

mdoc_man_act(enum roff_tok tok)

{

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

return mdoc_man_acts + (tok - MDOC_Dd);

}

static int

man_strlen(const char *cp)

{

size_t rsz;

int skip, sz;

sz = 0;

skip = 0;

for (;;) {

rsz = strcspn(cp, "\\");

if (rsz) {

cp += rsz;

if (skip) {

skip = 0;

rsz--;

}

sz += rsz;

}

if ('\0' == *cp)

break;

cp++;

switch (mandoc_escape(&cp, NULL, NULL)) {

case ESCAPE_ERROR:

return sz;

case ESCAPE_UNICODE:

case ESCAPE_NUMBERED:

case ESCAPE_SPECIAL:

case ESCAPE_OVERSTRIKE:

if (skip)

skip = 0;

else

sz++;

break;

case ESCAPE_SKIPCHAR:

skip = 1;

break;

default:

break;

}

return sz;

}

static void

font_push(char newfont)

{

Line 277 font_push(char newfont)

Line 347 font_push(char newfont)

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

fontqueue.size += 8;

fontqueue.head = mandoc_realloc(fontqueue.head,

fontqueue.size);

}

*fontqueue.tail = newfont;

print_word("");

Line 303 print_word(const char *s)

Line 373 print_word(const char *s)

{

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

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

if (MMAN_PP & outflags) {

Line 358 print_word(const char *s)

Line 428 print_word(const char *s)

for ( ; *s; s++) {

switch (*s) {

case (ASCII_NBRSP):

case ASCII_NBRSP:

printf("\\ ");

break;

case (ASCII_HYPH):

case ASCII_HYPH:

putchar('-');

break;

case ASCII_BREAK:

printf("\\:");

break;

case ' ':

if (MMAN_nbrword & outflags) {

printf("\\ ");

break;

}

/* FALLTHROUGH */

default:

putchar((unsigned char)*s);

break;

Line 371 print_word(const char *s)

Line 450 print_word(const char *s)

if (TPremain)

TPremain--;

}

outflags &= ~MMAN_nbrword;

}

static void

print_line(const char *s, int newflags)

{

outflags &= ~MMAN_br;

outflags |= MMAN_nl;

print_word(s);

outflags |= newflags;

Line 402 print_block(const char *s, int newflags)

Line 481 print_block(const char *s, int newflags)

}

static void

print_offs(const char *v)

print_offs(const char *v, int keywords)

{

char buf[24];

struct roffsu su;

size_t sz;

const char *end;

int sz;

print_line(".RS", MMAN_Bk_susp);

/* Convert v into a number (of characters). */

if (NULL == v || '\0' == *v || 0 == strcmp(v, "left"))

if (NULL == v || '\0' == *v || (keywords && !strcmp(v, "left")))

sz = 0;

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

else if (keywords && !strcmp(v, "indent"))

sz = 6;

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

else if (keywords && !strcmp(v, "indent-two"))

sz = 12;

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

else {

if (SCALE_EN == su.unit)

end = a2roffsu(v, &su, SCALE_EN);

if (end == NULL || *end != '\0')

sz = man_strlen(v);

else if (SCALE_EN == su.unit)

sz = su.scale;

else {

Line 432 print_offs(const char *v)

Line 515 print_offs(const char *v)

outflags |= MMAN_nl;

return;

}

} else

}

sz = strlen(v);

* We are inside an enclosing list.

Line 442 print_offs(const char *v)

Line 524 print_offs(const char *v)

if (Bl_stack_len)

sz += Bl_stack[Bl_stack_len - 1];

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

(void)snprintf(buf, sizeof(buf), "%dn", sz);

print_word(buf);

outflags |= MMAN_nl;

}

Line 450 print_offs(const char *v)

Line 532 print_offs(const char *v)

* Set up the indentation for a list item; used from pre_it().

void

static void

print_width(const char *v, const struct mdoc_node *child, size_t defsz)

print_width(const struct mdoc_bl *bl, const struct roff_node *child)

{

char buf[24];

struct roffsu su;

size_t sz, chsz;

const char *end;

int numeric, remain;

int numeric, remain, sz, chsz;

numeric = 1;

remain = 0;

/* Convert v into a number (of characters). */

/* Convert the width into a number (of characters). */

if (NULL == v)

if (bl->width == NULL)

sz = defsz;

sz = (bl->type == LIST_hang) ? 6 : 0;

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

else {

if (SCALE_EN == su.unit)

end = a2roffsu(bl->width, &su, SCALE_MAX);

if (end == NULL || *end != '\0')

sz = man_strlen(bl->width);

else if (SCALE_EN == su.unit)

sz = su.scale;

else {

sz = 0;

numeric = 0;

}

} else

}

sz = strlen(v);

/* XXX Rough estimation, might have multiple parts. */

chsz = (NULL != child && MDOC_TEXT == child->type) ?

if (bl->type == LIST_enum)

strlen(child->string) : 0;

chsz = (bl->count > 8) + 1;

else if (child != NULL && child->type == ROFFT_TEXT)

chsz = man_strlen(child->string);

else

chsz = 0;

/* Maybe we are inside an enclosing list? */

mid_it();

Line 488 print_width(const char *v, const struct mdoc_node *chi

Line 576 print_width(const char *v, const struct mdoc_node *chi

Bl_stack[Bl_stack_len++] = sz + 2;

/* Set up the current list. */

if (defsz && chsz > sz)

if (chsz > sz && bl->type != LIST_tag)

print_block(".HP", 0);

else {

print_block(".TP", 0);

remain = sz + 2;

}

if (numeric) {

snprintf(buf, sizeof(buf), "%zun", sz + 2);

(void)snprintf(buf, sizeof(buf), "%dn", sz + 2);

print_word(buf);

} else

print_word(v);

print_word(bl->width);

TPremain = remain;

}

void

static void

print_count(int *count)

{

char buf[12];

char buf[24];

snprintf(buf, sizeof(buf), "%d.", ++*count);

(void)snprintf(buf, sizeof(buf), "%d.\\&", ++*count);

print_word(buf);

}

void

man_man(void *arg, const struct man *man)

man_man(void *arg, const struct roff_man *man)

{

Line 525 man_man(void *arg, const struct man *man)

Line 613 man_man(void *arg, const struct man *man)

}

void

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

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

{

const struct mdoc_meta *meta;

struct roff_node *n;

const struct mdoc_node *n;

meta = mdoc_meta(mdoc);

printf(".\\\" Automatically generated from an mdoc input file."

n = mdoc_node(mdoc);

" Do not edit.\n");

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

if (n->type != ROFFT_COMMENT)

break;

printf(".\\\"%s\n", n->string);

}

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

meta->title, meta->msec, meta->date,

mdoc->meta.title,

meta->os, meta->vol);

(mdoc->meta.msec == NULL ? "" : mdoc->meta.msec),

mdoc->meta.date, mdoc->meta.os, mdoc->meta.vol);

/* Disable hyphenation and if nroff, disable justification. */

printf(".nh\n.if n .ad l");

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

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

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

*fontqueue.tail = 'R';

}

print_node(meta, n);

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

print_node(&mdoc->meta, n);

putchar('\n');

}

static void

print_node(DECL_ARGS)

{

const struct mdoc_node *sub;

const struct mdoc_man_act *act;

const struct manact *act;

struct roff_node *sub;

int cond, do_sub;

if (n->flags & NODE_NOPRT)

return;

* Break the line if we were parsed subsequent the current node.

* This makes the page structure be more consistent.

if (MMAN_spc & outflags && MDOC_LINE & n->flags)

if (MMAN_spc & outflags && NODE_LINE & n->flags)

outflags |= MMAN_nl;

act = NULL;

cond = 0;

do_sub = 1;

n->flags &= ~NODE_ENDED;

if (MDOC_TEXT == n->type) {

if (n->type == ROFFT_TEXT) {

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

* control character at the start of a line.

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

if (MMAN_nl & outflags &&

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

('.' == *n->string || '\'' == *n->string)) {

print_word("");

printf("\\&");

outflags &= ~MMAN_spc;

}

if (n->flags & NODE_DELIMC)

outflags &= ~(MMAN_spc | MMAN_spc_force);

else if (outflags & MMAN_Sm)

outflags |= MMAN_spc_force;

print_word(n->string);

if (n->flags & NODE_DELIMO)

outflags &= ~(MMAN_spc | MMAN_spc_force);

else if (outflags & MMAN_Sm)

outflags |= MMAN_spc;

} else if (n->tok < ROFF_MAX) {

(*roff_man_acts[n->tok])(meta, n);

return;

} else {

* Conditionally run the pre-node action handler for a

* node.

act = manacts + n->tok;

act = mdoc_man_act(n->tok);

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

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

if (cond && act->pre)

if (cond && act->pre != NULL &&

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

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

}

* Conditionally run all child nodes.

* Note that this iterates over children instead of using

* recursion. This prevents unnecessary depth in the stack.

Line 603 print_node(DECL_ARGS)

Line 713 print_node(DECL_ARGS)

* Lastly, conditionally run the post-node handler.

if (NODE_ENDED & n->flags)

return;

if (cond && act->post)

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

if (ENDBODY_NOT != n->end)

n->body->flags |= NODE_ENDED;

}

static int

cond_head(DECL_ARGS)

{

return(MDOC_HEAD == n->type);

return n->type == ROFFT_HEAD;

}

static int

cond_body(DECL_ARGS)

{

return(MDOC_BODY == n->type);

return n->type == ROFFT_BODY;

}

static int

Line 626 pre_enc(DECL_ARGS)

Line 742 pre_enc(DECL_ARGS)

{

const char *prefix;

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

prefix = mdoc_man_act(n->tok)->prefix;

if (NULL == prefix)

return(1);

return 1;

print_word(prefix);

outflags &= ~MMAN_spc;

return(1);

return 1;

}

static void

Line 639 post_enc(DECL_ARGS)

Line 755 post_enc(DECL_ARGS)

{

const char *suffix;

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

suffix = mdoc_man_act(n->tok)->suffix;

if (NULL == suffix)

return;

outflags &= ~MMAN_spc;

outflags &= ~(MMAN_spc | MMAN_nl);

print_word(suffix);

}

static int

pre_ex(DECL_ARGS)

{

outflags |= MMAN_br | MMAN_nl;

return 1;

}

static void

post_font(DECL_ARGS)

{

Line 657 static void

Line 780 static void

post_percent(DECL_ARGS)

{

if (pre_em == manacts[n->tok].pre)

if (mdoc_man_act(n->tok)->pre == pre_em)

font_pop();

if (n->next) {

print_word(",");

Line 674 static int

Line 797 static int

pre__t(DECL_ARGS)

{

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

if (n->parent->tok == MDOC_Rs && n->parent->norm->Rs.quote_T) {

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

print_word("\\(lq");

print_word("");

putchar('\"');

outflags &= ~MMAN_spc;

} else

font_push('I');

return(1);

return 1;

}

static void

post__t(DECL_ARGS)

{

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

if (n->parent->tok == MDOC_Rs && n->parent->norm->Rs.quote_T) {

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

outflags &= ~MMAN_spc;

print_word("");

print_word("\\(rq");

putchar('\"');

} else

font_pop();

post_percent(meta, n);

Line 705 static int

Line 824 static int

pre_sect(DECL_ARGS)

{

switch (n->type) {

if (n->type == ROFFT_HEAD) {

case (MDOC_HEAD):

outflags |= MMAN_sp;

print_block(manacts[n->tok].prefix, 0);

print_block(mdoc_man_act(n->tok)->prefix, 0);

print_word("");

putchar('\"');

outflags &= ~MMAN_spc;

break;

case (MDOC_BODY):

if (MDOC_Sh == n->tok) {

if (MDOC_SYNPRETTY & n->flags)

outflags |= MMAN_Bk;

else

outflags &= ~MMAN_Bk;

}

break;

default:

break;

}

return(1);

return 1;

}

Line 734 static void

Line 841 static void

post_sect(DECL_ARGS)

{

if (MDOC_HEAD != n->type)

if (n->type != ROFFT_HEAD)

return;

outflags &= ~MMAN_spc;

print_word("");

Line 746 post_sect(DECL_ARGS)

Line 853 post_sect(DECL_ARGS)

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

static void

pre_syn(const struct mdoc_node *n)

pre_syn(const struct roff_node *n)

{

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

if (NULL == n->prev || ! (NODE_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):

case MDOC_Fd:

/* FALLTHROUGH */

case MDOC_Fn:

case (MDOC_Fn):

case MDOC_Fo:

/* FALLTHROUGH */

case MDOC_In:

case (MDOC_Fo):

case MDOC_Vt:

/* FALLTHROUGH */

case (MDOC_In):

/* FALLTHROUGH */

case (MDOC_Vt):

outflags |= MMAN_sp;

break;

case (MDOC_Ft):

case MDOC_Ft:

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

outflags |= MMAN_sp;

break;

Line 789 pre_an(DECL_ARGS)

Line 892 pre_an(DECL_ARGS)

{

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

case (AUTH_split):

case AUTH_split:

outflags &= ~MMAN_An_nosplit;

outflags |= MMAN_An_split;

return(0);

return 0;

case (AUTH_nosplit):

case AUTH_nosplit:

outflags &= ~MMAN_An_split;

outflags |= MMAN_An_nosplit;

return(0);

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);

return 1;

}

Line 814 pre_ap(DECL_ARGS)

Line 917 pre_ap(DECL_ARGS)

outflags &= ~MMAN_spc;

print_word("'");

outflags &= ~MMAN_spc;

return(0);

return 0;

}

static int

pre_aq(DECL_ARGS)

{

print_word(n->child != NULL && n->child->next == NULL &&

n->child->tok == MDOC_Mt ? "<" : "\\(la");

outflags &= ~MMAN_spc;

return 1;

}

static void

post_aq(DECL_ARGS)

{

outflags &= ~(MMAN_spc | MMAN_nl);

print_word(n->child != NULL && n->child->next == NULL &&

n->child->tok == MDOC_Mt ? ">" : "\\(ra");

}

static int

pre_bd(DECL_ARGS)

{

Line 828 pre_bd(DECL_ARGS)

Line 950 pre_bd(DECL_ARGS)

print_line(".nf", 0);

if (0 == n->norm->Bd.comp && NULL != n->parent->prev)

outflags |= MMAN_sp;

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

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

return(1);

return 1;

}

static void

Line 852 pre_bf(DECL_ARGS)

Line 974 pre_bf(DECL_ARGS)

{

switch (n->type) {

case (MDOC_BLOCK):

case ROFFT_BLOCK:

return(1);

return 1;

case (MDOC_BODY):

case ROFFT_BODY:

break;

default:

return(0);

return 0;

}

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

case (FONT_Em):

case FONT_Em:

font_push('I');

break;

case (FONT_Sy):

case FONT_Sy:

font_push('B');

break;

default:

font_push('R');

break;

}

return(1);

return 1;

}

static void

post_bf(DECL_ARGS)

{

if (MDOC_BODY == n->type)

if (n->type == ROFFT_BODY)

font_pop();

}

static int

pre_bk(DECL_ARGS)

{

switch (n->type) {

case (MDOC_BLOCK):

case ROFFT_BLOCK:

return(1);

return 1;

case (MDOC_BODY):

case ROFFT_BODY:

case ROFFT_ELEM:

outflags |= MMAN_Bk;

return(1);

return 1;

default:

return(0);

return 0;

}

static void

post_bk(DECL_ARGS)

{

switch (n->type) {

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

case ROFFT_ELEM:

while ((n = n->parent) != NULL)

if (n->tok == MDOC_Bk)

return;

/* FALLTHROUGH */

case ROFFT_BODY:

outflags &= ~MMAN_Bk;

break;

default:

break;

}

static int

Line 915 pre_bl(DECL_ARGS)

Line 1046 pre_bl(DECL_ARGS)

* just nest and do not add up their indentation.

if (n->norm->Bl.offs) {

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

print_offs(n->norm->Bl.offs, 0);

Bl_stack[Bl_stack_len++] = 0;

}

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

case (LIST_enum):

case LIST_enum:

n->norm->Bl.count = 0;

return(1);

return 1;

case (LIST_column):

case LIST_column:

break;

default:

return(1);

return 1;

}

print_line(".TS", MMAN_nl);

if (n->child != NULL) {

for (icol = 0; icol < n->norm->Bl.ncols; icol++)

print_line(".TS", MMAN_nl);

print_word("l");

for (icol = 0; icol < n->norm->Bl.ncols; icol++)

print_word(".");

print_word("l");

print_word(".");

}

outflags |= MMAN_nl;

return(1);

return 1;

}

static void

Line 942 post_bl(DECL_ARGS)

Line 1075 post_bl(DECL_ARGS)

{

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

case (LIST_column):

case LIST_column:

print_line(".TE", 0);

if (n->child != NULL)

print_line(".TE", 0);

break;

case (LIST_enum):

case LIST_enum:

n->norm->Bl.count = 0;

break;

default:

Line 968 post_bl(DECL_ARGS)

Line 1102 post_bl(DECL_ARGS)

}

static int

static void

pre_br(DECL_ARGS)

{

outflags |= MMAN_br;

return(0);

}

static int

pre_bx(DECL_ARGS)

{

n = n->child;

if (n) {

print_word(n->string);

outflags &= ~MMAN_spc;

n = n->next;

}

print_word("BSD");

if (NULL == n)

return(0);

outflags &= ~MMAN_spc;

print_word("-");

outflags &= ~MMAN_spc;

print_word(n->string);

return(0);

}

static int

pre_dl(DECL_ARGS)

{

print_offs("6n");

print_offs("6n", 0);

return(1);

return 1;

}

static void

Line 1020 pre_em(DECL_ARGS)

Line 1132 pre_em(DECL_ARGS)

{

font_push('I');

return(1);

return 1;

}

static int

pre_en(DECL_ARGS)

{

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

NULL == n->norm->Es->child)

return 1;

print_word(n->norm->Es->child->string);

outflags &= ~MMAN_spc;

return 1;

}

static void

post_en(DECL_ARGS)

{

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

NULL == n->norm->Es->child ||

NULL == n->norm->Es->child->next)

return;

outflags &= ~MMAN_spc;

print_word(n->norm->Es->child->next->string);

return;

}

static int

pre_eo(DECL_ARGS)

{

if (n->end == ENDBODY_NOT &&

n->parent->head->child == NULL &&

n->child != NULL &&

n->child->end != ENDBODY_NOT)

print_word("\\&");

else if (n->end != ENDBODY_NOT ? n->child != NULL :

n->parent->head->child != NULL && (n->child != NULL ||

(n->parent->tail != NULL && n->parent->tail->child != NULL)))

outflags &= ~(MMAN_spc | MMAN_nl);

return 1;

}

static void

post_eo(DECL_ARGS)

{

int body, tail;

if (MDOC_HEAD == n->type || MDOC_BODY == n->type)

if (n->end != ENDBODY_NOT) {

outflags |= MMAN_spc;

return;

}

body = n->child != NULL || n->parent->head->child != NULL;

tail = n->parent->tail != NULL && n->parent->tail->child != NULL;

if (body && tail)

outflags &= ~MMAN_spc;

else if ( ! (body || tail))

print_word("\\&");

else if ( ! tail)

outflags |= MMAN_spc;

}

static int

pre_fa(DECL_ARGS)

{

int am_Fa;

if (MDOC_Fa == n->tok)

am_Fa = MDOC_Fa == n->tok;

if (am_Fa)

n = n->child;

while (NULL != n) {

font_push('I');

if (am_Fa || NODE_SYNPRETTY & n->flags)

outflags |= MMAN_nbrword;

print_node(meta, n);

font_pop();

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

print_word(",");

}

return(0);

return 0;

}

static void

Line 1062 pre_fd(DECL_ARGS)

Line 1235 pre_fd(DECL_ARGS)

pre_syn(n);

font_push('B');

return(1);

return 1;

}

static void

Line 1079 pre_fl(DECL_ARGS)

Line 1252 pre_fl(DECL_ARGS)

font_push('B');

print_word("\\-");

outflags &= ~MMAN_spc;

if (n->child != NULL)

return(1);

outflags &= ~MMAN_spc;

return 1;

}

static void

Line 1088 post_fl(DECL_ARGS)

Line 1262 post_fl(DECL_ARGS)

{

font_pop();

if (0 == n->nchild && NULL != n->next &&

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

n->next->line == n->line)

n->next == NULL ||

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

n->next->flags & NODE_LINE))

outflags &= ~MMAN_spc;

}

Line 1101 pre_fn(DECL_ARGS)

Line 1277 pre_fn(DECL_ARGS)

n = n->child;

if (NULL == n)

return(0);

return 0;

if (NODE_SYNPRETTY & n->flags)

print_block(".HP 4n", MMAN_nl);

font_push('B');

print_node(meta, n);

font_pop();

Line 1113 pre_fn(DECL_ARGS)

Line 1292 pre_fn(DECL_ARGS)

n = n->next;

if (NULL != n)

pre_fa(meta, n);

return(0);

return 0;

}

static void

Line 1121 post_fn(DECL_ARGS)

Line 1300 post_fn(DECL_ARGS)

{

print_word(")");

if (MDOC_SYNPRETTY & n->flags) {

if (NODE_SYNPRETTY & n->flags) {

print_word(";");

outflags |= MMAN_br;

outflags |= MMAN_PP;

}

Line 1132 pre_fo(DECL_ARGS)

Line 1311 pre_fo(DECL_ARGS)

{

switch (n->type) {

case (MDOC_BLOCK):

case ROFFT_BLOCK:

pre_syn(n);

break;

case (MDOC_HEAD):

case ROFFT_HEAD:

if (n->child == NULL)

return 0;

if (NODE_SYNPRETTY & n->flags)

print_block(".HP 4n", MMAN_nl);

font_push('B');

break;

case (MDOC_BODY):

case ROFFT_BODY:

outflags &= ~MMAN_spc;

outflags &= ~(MMAN_spc | MMAN_nl);

print_word("(");

outflags &= ~MMAN_spc;

break;

default:

break;

}

return(1);

return 1;

}

static void

post_fo(DECL_ARGS)

{

switch (n->type) {

case (MDOC_HEAD):

case ROFFT_HEAD:

font_pop();

if (n->child != NULL)

font_pop();

break;

case (MDOC_BODY):

case ROFFT_BODY:

post_fn(meta, n);

break;

default:

Line 1166 post_fo(DECL_ARGS)

Line 1350 post_fo(DECL_ARGS)

}

static int

pre_ft(DECL_ARGS)

pre_Ft(DECL_ARGS)

{

pre_syn(n);

font_push('I');

return(1);

return 1;

}

static void

pre_ft(DECL_ARGS)

{

print_line(".ft", 0);

print_word(n->child->string);

outflags |= MMAN_nl;

}

static int

pre_in(DECL_ARGS)

{

if (MDOC_SYNPRETTY & n->flags) {

if (NODE_SYNPRETTY & n->flags) {

pre_syn(n);

font_push('B');

print_word("#include <");

Line 1188 pre_in(DECL_ARGS)

Line 1380 pre_in(DECL_ARGS)

outflags &= ~MMAN_spc;

font_push('I');

}

return(1);

return 1;

}

static void

post_in(DECL_ARGS)

{

if (MDOC_SYNPRETTY & n->flags) {

if (NODE_SYNPRETTY & n->flags) {

outflags &= ~MMAN_spc;

print_word(">");

font_pop();

Line 1210 post_in(DECL_ARGS)

Line 1402 post_in(DECL_ARGS)

static int

pre_it(DECL_ARGS)

{

const struct mdoc_node *bln;

const struct roff_node *bln;

switch (n->type) {

case (MDOC_HEAD):

case ROFFT_HEAD:

outflags |= MMAN_PP | MMAN_nl;

bln = n->parent->parent;

if (0 == bln->norm->Bl.comp ||

Line 1222 pre_it(DECL_ARGS)

Line 1414 pre_it(DECL_ARGS)

outflags |= MMAN_sp;

outflags &= ~MMAN_br;

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

case (LIST_item):

case LIST_item:

return(0);

return 0;

case (LIST_inset):

case LIST_inset:

/* FALLTHROUGH */

case LIST_diag:

case (LIST_diag):

case LIST_ohang:

/* FALLTHROUGH */

case (LIST_ohang):

if (bln->norm->Bl.type == LIST_diag)

print_line(".B \"", 0);

else

print_line(".R \"", 0);

print_line(".BR \\& \"", 0);

outflags &= ~MMAN_spc;

return(1);

return 1;

case (LIST_bullet):

case LIST_bullet:

/* FALLTHROUGH */

case LIST_dash:

case (LIST_dash):

case LIST_hyphen:

/* FALLTHROUGH */

print_width(&bln->norm->Bl, NULL);

case (LIST_hyphen):

print_width(bln->norm->Bl.width, NULL, 0);

TPremain = 0;

outflags |= MMAN_nl;

font_push('B');

if (LIST_bullet == bln->norm->Bl.type)

print_word("o");

print_word("\\(bu");

else

print_word("-");

font_pop();

break;

outflags |= MMAN_nl;

case (LIST_enum):

return 0;

print_width(bln->norm->Bl.width, NULL, 0);

case LIST_enum:

print_width(&bln->norm->Bl, NULL);

TPremain = 0;

outflags |= MMAN_nl;

print_count(&bln->norm->Bl.count);

break;

outflags |= MMAN_nl;

case (LIST_hang):

return 0;

print_width(bln->norm->Bl.width, n->child, 6);

case LIST_hang:

print_width(&bln->norm->Bl, n->child);

TPremain = 0;

break;

outflags |= MMAN_nl;

case (LIST_tag):

return 1;

print_width(bln->norm->Bl.width, n->child, 0);

case LIST_tag:

print_width(&bln->norm->Bl, n->child);

putchar('\n');

outflags &= ~MMAN_spc;

return(1);

return 1;

default:

return(1);

return 1;

}

outflags |= MMAN_nl;

default:

break;

}

return(1);

return 1;

}

Line 1294 mid_it(void)

Line 1484 mid_it(void)

/* Restore the indentation of the enclosing list. */

print_line(".RS", MMAN_Bk_susp);

snprintf(buf, sizeof(buf), "%zun", Bl_stack[Bl_stack_len - 1]);

(void)snprintf(buf, sizeof(buf), "%dn",

Bl_stack[Bl_stack_len - 1]);

print_word(buf);

/* Remeber to close out this .RS block later. */

Line 1304 mid_it(void)

Line 1495 mid_it(void)

static void

post_it(DECL_ARGS)

{

const struct mdoc_node *bln;

const struct roff_node *bln;

bln = n->parent->parent;

switch (n->type) {

case (MDOC_HEAD):

case ROFFT_HEAD:

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

case (LIST_diag):

case LIST_diag:

outflags &= ~MMAN_spc;

print_word("\\ ");

break;

case (LIST_ohang):

case LIST_ohang:

outflags |= MMAN_br;

break;

default:

break;

}

break;

case (MDOC_BODY):

case ROFFT_BODY:

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

case (LIST_bullet):

case LIST_bullet:

/* FALLTHROUGH */

case LIST_dash:

case (LIST_dash):

case LIST_hyphen:

/* FALLTHROUGH */

case LIST_enum:

case (LIST_hyphen):

case LIST_hang:

/* FALLTHROUGH */

case LIST_tag:

case (LIST_enum):

/* FALLTHROUGH */

case (LIST_hang):

/* FALLTHROUGH */

case (LIST_tag):

assert(Bl_stack_len);

Bl_stack[--Bl_stack_len] = 0;

Line 1348 post_it(DECL_ARGS)

Line 1534 post_it(DECL_ARGS)

Bl_stack_post[Bl_stack_len] = 0;

}

break;

case (LIST_column):

case LIST_column:

if (NULL != n->next) {

putchar('\t');

outflags &= ~MMAN_spc;

Line 1374 post_lb(DECL_ARGS)

Line 1560 post_lb(DECL_ARGS)

static int

pre_lk(DECL_ARGS)

{

const struct mdoc_node *link, *descr;

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

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

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

return(0);

return 0;

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

/* Find beginning of trailing punctuation. */

punct = n->last;

while (punct != link && punct->flags & NODE_DELIMC)

punct = punct->prev;

punct = punct->next;

/* Link text. */

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

font_push('I');

while (NULL != descr) {

while (descr != punct) {

print_word(descr->string);

descr = descr->next;

}

print_word(":");

font_pop();

print_word(":");

}

/* Link target. */

font_push('B');

print_word(link->string);

font_pop();

return(0);

/* Trailing punctuation. */

while (punct != NULL) {

print_word(punct->string);

punct = punct->next;

}

return 0;

}

static void

pre_onearg(DECL_ARGS)

{

outflags |= MMAN_nl;

print_word(".");

outflags &= ~MMAN_spc;

print_word(roff_name[n->tok]);

if (n->child != NULL)

print_word(n->child->string);

outflags |= MMAN_nl;

if (n->tok == ROFF_ce)

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

print_node(meta, n);

}

static int

pre_li(DECL_ARGS)

{

font_push('R');

return(1);

return 1;

}

static int

Line 1408 pre_nm(DECL_ARGS)

Line 1623 pre_nm(DECL_ARGS)

{

char *name;

if (MDOC_BLOCK == n->type)

if (n->type == ROFFT_BLOCK) {

outflags |= MMAN_Bk;

pre_syn(n);

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

}

return(1);

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

name = n->child ? n->child->string : meta->name;

return 1;

name = n->child == NULL ? NULL : n->child->string;

if (NULL == name)

return(0);

return 0;

if (MDOC_HEAD == n->type) {

if (n->type == ROFFT_HEAD) {

if (NULL == n->parent->prev)

outflags |= MMAN_sp;

print_block(".HP", 0);

printf(" %zun", strlen(name) + 1);

printf(" %dn", man_strlen(name) + 1);

outflags |= MMAN_nl;

}

font_push('B');

if (NULL == n->child)

return 1;

print_word(meta->name);

return(1);

}

static void

post_nm(DECL_ARGS)

{

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

switch (n->type) {

return;

case ROFFT_BLOCK:

font_pop();

outflags &= ~MMAN_Bk;

break;

case ROFFT_HEAD:

case ROFFT_ELEM:

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

font_pop();

break;

default:

break;

}

static int

Line 1442 pre_no(DECL_ARGS)

Line 1666 pre_no(DECL_ARGS)

{

outflags |= MMAN_spc_force;

return(1);

return 1;

}

static int

Line 1450 pre_ns(DECL_ARGS)

Line 1674 pre_ns(DECL_ARGS)

{

outflags &= ~MMAN_spc;

return(0);

return 0;

}

static void

post_pf(DECL_ARGS)

{

outflags &= ~MMAN_spc;

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

outflags &= ~MMAN_spc;

}

static int

Line 1468 pre_pp(DECL_ARGS)

Line 1693 pre_pp(DECL_ARGS)

outflags |= MMAN_PP;

outflags |= MMAN_sp | MMAN_nl;

outflags &= ~MMAN_br;

return(0);

return 0;

}

static int

Line 1479 pre_rs(DECL_ARGS)

Line 1704 pre_rs(DECL_ARGS)

outflags |= MMAN_PP | MMAN_sp | MMAN_nl;

outflags &= ~MMAN_br;

}

return(1);

return 1;

}

static int

pre_skip(DECL_ARGS)

{

return 0;

}

static int

pre_sm(DECL_ARGS)

{

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

if (NULL == n->child)

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

outflags ^= MMAN_Sm;

outflags |= MMAN_Sm | MMAN_spc;

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

outflags |= MMAN_Sm;

else

outflags &= ~MMAN_Sm;

return(0);

if (MMAN_Sm & outflags)

outflags |= MMAN_spc;

return 0;

}

static int

static void

pre_sp(DECL_ARGS)

{

if (outflags & MMAN_PP) {

if (MMAN_PP & outflags) {

outflags &= ~MMAN_PP;

print_line(".PP", 0);

} else

} else {

print_line(".sp", 0);

return(1);

if (n->child != NULL)

}

print_word(n->child->string);

}

static void

post_sp(DECL_ARGS)

{

outflags |= MMAN_nl;

}

Line 1518 pre_sy(DECL_ARGS)

Line 1750 pre_sy(DECL_ARGS)

{

font_push('B');

return(1);

return 1;

}

static void

pre_ta(DECL_ARGS)

{

print_line(".ta", 0);

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

print_word(n->string);

outflags |= MMAN_nl;

}

static int

pre_vt(DECL_ARGS)

{

if (MDOC_SYNPRETTY & n->flags) {

if (NODE_SYNPRETTY & n->flags) {

switch (n->type) {

case (MDOC_BLOCK):

case ROFFT_BLOCK:

pre_syn(n);

return(1);

return 1;

case (MDOC_BODY):

case ROFFT_BODY:

break;

default:

return(0);

return 0;

}

font_push('I');

return(1);

return 1;

}

static void

post_vt(DECL_ARGS)

{

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

if (n->flags & NODE_SYNPRETTY && n->type != ROFFT_BODY)

return;

font_pop();

}

Line 1555 pre_xr(DECL_ARGS)

Line 1796 pre_xr(DECL_ARGS)

n = n->child;

if (NULL == n)

return(0);

return 0;

print_node(meta, n);

n = n->next;

if (NULL == n)

return(0);

return 0;

outflags &= ~MMAN_spc;

print_word("(");

print_node(meta, n);

print_word(")");

return(0);

return 0;

}

static int

pre_ux(DECL_ARGS)

{

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

if (NULL == n->child)

return(0);

outflags &= ~MMAN_spc;

print_word("\\ ");

outflags &= ~MMAN_spc;

return(1);

}

CVSweb