mandoc/term.c - diff

Return to term.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/term.c between version 1.14 and 1.45

version 1.14, 2009/02/24 14:52:55

version 1.45, 2009/03/08 13:57:07

Line 17

* PERFORMANCE OF THIS SOFTWARE.

#include <assert.h>

#include <ctype.h>

#include <err.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "term.h"

#define INDENT 4

* Performs actions on nodes of the abstract syntax tree. Both pre- and

* post-fix operations are defined here.

/* FIXME: indent/tab. */

/* FIXME: macro arguments can be escaped. */

/* FIXME: handle nested lists. */

#define TTYPE_PROG 0

#define TTYPE_CMD_FLAG 1

Line 48

#define TTYPE_CONFIG 13

#define TTYPE_CMD 14

#define TTYPE_INCLUDE 15

#define TTYPE_NMAX 16

#define TTYPE_SYMB 16

#define TTYPE_SYMBOL 17

#define TTYPE_DIAG 18

#define TTYPE_NMAX 19

* These define "styles" for element types, like command arguments or

Line 56

Line 59

* the same thing (like .Ex -std cmd and .Nm cmd).

/* TODO: abstract this into mdocterm.c. */

const int ttypes[TTYPE_NMAX] = {

TERMP_BOLD, /* TTYPE_PROG */

TERMP_BOLD, /* TTYPE_CMD_FLAG */

Line 72 const int ttypes[TTYPE_NMAX] = {

Line 77 const int ttypes[TTYPE_NMAX] = {

TERMP_UNDERLINE, /* TTYPE_EMPH */

TERMP_BOLD, /* TTYPE_CONFIG */

TERMP_BOLD, /* TTYPE_CMD */

TERMP_BOLD /* TTYPE_INCLUDE */

TERMP_BOLD, /* TTYPE_INCLUDE */

TERMP_BOLD, /* TTYPE_SYMB */

TERMP_BOLD, /* TTYPE_SYMBOL */

TERMP_BOLD /* TTYPE_DIAG */

};

static int arg_hasattr(int, size_t,

static int arg_hasattr(int, const struct mdoc_node *);

const struct mdoc_arg *);

static int arg_getattr(int, const struct mdoc_node *);

static int arg_getattr(int, size_t,

static size_t arg_offset(const struct mdoc_argv *);

const struct mdoc_arg *);

static size_t arg_width(const struct mdoc_argv *);

static size_t arg_offset(const struct mdoc_arg *);

static int arg_listtype(const struct mdoc_node *);

static size_t arg_width(const struct mdoc_arg *);

* What follows describes prefix and postfix operations for the abstract

Line 89 static size_t arg_width(const struct mdoc_arg *);

Line 96 static size_t arg_width(const struct mdoc_arg *);

#define DECL_ARGS \

struct termp *p, \

struct termpair *pair, \

const struct mdoc_meta *meta, \

const struct mdoc_node *node

Line 100 static void name##_post(DECL_ARGS)

Line 108 static void name##_post(DECL_ARGS)

DECL_PRE(name); \

DECL_POST(name);

DECL_PREPOST(termp__t);

DECL_PREPOST(termp_aq);

DECL_PREPOST(termp_ar);

DECL_PREPOST(termp_bd);

DECL_PREPOST(termp_cd);

DECL_PREPOST(termp_bq);

DECL_PREPOST(termp_cm);

DECL_PREPOST(termp_d1);

DECL_PREPOST(termp_dq);

DECL_PREPOST(termp_em);

DECL_PREPOST(termp_fa);

DECL_PREPOST(termp_fd);

DECL_PREPOST(termp_fl);

DECL_PREPOST(termp_fn);

DECL_PREPOST(termp_fo);

DECL_PREPOST(termp_ft);

DECL_PREPOST(termp_ic);

DECL_PREPOST(termp_in);

DECL_PREPOST(termp_it);

DECL_PREPOST(termp_nm);

DECL_PREPOST(termp_op);

DECL_PREPOST(termp_pa);

DECL_PREPOST(termp_pf);

DECL_PREPOST(termp_qo);

DECL_PREPOST(termp_pq);

DECL_PREPOST(termp_qq);

DECL_PREPOST(termp_sh);

DECL_PREPOST(termp_ss);

DECL_PREPOST(termp_sq);

DECL_PREPOST(termp_sx);

DECL_PREPOST(termp_va);

DECL_PREPOST(termp_vt);

DECL_PRE(termp_ar);

DECL_PRE(termp_at);

DECL_PRE(termp_bx);

DECL_PRE(termp_bf);

DECL_PRE(termp_bsx);

DECL_PRE(termp_bt);

DECL_PRE(termp_cd);

DECL_PRE(termp_cm);

DECL_PRE(termp_em);

DECL_PRE(termp_ex);

DECL_PRE(termp_fa);

DECL_PRE(termp_fl);

DECL_PRE(termp_fx);

DECL_PRE(termp_ic);

DECL_PRE(termp_ms);

DECL_PRE(termp_nd);

DECL_PRE(termp_nm);

DECL_PRE(termp_ns);

DECL_PRE(termp_nx);

DECL_PRE(termp_ox);

DECL_PRE(termp_pa);

DECL_PRE(termp_pp);

DECL_PRE(termp_rs);

DECL_PRE(termp_rv);

DECL_PRE(termp_sm);

DECL_PRE(termp_st);

DECL_PRE(termp_sx);

DECL_PRE(termp_sy);

DECL_PRE(termp_ud);

DECL_PRE(termp_ux);

DECL_PRE(termp_va);

DECL_PRE(termp_xr);

DECL_POST(termp___);

DECL_POST(termp_bl);

DECL_POST(termp_bx);

DECL_POST(termp_lb);

const struct termact __termacts[MDOC_MAX] = {

{ NULL, NULL }, /* \" */

Line 153 const struct termact __termacts[MDOC_MAX] = {

Line 175 const struct termact __termacts[MDOC_MAX] = {

{ termp_ss_pre, termp_ss_post }, /* Ss */

{ termp_pp_pre, NULL }, /* Pp */

{ termp_d1_pre, termp_d1_post }, /* D1 */

{ NULL, NULL }, /* Dl */

{ termp_d1_pre, termp_d1_post }, /* Dl */

{ termp_bd_pre, termp_bd_post }, /* Bd */

{ NULL, NULL }, /* Ed */

{ NULL, termp_bl_post }, /* Bl */

Line 161 const struct termact __termacts[MDOC_MAX] = {

Line 183 const struct termact __termacts[MDOC_MAX] = {

{ termp_it_pre, termp_it_post }, /* It */

{ NULL, NULL }, /* Ad */

{ NULL, NULL }, /* An */

{ termp_ar_pre, termp_ar_post }, /* Ar */

{ termp_ar_pre, NULL }, /* Ar */

{ termp_cd_pre, termp_cd_post }, /* Cd */

{ termp_cd_pre, NULL }, /* Cd */

{ termp_cm_pre, termp_cm_post }, /* Cm */

{ termp_cm_pre, NULL }, /* Cm */

{ NULL, NULL }, /* Dv */

{ NULL, NULL }, /* Er */

{ NULL, NULL }, /* Ev */

{ termp_ex_pre, NULL }, /* Ex */

{ termp_fa_pre, termp_fa_post }, /* Fa */

{ termp_fa_pre, NULL }, /* Fa */

{ termp_fd_pre, termp_fd_post }, /* Fd */

{ termp_fl_pre, termp_fl_post }, /* Fl */

{ termp_fl_pre, NULL }, /* Fl */

{ termp_fn_pre, termp_fn_post }, /* Fn */

{ termp_ft_pre, termp_ft_post }, /* Ft */

{ termp_ic_pre, termp_ic_post }, /* Ic */

{ termp_ic_pre, NULL }, /* Ic */

{ termp_in_pre, termp_in_post }, /* In */

{ NULL, NULL }, /* Li */

{ termp_nd_pre, NULL }, /* Nd */

{ termp_nm_pre, termp_nm_post }, /* Nm */

{ termp_nm_pre, NULL }, /* Nm */

{ termp_op_pre, termp_op_post }, /* Op */

{ NULL, NULL }, /* Ot */

{ termp_pa_pre, termp_pa_post }, /* Pa */

{ termp_pa_pre, NULL }, /* Pa */

{ termp_rv_pre, NULL }, /* Rv */

{ termp_st_pre, NULL }, /* St */

{ termp_va_pre, termp_va_post }, /* Va */

{ termp_va_pre, NULL }, /* Va */

{ termp_vt_pre, termp_vt_post }, /* Vt */

{ termp_xr_pre, NULL }, /* Xr */

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

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

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

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

{ NULL, NULL }, /* %D */

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

{ NULL, NULL }, /* %I */

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

{ NULL, NULL }, /* %J */

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

{ NULL, NULL }, /* %N */

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

{ NULL, NULL }, /* %O */

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

{ NULL, NULL }, /* %P */

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

{ NULL, NULL }, /* %R */

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

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

{ termp__t_pre, termp__t_post }, /* %T */

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

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

{ NULL, NULL }, /* Ac */

{ termp_aq_pre, termp_aq_post }, /* Ao */

{ termp_aq_pre, termp_aq_post }, /* Aq */

{ termp_at_pre, NULL }, /* At */

{ NULL, NULL }, /* Bc */

{ NULL, NULL }, /* Bf */

{ termp_bf_pre, NULL }, /* Bf */

{ NULL, NULL }, /* Bo */

{ termp_bq_pre, termp_bq_post }, /* Bo */

{ NULL, NULL }, /* Bq */

{ termp_bq_pre, termp_bq_post }, /* Bq */

{ NULL, NULL }, /* Bsx */

{ termp_bsx_pre, NULL }, /* Bsx */

{ termp_bx_pre, NULL }, /* Bx */

{ NULL, termp_bx_post }, /* Bx */

{ NULL, NULL }, /* Db */

{ NULL, NULL }, /* Dc */

{ NULL, NULL }, /* Do */

{ termp_dq_pre, termp_dq_post }, /* Do */

{ termp_dq_pre, termp_dq_post }, /* Dq */

{ NULL, NULL }, /* Ec */

{ NULL, NULL }, /* Ef */

{ termp_em_pre, termp_em_post }, /* Em */

{ termp_em_pre, NULL }, /* Em */

{ NULL, NULL }, /* Eo */

{ NULL, NULL }, /* Fx */

{ termp_fx_pre, NULL }, /* Fx */

{ NULL, NULL }, /* Ms */

{ termp_ms_pre, NULL }, /* Ms */

{ NULL, NULL }, /* No */

{ termp_ns_pre, NULL }, /* Ns */

{ termp_nx_pre, NULL }, /* Nx */

{ termp_ox_pre, NULL }, /* Ox */

{ NULL, NULL }, /* Pc */

{ termp_pf_pre, termp_pf_post }, /* Pf */

{ NULL, NULL }, /* Po */

{ termp_pq_pre, termp_pq_post }, /* Po */

{ NULL, NULL }, /* Pq */

{ termp_pq_pre, termp_pq_post }, /* Pq */

{ NULL, NULL }, /* Qc */

{ NULL, NULL }, /* Ql */

{ termp_sq_pre, termp_sq_post }, /* Ql */

{ termp_qo_pre, termp_qo_post }, /* Qo */

{ termp_qq_pre, termp_qq_post }, /* Qo */

{ termp_qq_pre, termp_qq_post }, /* Qq */

{ NULL, NULL }, /* Re */

{ NULL, NULL }, /* Rs */

{ termp_rs_pre, NULL }, /* Rs */

{ NULL, NULL }, /* Sc */

{ NULL, NULL }, /* So */

{ termp_sq_pre, termp_sq_post }, /* So */

{ termp_sq_pre, termp_sq_post }, /* Sq */

{ NULL, NULL }, /* Sm */

{ termp_sm_pre, NULL }, /* Sm */

{ termp_sx_pre, termp_sx_post }, /* Sx */

{ termp_sx_pre, NULL }, /* Sx */

{ NULL, NULL }, /* Sy */

{ termp_sy_pre, NULL }, /* Sy */

{ NULL, NULL }, /* Tn */

{ NULL, NULL }, /* Ux */

{ termp_ux_pre, NULL }, /* Ux */

{ NULL, NULL }, /* Xc */

{ NULL, NULL }, /* Xo */

{ NULL, NULL }, /* Fo */

{ termp_fo_pre, termp_fo_post }, /* Fo */

{ NULL, NULL }, /* Fc */

{ NULL, NULL }, /* Oo */

{ termp_op_pre, termp_op_post }, /* Oo */

{ NULL, NULL }, /* Oc */

{ NULL, NULL }, /* Bk */

{ NULL, NULL }, /* Ek */

{ NULL, NULL }, /* Bt */

{ termp_bt_pre, NULL }, /* Bt */

{ NULL, NULL }, /* Hf */

{ NULL, NULL }, /* Fr */

{ termp_ud_pre, NULL }, /* Ud */

{ NULL, termp_lb_post }, /* lb */

};

const struct termact *termacts = __termacts;

static size_t

arg_width(const struct mdoc_arg *arg)

arg_width(const struct mdoc_argv *arg)

{

size_t v;

int i, len;

/* TODO */

assert(*arg->value);

return(strlen(*arg->value));

if (0 == strcmp(*arg->value, "indent"))

return(INDENT);

if (0 == strcmp(*arg->value, "indent-two"))

return(INDENT * 2);

len = (int)strlen(*arg->value);

assert(len > 0);

for (i = 0; i < len - 1; i++)

if ( ! isdigit((u_char)(*arg->value)[i]))

break;

if (i == len - 1) {

if ('n' == (*arg->value)[len - 1]) {

v = (size_t)atoi(*arg->value);

return(v);

}

return(strlen(*arg->value) + 1);

}

static int

arg_listtype(const struct mdoc_node *n)

{

int i, len;

assert(MDOC_BLOCK == n->type);

len = n->args ? n->args->argc : 0;

for (i = 0; i < len; i++)

switch (n->args->argv[i].arg) {

case (MDOC_Bullet):

/* FALLTHROUGH */

case (MDOC_Dash):

/* FALLTHROUGH */

case (MDOC_Enum):

/* FALLTHROUGH */

case (MDOC_Hyphen):

/* FALLTHROUGH */

case (MDOC_Tag):

/* FALLTHROUGH */

case (MDOC_Inset):

/* FALLTHROUGH */

case (MDOC_Diag):

/* FALLTHROUGH */

case (MDOC_Item):

/* FALLTHROUGH */

case (MDOC_Ohang):

return(n->args->argv[i].arg);

default:

break;

}

errx(1, "list type not supported");

/* NOTREACHED */

}

static size_t

arg_offset(const struct mdoc_arg *arg)

arg_offset(const struct mdoc_argv *arg)

{

/* TODO */

Line 276 arg_offset(const struct mdoc_arg *arg)

Line 357 arg_offset(const struct mdoc_arg *arg)

return(INDENT);

if (0 == strcmp(*arg->value, "indent-two"))

return(INDENT * 2);

return(strlen(*arg->value));

}

static int

arg_hasattr(int arg, size_t argc, const struct mdoc_arg *argv)

arg_hasattr(int arg, const struct mdoc_node *n)

{

return(-1 != arg_getattr(arg, argc, argv));

return(-1 != arg_getattr(arg, n));

}

static int

arg_getattr(int arg, size_t argc, const struct mdoc_arg *argv)

arg_getattr(int arg, const struct mdoc_node *n)

{

int i;

for (i = 0; i < (int)argc; i++)

if (NULL == n->args)

if (argv[i].arg == arg)

return(-1);

for (i = 0; i < (int)n->args->argc; i++)

if (n->args->argv[i].arg == arg)

return(i);

return(-1);

}

Line 329 termp_dq_post(DECL_ARGS)

Line 411 termp_dq_post(DECL_ARGS)

/* ARGSUSED */

static void

static int

termp_it_post(DECL_ARGS)

termp_it_pre_block(DECL_ARGS)

{

const struct mdoc_node *n, *it;

const struct mdoc_block *bl;

int i;

size_t width, offset;

newln(p);

* This (and termp_it_pre()) are the most complicated functions

if ( ! arg_hasattr(MDOC_Compact, node->parent->parent))

* here. They must account for a considerable number of

if (node->prev || node->parent->parent->prev)

* switches that completely change the output behaviour, like

vspace(p);

* -tag versus -column. Yech.

switch (node->type) {

return(1);

case (MDOC_BODY):

}

/* FALLTHROUGH */

case (MDOC_HEAD):

break;

default:

return;

}

it = node->parent;

assert(MDOC_BLOCK == it->type);

assert(MDOC_It == it->tok);

n = it->parent;

/* ARGSUSED */

assert(MDOC_BODY == n->type);

static int

assert(MDOC_Bl == n->tok);

termp_it_pre(DECL_ARGS)

n = n->parent;

{

bl = &n->data.block;

const struct mdoc_node *bl;

char buf[7];

int i, type;

size_t width, offset;

/* If `-tag', adjust our margins accordingly. */

if (MDOC_BLOCK == node->type)

return(termp_it_pre_block(p, pair, meta, node));

if (arg_hasattr(MDOC_Tag, bl->argc, bl->argv)) {

/* Get ptr to list block, type, etc. */

flushln(p);

/* FIXME: this should auto-size. */

bl = node->parent->parent->parent;

i = arg_getattr(MDOC_Width, bl->argc, bl->argv);

type = arg_listtype(bl);

width = i >= 0 ? arg_width(&bl->argv[i]) : 10;

/* FIXME: nesting! Should happen at block. */

/* Save parent attributes. */

i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);

offset = i >= 0 ? arg_width(&bl->argv[i]) : 0;

if (MDOC_HEAD == node->type) {

pair->offset = p->offset;

p->rmargin = p->maxrmargin;

pair->rmargin = p->rmargin;

p->offset -= offset;

pair->flag = p->flags;

p->flags &= ~TERMP_NOBREAK;

} else {

p->offset -= width;

p->flags &= ~TERMP_NOLPAD;

}

if (arg_hasattr(MDOC_Ohang, bl->argc, bl->argv)) {

/* Get list width and offset. */

i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);

offset = i >= 0 ? arg_offset(&bl->argv[i]) : 0;

flushln(p);

i = arg_getattr(MDOC_Width, bl);

p->offset -= offset;

width = i >= 0 ? arg_width(&bl->args->argv[i]) : 0;

return;

}

i = arg_getattr(MDOC_Offset, bl);

offset = i >= 0 ? arg_offset(&bl->args->argv[i]) : 0;

/* ARGSUSED */

static int

* List-type can override the width in the case of fixed-head

termp_it_pre(DECL_ARGS)

* values (bullet, dash/hyphen, enum). Tags need a non-zero

{

* offset.

const struct mdoc_node *n, *it;

const struct mdoc_block *bl;

int i;

size_t width, offset;

* Also see termp_it_post() for general comments.

switch (node->type) {

switch (type) {

case (MDOC_BODY):

case (MDOC_Bullet):

/* FALLTHROUGH */

case (MDOC_HEAD):

case (MDOC_Dash):

it = node->parent;

/* FALLTHROUGH */

case (MDOC_Enum):

/* FALLTHROUGH */

case (MDOC_Hyphen):

width = width > 4 ? width : 4;

break;

case (MDOC_BLOCK):

case (MDOC_Tag):

it = node;

if (width)

break;

errx(1, "need non-zero %s for list type",

mdoc_argnames[MDOC_Width]);

default:

return(1);

break;

}

assert(MDOC_BLOCK == it->type);

assert(MDOC_It == it->tok);

* Whitespace control. Inset bodies need an initial space.

n = it->parent;

switch (type) {

assert(MDOC_BODY == n->type);

case (MDOC_Diag):

assert(MDOC_Bl == n->tok);

/* FALLTHROUGH */

n = n->parent;

case (MDOC_Inset):

bl = &n->data.block;

if (MDOC_BODY == node->type)

p->flags &= ~TERMP_NOSPACE;

/* If `-compact', don't assert vertical space. */

if (MDOC_BLOCK == node->type) {

if (arg_hasattr(MDOC_Compact, bl->argc, bl->argv))

newln(p);

else

vspace(p);

p->flags |= TERMP_NOSPACE;

return(1);

break;

default:

p->flags |= TERMP_NOSPACE;

break;

}

assert(MDOC_HEAD == node->type

|| MDOC_BODY == node->type);

* Style flags. Diagnostic heads need TTYPE_DIAG.

/* FIXME: see termp_it_post(). */

switch (type) {

case (MDOC_Diag):

if (MDOC_HEAD == node->type)

p->flags |= ttypes[TTYPE_DIAG];

break;

default:

break;

}

/* If `-tag', adjust our margins accordingly. */

* Pad and break control. This is the tricker part. Lists with

* set right-margins for the head get TERMP_NOBREAK because, if

* they overrun the margin, they wrap to the new margin.

* Correspondingly, the body for these types don't left-pad, as

* the head will pad out to to the right.

if (arg_hasattr(MDOC_Tag, bl->argc, bl->argv)) {

switch (type) {

p->flags |= TERMP_NOSPACE;

case (MDOC_Bullet):

/* FALLTHROUGH */

case (MDOC_Dash):

/* FALLTHROUGH */

case (MDOC_Enum):

/* FALLTHROUGH */

case (MDOC_Hyphen):

/* FALLTHROUGH */

case (MDOC_Tag):

if (MDOC_HEAD == node->type)

p->flags |= TERMP_NOBREAK;

else

p->flags |= TERMP_NOLPAD;

if (MDOC_HEAD == node->type && MDOC_Tag == type)

if (NULL == node->next ||

NULL == node->next->child)

p->flags |= TERMP_NONOBREAK;

break;

case (MDOC_Diag):

if (MDOC_HEAD == node->type)

p->flags |= TERMP_NOBREAK;

break;

default:

break;

}

i = arg_getattr(MDOC_Width, bl->argc, bl->argv);

width = i >= 0 ? arg_width(&bl->argv[i]) : 10;

* Margin control. Set-head-width lists have their right

* margins shortened. The body for these lists has the offset

* necessarily lengthened. Everybody gets the offset.

i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);

p->offset += offset;

offset = i >= 0 ? arg_offset(&bl->argv[i]) : 0;

if (MDOC_HEAD == node->type) {

switch (type) {

p->flags |= TERMP_NOBREAK;

case (MDOC_Bullet):

p->offset += offset;

/* FALLTHROUGH */

case (MDOC_Dash):

/* FALLTHROUGH */

case (MDOC_Enum):

/* FALLTHROUGH */

case (MDOC_Hyphen):

/* FALLTHROUGH */

case (MDOC_Tag):

if (MDOC_HEAD == node->type)

p->rmargin = p->offset + width;

} else {

else

p->flags |= TERMP_NOSPACE;

p->flags |= TERMP_NOLPAD;

p->offset += width;

}

/* FALLTHROUGH */

return(1);

default:

break;

}

/* If `-ohang', adjust left-margin. */

* The dash, hyphen, bullet and enum lists all have a special

* HEAD character. Print it now.

if (arg_hasattr(MDOC_Ohang, bl->argc, bl->argv)) {

if (MDOC_HEAD == node->type)

i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);

switch (type) {

offset = i >= 0 ? arg_offset(&bl->argv[i]) : 0;

case (MDOC_Bullet):

word(p, "\\[bu]");

break;

case (MDOC_Dash):

/* FALLTHROUGH */

case (MDOC_Hyphen):

word(p, "\\-");

break;

case (MDOC_Enum):

/* TODO: have a wordfmt or something. */

(pair->ppair->ppair->count)++;

(void)snprintf(buf, sizeof(buf), "%d.",

pair->ppair->ppair->count);

word(p, buf);

break;

default:

break;

}

p->flags |= TERMP_NOSPACE;

p->offset += offset;

* If we're not going to process our header children, indicate

return(1);

* so here.

if (MDOC_HEAD == node->type)

switch (type) {

case (MDOC_Bullet):

/* FALLTHROUGH */

case (MDOC_Item):

/* FALLTHROUGH */

case (MDOC_Dash):

/* FALLTHROUGH */

case (MDOC_Hyphen):

/* FALLTHROUGH */

case (MDOC_Enum):

return(0);

default:

break;

}

return(1);

Line 487 termp_it_pre(DECL_ARGS)

Line 626 termp_it_pre(DECL_ARGS)

/* ARGSUSED */

static void

termp_nm_post(DECL_ARGS)

termp_it_post(DECL_ARGS)

{

int type;

p->flags &= ~ttypes[TTYPE_PROG];

if (MDOC_BODY != node->type && MDOC_HEAD != node->type)

return;

type = arg_listtype(node->parent->parent->parent);

switch (type) {

case (MDOC_Diag):

/* FALLTHROUGH */

case (MDOC_Item):

/* FALLTHROUGH */

case (MDOC_Inset):

if (MDOC_BODY != node->type)

break;

flushln(p);

break;

default:

flushln(p);

break;

}

p->offset = pair->offset;

p->rmargin = pair->rmargin;

p->flags = pair->flag;

}

/* ARGSUSED */

static void

static int

termp_fl_post(DECL_ARGS)

termp_nm_pre(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_CMD_FLAG];

if (SEC_SYNOPSIS == node->sec)

newln(p);

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_PROG]);

if (NULL == node->child)

word(p, meta->name);

return(1);

}

/* ARGSUSED */

static int

termp_ar_pre(DECL_ARGS)

termp_fl_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_CMD_ARG];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_FLAG]);

if (NULL == node->child)

word(p, "\\-");

word(p, "...");

p->flags |= TERMP_NOSPACE;

return(1);

}

/* ARGSUSED */

static int

termp_nm_pre(DECL_ARGS)

termp_ar_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_PROG];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_ARG]);

