mandoc/term.c - diff

Return to term.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/term.c between version 1.13 and 1.33

version 1.13, 2009/02/24 13:46:54

version 1.33, 2009/03/01 23:27:14

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

#define INDENT 6

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

Line 30

Line 33

/* FIXME: indent/tab. */

/* FIXME: handle nested lists. */

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

#define TTYPE_PROG 0

#define TTYPE_CMD_FLAG 1

Line 45

Line 48

#define TTYPE_SSECTION 10

#define TTYPE_FILE 11

#define TTYPE_EMPH 12

#define TTYPE_NMAX 13

#define TTYPE_CONFIG 13

#define TTYPE_CMD 14

#define TTYPE_INCLUDE 15

#define TTYPE_SYMB 16

#define TTYPE_SYMBOL 17

#define TTYPE_NMAX 18

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

Line 66 const int ttypes[TTYPE_NMAX] = {

Line 74 const int ttypes[TTYPE_NMAX] = {

TERMP_UNDERLINE, /* TTYPE_LINK */

TERMP_BOLD, /* TTYPE_SSECTION */

TERMP_UNDERLINE, /* TTYPE_FILE */

TERMP_UNDERLINE /* TTYPE_EMPH */

TERMP_UNDERLINE, /* TTYPE_EMPH */

TERMP_BOLD, /* TTYPE_CONFIG */

TERMP_BOLD, /* TTYPE_CMD */

TERMP_BOLD, /* TTYPE_INCLUDE */

TERMP_BOLD, /* TTYPE_SYMB */

TERMP_BOLD /* TTYPE_SYMBOL */

};

static int arg_hasattr(int, size_t,

Line 83 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 94 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_bq);

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

DECL_PRE(termp_ar);

DECL_PRE(termp_at);

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

const struct termact __termacts[MDOC_MAX] = {

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

Line 140 const struct termact __termacts[MDOC_MAX] = {

Line 174 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 148 const struct termact __termacts[MDOC_MAX] = {

Line 182 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 */

{ NULL, NULL }, /* Cd */

{ termp_cd_pre, NULL }, /* Cd */

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

{ NULL, NULL }, /* Ic */

{ termp_ic_pre, NULL }, /* Ic */

{ NULL, NULL }, /* In */

{ 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 */

{ NULL, NULL }, /* Rv */

{ termp_rv_pre, NULL }, /* Rv */

{ NULL, NULL }, /* St */

{ 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 */

{ NULL, NULL }, /* Ao */

{ termp_aq_pre, termp_aq_post }, /* Ao */

{ termp_aq_pre, termp_aq_post }, /* Aq */

{ NULL, NULL }, /* At */

{ 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 */

Line 246 const struct termact *termacts = __termacts;

Line 280 const struct termact *termacts = __termacts;

static size_t

arg_width(const struct mdoc_arg *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((int)(*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);

}

Line 263 arg_offset(const struct mdoc_arg *arg)

Line 317 arg_offset(const struct mdoc_arg *arg)

return(INDENT);

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

return(INDENT * 2);

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

}

Line 316 termp_dq_post(DECL_ARGS)

Line 369 termp_dq_post(DECL_ARGS)

/* ARGSUSED */

static void

static int

termp_it_post(DECL_ARGS)

termp_it_pre(DECL_ARGS)

{

const struct mdoc_node *n, *it;

const struct mdoc_block *bl;

int i;

char buf[7], *tp;

int i, type;

size_t width, offset;

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

* here. They must account for a considerable number of

* switches that completely change the output behaviour, like

* -tag versus -column. Yech.

switch (node->type) {

case (MDOC_BODY):

/* FALLTHROUGH */

case (MDOC_HEAD):

it = node->parent;

break;

case (MDOC_BLOCK):

it = node;

break;

default:

return;

return(1);

}

it = node->parent;

n = it->parent->parent;

assert(MDOC_BLOCK == it->type);

assert(MDOC_It == it->tok);

n = it->parent;

assert(MDOC_BODY == n->type);

assert(MDOC_Bl == n->tok);

n = n->parent;

bl = &n->data.block;

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

if (MDOC_BLOCK == node->type) {

newln(p);

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

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

vspace(p);

return(1);

}

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

/* Get our list type. */

flushln(p);

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

for (type = -1, i = 0; i < (int)bl->argc; i++)

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

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

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

case (MDOC_Bullet):

/* FALLTHROUGH */

case (MDOC_Dash):

/* FALLTHROUGH */

case (MDOC_Enum):

/* FALLTHROUGH */

case (MDOC_Hyphen):

/* FALLTHROUGH */

case (MDOC_Tag):

/* FALLTHROUGH */

case (MDOC_Ohang):

type = bl->argv[i].arg;

i = (int)bl->argc;

break;

default:

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

/* NOTREACHED */

}

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

assert(-1 != type);

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

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

if (MDOC_HEAD == node->type) {

/* Save our existing (inherited) margin and offset. */

p->rmargin = p->maxrmargin;

p->offset -= offset;

p->flags &= ~TERMP_NOBREAK;

} else {

p->offset -= width;

p->flags &= ~TERMP_NOLPAD;

}

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

pair->offset = p->offset;

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

pair->rmargin = p->rmargin;

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

flushln(p);

/* Get list width and offset. */

p->offset -= offset;

return;

}

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

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

/* ARGSUSED */

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

static int

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

termp_it_pre(DECL_ARGS)

{

const struct mdoc_node *n, *it;

const struct mdoc_block *bl;

int i;

size_t width, offset;

/* Override the width. */

* 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 > 6 ? width : 6;

break;

case (MDOC_BLOCK):

case (MDOC_Tag):

it = node;

/* FIXME: auto-size. */

if (0 == width)

errx(1, "need non-zero -width");

break;

default:

return(1);

break;

}

assert(MDOC_BLOCK == it->type);

/* Word-wrap control. */

assert(MDOC_It == it->tok);

n = it->parent;

p->flags |= TERMP_NOSPACE;

assert(MDOC_BODY == n->type);

assert(MDOC_Bl == n->tok);

n = n->parent;

bl = &n->data.block;

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

switch (type) {

case (MDOC_Bullet):

if (MDOC_BLOCK == node->type) {

/* FALLTHROUGH */

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

case (MDOC_Dash):

newln(p);

/* FALLTHROUGH */

else

case (MDOC_Enum):

vspace(p);

/* FALLTHROUGH */

return(1);

case (MDOC_Hyphen):

/* FALLTHROUGH */

case (MDOC_Tag):

if (MDOC_HEAD == node->type)

p->flags |= TERMP_NOBREAK;

else if (MDOC_BODY == node->type)

p->flags |= TERMP_NOLPAD;

break;

default:

break;

}

assert(MDOC_HEAD == node->type

|| MDOC_BODY == node->type);

* Get a token to use as the HEAD lead-in. If NULL, we use the

* HEAD child.

/* FIXME: see termp_it_post(). */

tp = NULL;

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

if (MDOC_HEAD == node->type) {

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

tp = "\\[bu]";

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

tp = "\\-";

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

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

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

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

tp = buf;

}

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

tp = "\\-";

}

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

/* Margin control. */

p->flags |= TERMP_NOSPACE;

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

p->offset += offset;

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

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

switch (type) {

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

case (MDOC_Bullet):

/* FALLTHROUGH */

if (MDOC_HEAD == node->type) {

case (MDOC_Dash):

p->flags |= TERMP_NOBREAK;

/* FALLTHROUGH */

p->offset += offset;

case (MDOC_Enum):

/* FALLTHROUGH */

case (MDOC_Hyphen):

/* FALLTHROUGH */

case (MDOC_Tag):

if (MDOC_HEAD == node->type)

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

} else {

else if (MDOC_BODY == node->type)

p->flags |= TERMP_NOSPACE;

p->flags |= TERMP_NOLPAD;

p->offset += width;

}

break;

return(1);

default:

break;

}

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

if (NULL == tp)

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

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

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

p->flags |= TERMP_NOSPACE;

p->offset += offset;

return(1);

}

return(1);

word(p, tp);

return(0);

}

/* ARGSUSED */

static void

termp_nm_post(DECL_ARGS)

termp_it_post(DECL_ARGS)

{

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

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

return;

flushln(p);

p->offset = pair->offset;

p->rmargin = pair->rmargin;

if (MDOC_HEAD == node->type)

p->flags &= ~TERMP_NOBREAK;

else if (MDOC_BODY == node->type)

p->flags &= ~TERMP_NOLPAD;

}

/* 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)

if (NULL == node->child) {

word(p, meta->name);

word(p, "file");

word(p, "...");

}

return(1);

}

Line 535 termp_pp_pre(DECL_ARGS)

Line 620 termp_pp_pre(DECL_ARGS)

/* ARGSUSED */

static void

static int

termp_ar_post(DECL_ARGS)

termp_st_pre(DECL_ARGS)

{

const char *tp;

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

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

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

word(p, tp);

return(1);

}

/* ARGSUSED */

static int

termp_rs_pre(DECL_ARGS)

{

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

vspace(p);

return(1);

}

/* ARGSUSED */

static int

termp_rv_pre(DECL_ARGS)

{

int i;

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

node->data.elem.argv);

assert(i >= 0);

newln(p);

word(p, "The");

p->flags |= ttypes[TTYPE_FUNC_NAME];

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

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

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

word(p, "otherwise the value -1 is returned and the");

word(p, "global variable");

p->flags |= ttypes[TTYPE_VAR_DECL];

word(p, "errno");

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

word(p, "is set to indicate the error.");

return(1);

}

/* ARGSUSED */

static int

termp_ex_pre(DECL_ARGS)

{

int i;

Line 596 termp_op_post(DECL_ARGS)

Line 729 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)

{

Line 648 termp_vt_pre(DECL_ARGS)

Line 761 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 658 static void

Line 771 static void

termp_vt_post(DECL_ARGS)

{

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

if (node->sec == SEC_SYNOPSIS)

vspace(p);

}

Line 673 termp_fd_pre(DECL_ARGS)

Line 785 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 683 static void

Line 795 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 698 termp_sh_pre(DECL_ARGS)

Line 811 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 711 termp_sh_pre(DECL_ARGS)

Line 824 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 729 termp_op_pre(DECL_ARGS)

Line 861 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 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 757 termp_d1_pre(DECL_ARGS)

Line 887 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 770 termp_d1_post(DECL_ARGS)

Line 900 termp_d1_post(DECL_ARGS)

if (MDOC_BODY != node->type)

return;

newln(p);

p->offset -= INDENT;

p->offset -= pair->offset;

}

Line 804 static int

Line 934 static int

termp_ft_pre(DECL_ARGS)

{

p->flags |= ttypes[TTYPE_FUNC_TYPE];

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

return(1);

}

Line 814 static void

Line 944 static void

termp_ft_post(DECL_ARGS)

{

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

if (node->sec == SEC_SYNOPSIS)

newln(p);

}

Line 836 termp_fn_pre(DECL_ARGS)

Line 964 termp_fn_pre(DECL_ARGS)

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

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

p->flags |= TERMP_NOSPACE;

word(p, "(");

p->flags |= TERMP_NOSPACE;

Line 845 termp_fn_pre(DECL_ARGS)

Line 972 termp_fn_pre(DECL_ARGS)

p->flags |= ttypes[TTYPE_FUNC_ARG];

word(p, n->data.text.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 864 static void

Line 990 static void

termp_fn_post(DECL_ARGS)

{

if (node->sec == SEC_SYNOPSIS)

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

vspace(p);

}

Line 875 static int

Line 1001 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) {

assert(MDOC_TEXT == n->type);

/* ARGSUSED */

p->flags |= ttypes[TTYPE_FUNC_ARG];

static void

word(p, n->data.text.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 913 static int

Line 1040 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)

{

Line 936 termp_bd_pre(DECL_ARGS)

Line 1054 termp_bd_pre(DECL_ARGS)

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

pair->offset = p->offset;

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

Line 951 termp_bd_pre(DECL_ARGS)

Line 1071 termp_bd_pre(DECL_ARGS)

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

}

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

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)

errx(1, "non-text displays unsupported");

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

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

flushln(p);

Line 975 termp_bd_pre(DECL_ARGS)

Line 1093 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;

newln(p);

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

p->offset = pair->offset;

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

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

if (-1 != i) {

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

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

}

Line 1019 termp_qq_post(DECL_ARGS)

Line 1128 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)

{

p->flags |= TERMP_NOSPACE;

word(p, "BSD");

}

/* ARGSUSED */

static int

termp_ox_pre(DECL_ARGS)

{

Line 1039 termp_ox_pre(DECL_ARGS)

Line 1158 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 1054 termp_sq_pre(DECL_ARGS)

Line 1193 termp_sq_pre(DECL_ARGS)

if (MDOC_BODY != node->type)

return(1);

word(p, "\'");

word(p, "`");

p->flags |= TERMP_NOSPACE;

return(1);

}

Line 1100 termp_ss_pre(DECL_ARGS)

Line 1239 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 1118 termp_ss_post(DECL_ARGS)

Line 1257 termp_ss_post(DECL_ARGS)

switch (node->type) {

case (MDOC_HEAD):

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

newln(p);

p->offset = INDENT;

break;

Line 1133 static int

Line 1271 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)

{

enum mdoc_att c;

c = ATT_DEFAULT;

if (node->child) {

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

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

}

word(p, mdoc_att2a(c));

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 1162 termp_qo_pre(DECL_ARGS)

Line 1378 termp_qo_pre(DECL_ARGS)

/* ARGSUSED */

static void

termp_qo_post(DECL_ARGS)

termp_bq_post(DECL_ARGS)

{

if (MDOC_BODY != node->type)

return;

word(p, "]");

}

/* ARGSUSED */

static int

termp_pq_pre(DECL_ARGS)

{

if (MDOC_BODY != node->type)

return(1);

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

p->flags |= TERMP_NOSPACE;

word(p, "\"");

return(1);

}

/* ARGSUSED */

static void

termp_pq_post(DECL_ARGS)

{

if (MDOC_BODY != node->type)

return;

word(p, ")");

}

/* ARGSUSED */

static int

termp_em_pre(DECL_ARGS)

termp_fo_pre(DECL_ARGS)

{

const struct mdoc_node *n;

p->flags |= ttypes[TTYPE_EMPH];

if (MDOC_BODY == node->type) {

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

assert(MDOC_TEXT == n->type);

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

}

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

return(0);

}

/* ARGSUSED */

static void

termp_fo_post(DECL_ARGS)

{

if (MDOC_BODY != node->type)

return;

word(p, ")");

word(p, ";");

newln(p);

}

/* ARGSUSED */

static int

termp_bf_pre(DECL_ARGS)

{

const struct mdoc_node *n;

const struct mdoc_block *b;

/* XXX - we skip over possible trailing HEAD tokens. */

if (MDOC_HEAD == node->type)

return(0);

else if (MDOC_BLOCK != node->type)

return(1);

b = &node->data.block;

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

if (arg_hasattr(MDOC_Emphasis, b->argc, b->argv))

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

else if (arg_hasattr(MDOC_Symbolic, b->argc, b->argv))

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

return(1);

}

assert(MDOC_TEXT == n->type);

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

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

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

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

return(1);

}

/* ARGSUSED */

static int

termp_sy_pre(DECL_ARGS)

{

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

return(1);

}

/* ARGSUSED */

static int

termp_ms_pre(DECL_ARGS)

{

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

return(1);

}

/* ARGSUSED */

static int

termp_sm_pre(DECL_ARGS)

{

#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__t_pre(DECL_ARGS)

{

word(p, "\"");

p->flags |= TERMP_NOSPACE;

return(1);

}

/* ARGSUSED */

static void

termp_em_post(DECL_ARGS)

termp__t_post(DECL_ARGS)

{

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

p->flags |= TERMP_NOSPACE;

word(p, "\"");

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

}

/* ARGSUSED */

static void

termp____post(DECL_ARGS)

{

p->flags |= TERMP_NOSPACE;

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

}

CVSweb