if (NULL == node->child)

word(p, meta->name);

return(1);

}

Line 548 termp_pp_pre(DECL_ARGS)

Line 715 termp_pp_pre(DECL_ARGS)

/* ARGSUSED */

static void

static int

termp_ar_post(DECL_ARGS)

termp_st_pre(DECL_ARGS)

{

const char *cp;

p->flags &= ~ttypes[TTYPE_CMD_ARG];

if (node->child) {

if (MDOC_TEXT != node->child->type)

errx(1, "expected text line arguments");

if ((cp = mdoc_a2st(node->child->string)))

word(p, cp);

}

return(0);

}

/* ARGSUSED */

static int

termp_st_pre(DECL_ARGS)

termp_rs_pre(DECL_ARGS)

{

const char *tp;

assert(1 == node->data.elem.argc);

if (MDOC_BLOCK == node->type && node->prev)

vspace(p);

tp = mdoc_st2a(node->data.elem.argv[0].arg);

word(p, tp);

return(1);

}

Line 577 termp_rv_pre(DECL_ARGS)

Line 747 termp_rv_pre(DECL_ARGS)

{

int i;

i = arg_getattr(MDOC_Std, node->data.elem.argc,

if (-1 == (i = arg_getattr(MDOC_Std, node)))

node->data.elem.argv);

errx(1, "expected -std argument");

assert(i >= 0);

if (1 != node->args->argv[i].sz)

errx(1, "expected -std argument");

newln(p);

word(p, "The");

p->flags |= ttypes[TTYPE_FUNC_NAME];

word(p, *node->data.elem.argv[i].value);

word(p, *node->args->argv[i].value);

p->flags &= ~ttypes[TTYPE_FUNC_NAME];

word(p, "() function returns the value 0 if successful;");

Line 608 termp_ex_pre(DECL_ARGS)

Line 779 termp_ex_pre(DECL_ARGS)

{

int i;

i = arg_getattr(MDOC_Std, node->data.elem.argc,

if (-1 == (i = arg_getattr(MDOC_Std, node)))

node->data.elem.argv);

errx(1, "expected -std argument");

assert(i >= 0);

if (1 != node->args->argv[i].sz)

errx(1, "expected -std argument");

word(p, "The");

p->flags |= ttypes[TTYPE_PROG];

word(p, *node->data.elem.argv[i].value);

word(p, *node->args->argv[i].value);

p->flags &= ~ttypes[TTYPE_PROG];

word(p, "utility exits 0 on success, and >0 if an error occurs.");

Line 655 termp_op_post(DECL_ARGS)

Line 827 termp_op_post(DECL_ARGS)

/* ARGSUSED */

static void

termp_sh_post(DECL_ARGS)

{

switch (node->type) {

case (MDOC_HEAD):

p->flags &= ~ttypes[TTYPE_SECTION];

newln(p);

break;

case (MDOC_BODY):

newln(p);

p->offset = 0;

break;

default:

break;

}

/* ARGSUSED */

static int

termp_xr_pre(DECL_ARGS)

{

const struct mdoc_node *n;

n = node->child;

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

assert(n);

errx(1, "expected text line argument");

if (MDOC_TEXT != n->type)

errx(1, "expected text line argument");

assert(MDOC_TEXT == n->type);

word(p, n->string);

word(p, n->data.text.string);

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

return(0);

if (MDOC_TEXT != n->type)

errx(1, "expected text line argument");

assert(MDOC_TEXT == n->type);

p->flags |= TERMP_NOSPACE;

word(p, "(");

p->flags |= TERMP_NOSPACE;

word(p, n->data.text.string);

word(p, n->string);

p->flags |= TERMP_NOSPACE;

word(p, ")");

Line 707 termp_vt_pre(DECL_ARGS)

Line 861 termp_vt_pre(DECL_ARGS)

{

/* FIXME: this can be "type name". */

p->flags |= ttypes[TTYPE_VAR_DECL];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_VAR_DECL]);

return(1);

}

Line 717 static void

Line 871 static void

termp_vt_post(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_VAR_DECL];

if (node->sec == SEC_SYNOPSIS)

vspace(p);

}

Line 732 termp_fd_pre(DECL_ARGS)

Line 885 termp_fd_pre(DECL_ARGS)

* FIXME: this naming is bad. This value is used, in general,

* for the #include header or other preprocessor statement.

p->flags |= ttypes[TTYPE_FUNC_DECL];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_DECL]);

return(1);

}

Line 742 static void

Line 895 static void

termp_fd_post(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_FUNC_DECL];

if (node->sec != SEC_SYNOPSIS)

if (node->sec == SEC_SYNOPSIS)

return;

newln(p);

if (node->next && MDOC_Fd != node->next->tok)

vspace(p);

}

Line 757 termp_sh_pre(DECL_ARGS)

Line 911 termp_sh_pre(DECL_ARGS)

switch (node->type) {

case (MDOC_HEAD):

vspace(p);

p->flags |= ttypes[TTYPE_SECTION];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SECTION]);

break;

case (MDOC_BODY):

p->offset = INDENT;

Line 770 termp_sh_pre(DECL_ARGS)

Line 924 termp_sh_pre(DECL_ARGS)

/* ARGSUSED */

static void

termp_sh_post(DECL_ARGS)

{

switch (node->type) {

case (MDOC_HEAD):

newln(p);

break;

case (MDOC_BODY):

newln(p);

p->offset = 0;

break;

default:

break;

}

/* ARGSUSED */

static int

termp_op_pre(DECL_ARGS)

{

Line 788 termp_op_pre(DECL_ARGS)

Line 961 termp_op_pre(DECL_ARGS)

/* ARGSUSED */

static int

termp_ud_pre(DECL_ARGS)

termp_bt_pre(DECL_ARGS)

{

word(p, "currently under development.");

word(p, "is currently in beta test.");

return(1);

}

/* ARGSUSED */

static void

termp_lb_post(DECL_ARGS)

{

newln(p);

}

/* ARGSUSED */

static int

termp_fl_pre(DECL_ARGS)

termp_ud_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_CMD_FLAG];

word(p, "currently under development.");

word(p, "\\-");

p->flags |= TERMP_NOSPACE;

return(1);

}

Line 816 termp_d1_pre(DECL_ARGS)

Line 996 termp_d1_pre(DECL_ARGS)

if (MDOC_BODY != node->type)

return(1);

newln(p);

p->offset += INDENT;

p->offset += (pair->offset = INDENT);

return(1);

}

Line 829 termp_d1_post(DECL_ARGS)

Line 1009 termp_d1_post(DECL_ARGS)

if (MDOC_BODY != node->type)

return;

newln(p);

p->offset -= INDENT;

p->offset -= pair->offset;

}

Line 840 termp_aq_pre(DECL_ARGS)

Line 1020 termp_aq_pre(DECL_ARGS)

if (MDOC_BODY != node->type)

return(1);

word(p, "<");

word(p, "\\(la");

p->flags |= TERMP_NOSPACE;

return(1);

}

Line 854 termp_aq_post(DECL_ARGS)

Line 1034 termp_aq_post(DECL_ARGS)

if (MDOC_BODY != node->type)

return;

p->flags |= TERMP_NOSPACE;

word(p, ">");

word(p, "\\(ra");

}

Line 863 static int

Line 1043 static int

termp_ft_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_FUNC_TYPE];

if (SEC_SYNOPSIS == node->sec)

if (node->prev && MDOC_Fo == node->prev->tok)

vspace(p);

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_TYPE]);

return(1);

}

Line 873 static void

Line 1056 static void

termp_ft_post(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_FUNC_TYPE];

if (SEC_SYNOPSIS == node->sec)

if (node->sec == SEC_SYNOPSIS)

newln(p);

}

Line 886 termp_fn_pre(DECL_ARGS)

Line 1067 termp_fn_pre(DECL_ARGS)

{

const struct mdoc_node *n;

assert(node->child);

if (NULL == node->child)

assert(MDOC_TEXT == node->child->type);

errx(1, "expected text line arguments");

if (MDOC_TEXT != node->child->type)

errx(1, "expected text line arguments");

/* FIXME: can be "type funcname" "type varname"... */

p->flags |= ttypes[TTYPE_FUNC_NAME];

word(p, node->child->data.text.string);

word(p, node->child->string);

p->flags &= ~ttypes[TTYPE_FUNC_NAME];

p->flags |= TERMP_NOSPACE;

word(p, "(");

p->flags |= TERMP_NOSPACE;

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

assert(MDOC_TEXT == n->type);

if (MDOC_TEXT != n->type)

errx(1, "expected text line arguments");

p->flags |= ttypes[TTYPE_FUNC_ARG];

word(p, n->data.text.string);

word(p, n->string);

p->flags &= ~ttypes[TTYPE_FUNC_ARG];

if ((n->next))

if (n->next)

word(p, ",");

}

p->flags |= TERMP_NOSPACE;

word(p, ")");

if (SEC_SYNOPSIS == node->sec)

Line 923 static void

Line 1105 static void

termp_fn_post(DECL_ARGS)

{

if (node->sec == SEC_SYNOPSIS)

if (node->sec == SEC_SYNOPSIS && node->next)

vspace(p);

}

Line 934 static int

Line 1116 static int

termp_sx_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_LINK];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_LINK]);

return(1);

}

/* ARGSUSED */

static void

termp_sx_post(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_LINK];

}

/* ARGSUSED */

static int

termp_fa_pre(DECL_ARGS)

{

struct mdoc_node *n;

p->flags |= ttypes[TTYPE_FUNC_ARG];

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

return(1);

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_ARG]);

}

return(1);

}

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

if (MDOC_TEXT != n->type)

errx(1, "expected text line arguments");

/* ARGSUSED */

p->flags |= ttypes[TTYPE_FUNC_ARG];

static void

word(p, n->string);

termp_fa_post(DECL_ARGS)

p->flags &= ~ttypes[TTYPE_FUNC_ARG];

{

p->flags &= ~ttypes[TTYPE_FUNC_ARG];

if (n->next)

word(p, ",");

}

if (node->next && node->next->tok == MDOC_Fa)

word(p, ",");

return(0);

}

Line 972 static int

Line 1156 static int

termp_va_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_VAR_DECL];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_VAR_DECL]);

return(1);

}

/* ARGSUSED */

static void

termp_va_post(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_VAR_DECL];

}

/* ARGSUSED */

static int

termp_bd_pre(DECL_ARGS)

{

const struct mdoc_block *bl;

const struct mdoc_node *n;

int i, type;

int i;

if (MDOC_BLOCK == node->type) {

vspace(p);

if (node->prev)

vspace(p);

return(1);

} else if (MDOC_BODY != node->type)

return(1);

assert(MDOC_BLOCK == node->parent->type);

if (NULL == node->parent->args)

errx(1, "missing display type");

bl = &node->parent->data.block;

pair->offset = p->offset;

i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);

for (type = -1, i = 0;

i < (int)node->parent->args->argc; i++) {

switch (node->parent->args->argv[i].arg) {

case (MDOC_Ragged):

/* FALLTHROUGH */

case (MDOC_Filled):

/* FALLTHROUGH */

case (MDOC_Unfilled):

/* FALLTHROUGH */

case (MDOC_Literal):

type = node->parent->args->argv[i].arg;

i = (int)node->parent->args->argc;

break;

default:

break;

}

if (NULL == node->parent->args)

errx(1, "missing display type");

i = arg_getattr(MDOC_Offset, node->parent);

if (-1 != i) {

assert(1 == bl->argv[i].sz);

if (1 != node->parent->args->argv[i].sz)

p->offset += arg_offset(&bl->argv[i]);

errx(1, "expected single value");

p->offset += arg_offset(&node->parent->args->argv[i]);

}

if ( ! arg_hasattr(MDOC_Literal, bl->argc, bl->argv))

switch (type) {

case (MDOC_Literal):

/* FALLTHROUGH */

case (MDOC_Unfilled):

break;

default:

return(1);

}

p->flags |= TERMP_LITERAL;

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

assert(MDOC_TEXT == n->type); /* FIXME */

if (MDOC_TEXT != n->type) {

if ((*n->data.text.string)) {

warnx("non-text children not yet allowed");

word(p, n->data.text.string);

continue;

flushln(p);

}

} else

word(p, n->string);

vspace(p);

flushln(p);

}

p->flags &= ~TERMP_LITERAL;

return(0);

}

Line 1034 termp_bd_pre(DECL_ARGS)

Line 1236 termp_bd_pre(DECL_ARGS)

static void

termp_bd_post(DECL_ARGS)

{

int i;

const struct mdoc_block *bl;

if (MDOC_BODY != node->type)

return;

assert(MDOC_BLOCK == node->parent->type);

if ( ! (p->flags & TERMP_LITERAL))

bl = &node->parent->data.block;

flushln(p);

i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);

p->flags &= ~TERMP_LITERAL;

if (-1 != i) {

p->offset = pair->offset;

assert(1 == bl->argv[i].sz);

p->offset -= arg_offset(&bl->argv[i]);

}

Line 1078 termp_qq_post(DECL_ARGS)

Line 1275 termp_qq_post(DECL_ARGS)

/* ARGSUSED */

static int

termp_bx_pre(DECL_ARGS)

termp_bsx_pre(DECL_ARGS)

{

word(p, "BSD");

word(p, "BSDI BSD/OS");

return(1);

}

/* ARGSUSED */

static void

termp_bx_post(DECL_ARGS)

{

if (node->child)

p->flags |= TERMP_NOSPACE;

word(p, "BSD");

}

/* ARGSUSED */

static int

termp_ox_pre(DECL_ARGS)

{

Line 1098 termp_ox_pre(DECL_ARGS)

Line 1306 termp_ox_pre(DECL_ARGS)

/* ARGSUSED */

static int

termp_ux_pre(DECL_ARGS)

{

word(p, "UNIX");

return(1);

}

/* ARGSUSED */

static int

termp_fx_pre(DECL_ARGS)

{

word(p, "FreeBSD");

return(1);

}

/* ARGSUSED */

static int

termp_nx_pre(DECL_ARGS)

{

Line 1113 termp_sq_pre(DECL_ARGS)

Line 1341 termp_sq_pre(DECL_ARGS)

if (MDOC_BODY != node->type)

return(1);

word(p, "\'");

word(p, "`");

p->flags |= TERMP_NOSPACE;

return(1);

}

Line 1159 termp_ss_pre(DECL_ARGS)

Line 1387 termp_ss_pre(DECL_ARGS)

switch (node->type) {

case (MDOC_HEAD):

vspace(p);

p->flags |= ttypes[TTYPE_SSECTION];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SSECTION]);

p->offset = INDENT / 2;

break;

default:

Line 1177 termp_ss_post(DECL_ARGS)

Line 1405 termp_ss_post(DECL_ARGS)

switch (node->type) {

case (MDOC_HEAD):

p->flags &= ~ttypes[TTYPE_SSECTION];

newln(p);

p->offset = INDENT;

break;

Line 1192 static int

Line 1419 static int

termp_pa_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_FILE];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FILE]);

return(1);

}

/* ARGSUSED */

static int

termp_em_pre(DECL_ARGS)

{

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);

return(1);

}

/* ARGSUSED */

static int

termp_cd_pre(DECL_ARGS)

{

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CONFIG]);

newln(p);

return(1);

}

/* ARGSUSED */

static int

termp_cm_pre(DECL_ARGS)

{

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_FLAG]);

return(1);

}

/* ARGSUSED */

static int

termp_ic_pre(DECL_ARGS)

{

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD]);

return(1);

}

/* ARGSUSED */

static int

termp_in_pre(DECL_ARGS)

{

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_INCLUDE]);

word(p, "#include");

word(p, "<");

p->flags |= TERMP_NOSPACE;

return(1);

}

/* ARGSUSED */

static void

termp_pa_post(DECL_ARGS)

termp_in_post(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_FILE];

p->flags |= TERMP_NOSPACE;

word(p, ">");

newln(p);

if (SEC_SYNOPSIS != node->sec)

return;

if (node->next && MDOC_In != node->next->tok)

vspace(p);

}

/* ARGSUSED */

static int

termp_qo_pre(DECL_ARGS)

termp_at_pre(DECL_ARGS)

{

const char *att;

att = NULL;

if (node->child) {

if (MDOC_TEXT != node->child->type)

errx(1, "expected text line argument");

att = mdoc_a2att(node->child->string);

}

if (NULL == att)

att = "AT&T UNIX";

word(p, att);

return(0);

}

/* ARGSUSED */

static int

termp_bq_pre(DECL_ARGS)

{

if (MDOC_BODY != node->type)

return(1);

word(p, "\"");

word(p, "[");

p->flags |= TERMP_NOSPACE;

return(1);

}

Line 1221 termp_qo_pre(DECL_ARGS)

Line 1531 termp_qo_pre(DECL_ARGS)

/* ARGSUSED */

static void

termp_qo_post(DECL_ARGS)

termp_bq_post(DECL_ARGS)

{

if (MDOC_BODY != node->type)

return;

p->flags |= TERMP_NOSPACE;

word(p, "]");

word(p, "\"");

}

/* ARGSUSED */

static int

termp_em_pre(DECL_ARGS)

termp_pq_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_EMPH];

if (MDOC_BODY != node->type)

return(1);

word(p, "\\&(");

p->flags |= TERMP_NOSPACE;

return(1);

}

/* ARGSUSED */

static void

termp_em_post(DECL_ARGS)

termp_pq_post(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_EMPH];

if (MDOC_BODY != node->type)

return;

word(p, ")");

}

/* ARGSUSED */

static int

termp_cd_pre(DECL_ARGS)

termp_fo_pre(DECL_ARGS)

{

const struct mdoc_node *n;

p->flags |= ttypes[TTYPE_CONFIG];

if (MDOC_BODY == node->type) {

return(1);

word(p, "(");

p->flags |= TERMP_NOSPACE;

return(1);

} else if (MDOC_HEAD != node->type)

return(1);

/* XXX - groff shows only first parameter */

p->flags |= ttypes[TTYPE_FUNC_NAME];

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

if (MDOC_TEXT != n->type)

errx(1, "expected text line argument");

word(p, n->string);

}

p->flags &= ~ttypes[TTYPE_FUNC_NAME];

return(0);

}

/* ARGSUSED */

static void

termp_cd_post(DECL_ARGS)

termp_fo_post(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_CONFIG];

if (MDOC_BODY != node->type)

return;

word(p, ")");

word(p, ";");

newln(p);

}

/* ARGSUSED */

static int

termp_cm_pre(DECL_ARGS)

termp_bf_pre(DECL_ARGS)

{

const struct mdoc_node *n;

p->flags |= ttypes[TTYPE_CMD_FLAG];

if (MDOC_HEAD == node->type) {

return(0);

} else if (MDOC_BLOCK != node->type)

return(1);

if (NULL == (n = node->head->child)) {

if (arg_hasattr(MDOC_Emphasis, node))

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);

else if (arg_hasattr(MDOC_Symbolic, node))

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMB]);

return(1);

}

if (MDOC_TEXT != n->type)

errx(1, "expected text line arguments");

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

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);

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

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);

return(1);

}

/* ARGSUSED */

static void

static int

termp_cm_post(DECL_ARGS)

termp_sy_pre(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_CMD_FLAG];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMB]);

return(1);

}

/* ARGSUSED */

static int

termp_ic_pre(DECL_ARGS)

termp_ms_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_CMD];

TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMBOL]);

return(1);

}

/* ARGSUSED */

static void

static int

termp_ic_post(DECL_ARGS)

termp_sm_pre(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_CMD];

#if notyet

assert(node->child);

if (0 == strcmp("off", node->child->data.text.string)) {

p->flags &= ~TERMP_NONOSPACE;

p->flags &= ~TERMP_NOSPACE;

} else {

p->flags |= TERMP_NONOSPACE;

p->flags |= TERMP_NOSPACE;

}

#endif

return(0);

}

/* ARGSUSED */

static int

termp_in_pre(DECL_ARGS)

termp__t_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_INCLUDE];

/* FIXME: titles are underlined. */

word(p, "\"");

p->flags |= TERMP_NOSPACE;

return(1);

}

/* ARGSUSED */

static void

termp_in_post(DECL_ARGS)

termp__t_post(DECL_ARGS)

{

p->flags &= ~ttypes[TTYPE_INCLUDE];

p->flags |= TERMP_NOSPACE;

/* FIXME: titles are underlined. */

word(p, "\"");

word(p, node->next ? "," : ".");

}

/* ARGSUSED */

static int

static void

termp_at_pre(DECL_ARGS)

termp____post(DECL_ARGS)

{

enum mdoc_att c;

c = ATT_DEFAULT;

p->flags |= TERMP_NOSPACE;

if (node->child) {

word(p, node->next ? "," : ".");

assert(MDOC_TEXT == node->child->type);

c = mdoc_atoatt(node->child->data.text.string);

}

word(p, mdoc_att2a(c));

return(0);

}

CVSweb