mandoc/man_term.c - diff

Return to man_term.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/man_term.c between version 1.21 and 1.25

version 1.21, 2009/08/13 12:31:50

version 1.25, 2009/08/19 09:14:50

Line 27

#define INDENT 7

#define HALFINDENT 3

#ifdef __linux__

struct mtermp {

extern size_t strlcpy(char *, const char *, size_t);

int fl;

extern size_t strlcat(char *, const char *, size_t);

#endif

#define MANT_LITERAL (1 << 0)

int lmargin;

};

#define DECL_ARGS struct termp *p, \

int *fl, \

struct mtermp *mt, \

const struct man_node *n, \

const struct man_meta *m

Line 66 static int pre_sp(DECL_ARGS);

Line 65 static int pre_sp(DECL_ARGS);

static void post_B(DECL_ARGS);

static void post_I(DECL_ARGS);

static void post_IP(DECL_ARGS);

static void post_HP(DECL_ARGS);

static void post_SH(DECL_ARGS);

static void post_SS(DECL_ARGS);

Line 81 static const struct termact termacts[MAN_MAX] = {

{ pre_PP, NULL }, /* LP */

{ pre_PP, NULL }, /* PP */

{ pre_PP, NULL }, /* P */

{ pre_IP, NULL }, /* IP */

{ pre_IP, post_IP }, /* IP */

{ pre_HP, post_HP }, /* HP */

{ NULL, NULL }, /* SM */

{ pre_B, post_B }, /* SB */

Line 100 static const struct termact termacts[MAN_MAX] = {

{ pre_nf, NULL }, /* nf */

{ pre_fi, NULL }, /* fi */

{ pre_r, NULL }, /* r */

{ NULL, NULL }, /* RE */

{ NULL, NULL }, /* RS */

};

#ifdef __linux__

extern size_t strlcpy(char *, const char *, size_t);

extern size_t strlcat(char *, const char *, size_t);

#endif

static void print_head(struct termp *,

const struct man_meta *);

static void print_body(DECL_ARGS);

Line 116 static int arg_width(const struct man_node *);

Line 123 static int arg_width(const struct man_node *);

int

man_run(struct termp *p, const struct man *m)

{

int fl;

struct mtermp mt;

print_head(p, man_meta(m));

p->flags |= TERMP_NOSPACE;

assert(man_node(m));

assert(MAN_ROOT == man_node(m)->type);

fl = 0;

mt.fl = 0;

mt.lmargin = INDENT;

if (man_node(m)->child)

print_body(p, &fl, man_node(m)->child, man_meta(m));

print_body(p, &mt, man_node(m)->child, man_meta(m));

print_foot(p, man_meta(m));

return(1);

Line 222 static int

Line 231 static int

pre_fi(DECL_ARGS)

{

*fl &= ~MANT_LITERAL;

mt->fl &= ~MANT_LITERAL;

return(1);

}

Line 233 pre_nf(DECL_ARGS)

Line 242 pre_nf(DECL_ARGS)

{

term_newln(p);

*fl |= MANT_LITERAL;

mt->fl |= MANT_LITERAL;

return(1);

}

Line 250 pre_IR(DECL_ARGS)

Line 259 pre_IR(DECL_ARGS)

p->flags |= TERMP_UNDER;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

print_node(p, mt, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_UNDER;

}

Line 269 pre_IB(DECL_ARGS)

Line 278 pre_IB(DECL_ARGS)

p->flags |= i % 2 ? TERMP_BOLD : TERMP_UNDER;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

print_node(p, mt, nn, m);

p->flags &= i % 2 ? ~TERMP_BOLD : ~TERMP_UNDER;

}

return(0);

Line 288 pre_RB(DECL_ARGS)

Line 297 pre_RB(DECL_ARGS)

p->flags |= TERMP_BOLD;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

print_node(p, mt, nn, m);

if (i % 2)

p->flags &= ~TERMP_BOLD;

}

Line 308 pre_RI(DECL_ARGS)

Line 317 pre_RI(DECL_ARGS)

p->flags |= TERMP_UNDER;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

print_node(p, mt, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_UNDER;

}

Line 328 pre_BR(DECL_ARGS)

Line 337 pre_BR(DECL_ARGS)

p->flags |= TERMP_BOLD;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

print_node(p, mt, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_BOLD;

}

Line 347 pre_BI(DECL_ARGS)

Line 356 pre_BI(DECL_ARGS)

p->flags |= i % 2 ? TERMP_UNDER : TERMP_BOLD;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

print_node(p, mt, nn, m);

p->flags &= i % 2 ? ~TERMP_UNDER : ~TERMP_BOLD;

}

return(0);

Line 408 pre_br(DECL_ARGS)

Line 417 pre_br(DECL_ARGS)

static int

pre_HP(DECL_ARGS)

{

size_t len;

int ival;

const struct man_node *nn;

switch (n->type) {

case (MAN_BLOCK):

fmt_block_vspace(p, n);

break;

return(1);

case (MAN_BODY):

p->flags |= TERMP_NOBREAK;

p->flags |= TERMP_TWOSPACE;

p->offset = INDENT;

p->rmargin = INDENT * 2;

break;

default:

return(0);

}

len = (size_t)mt->lmargin;

ival = -1;

/* Calculate offset. */

if (NULL != (nn = n->parent->head->child))

if ((ival = arg_width(nn)) >= 0)

len = (size_t)ival;

if (0 == len)

len = 1;

p->offset = INDENT;

p->rmargin = INDENT + len;

if (ival >= 0)

mt->lmargin = ival;

return(1);

}

Line 433 post_HP(DECL_ARGS)

Line 461 post_HP(DECL_ARGS)

{

switch (n->type) {

case (MAN_BLOCK):

term_flushln(p);

break;

case (MAN_BODY):

term_flushln(p);

p->flags &= ~TERMP_NOBREAK;

Line 453 pre_PP(DECL_ARGS)

Line 484 pre_PP(DECL_ARGS)

switch (n->type) {

case (MAN_BLOCK):

mt->lmargin = INDENT;

fmt_block_vspace(p, n);

break;

default:

Line 468 pre_PP(DECL_ARGS)

Line 500 pre_PP(DECL_ARGS)

static int

pre_IP(DECL_ARGS)

{

/* TODO */

const struct man_node *nn;

#if 0

size_t len;

const struct man_node *nn;

int ival;

size_t offs, sv;

int ival;

fmt_block_vspace(p, n);

switch (n->type) {

case (MAN_BODY):

p->flags |= TERMP_NOSPACE;

p->flags |= TERMP_NOLPAD;

p->flags |= TERMP_NOSPACE;

sv = p->offset;

break;

p->offset = INDENT;

case (MAN_HEAD):

p->flags |= TERMP_NOBREAK;

if (NULL == n->child)

p->flags |= TERMP_TWOSPACE;

break;

case (MAN_BLOCK):

fmt_block_vspace(p, n);

/* FALLTHROUGH */

default:

return(1);

}

p->flags |= TERMP_NOBREAK;

len = (size_t)mt->lmargin;

ival = -1;

offs = sv;

/* Calculate offset. */

if (NULL != (nn = n->parent->head->child))

* If the last token is number-looking (3m, 3n, 3) then

if (NULL != (nn = nn->next)) {

* interpret it as the width specifier, else we stick with the

for ( ; nn->next; nn = nn->next)

* prior saved offset. XXX - obviously not documented.

/* Do nothing. */ ;

if ((ival = arg_width(nn)) >= 0)

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

len = (size_t)ival;

if (NULL == nn->next) {

ival = arg_width(nn);

if (ival >= 0) {

offs = (size_t)ival;

break;

}

print_node(p, fl, nn, m);

}

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

switch (n->type) {

case (MAN_HEAD):

/* Handle zero-width lengths. */

if (0 == len)

len = 1;

term_flushln(p);

p->offset = INDENT;

p->rmargin = INDENT + len;

if (ival < 0)

break;

p->offset = offs;

/* Set the saved left-margin. */

p->rmargin = p->maxrmargin;

mt->lmargin = ival;

p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;

/* Don't print the length value. */

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

print_node(p, mt, nn, m);

return(0);

case (MAN_BODY):

p->offset = INDENT + len;

p->rmargin = p->maxrmargin;

break;

default:

break;

}

return(0);

#endif

return(1);

}

/* ARGSUSED */

static void

post_IP(DECL_ARGS)

{

switch (n->type) {

case (MAN_HEAD):

term_flushln(p);

p->flags &= ~TERMP_NOBREAK;

p->flags &= ~TERMP_TWOSPACE;

p->rmargin = p->maxrmargin;

break;

case (MAN_BODY):

term_flushln(p);

p->flags &= ~TERMP_NOLPAD;

break;

default:

break;

}

/* ARGSUSED */

static int

pre_TP(DECL_ARGS)

{

const struct man_node *nn;

size_t len;

int ival;

switch (n->type) {

case (MAN_BLOCK):

fmt_block_vspace(p, n);

break;

case (MAN_HEAD):

p->rmargin = INDENT * 2;

p->offset = INDENT;

p->flags |= TERMP_NOBREAK;

p->flags |= TERMP_TWOSPACE;

break;

case (MAN_BODY):

p->flags |= TERMP_NOLPAD;

p->flags |= TERMP_NOSPACE;

p->offset = INDENT * 2;

break;

case (MAN_BLOCK):

fmt_block_vspace(p, n);

/* FALLTHROUGH */

default:

return(1);

}

len = (size_t)mt->lmargin;

ival = -1;

/* Calculate offset. */

if (NULL != (nn = n->parent->head->child))

if (NULL != nn->next)

if ((ival = arg_width(nn)) >= 0)

len = (size_t)ival;

switch (n->type) {

case (MAN_HEAD):

/* Handle zero-length properly. */

if (0 == len)

len = 1;

p->offset = INDENT;

p->rmargin = INDENT + len;

/* Don't print same-line elements. */

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

if (nn->line > n->line)

print_node(p, mt, nn, m);

if (ival >= 0)

mt->lmargin = ival;

return(0);

case (MAN_BODY):

p->offset = INDENT + len;

p->rmargin = p->maxrmargin;

break;

default:

break;

}

return(1);

Line 576 pre_SS(DECL_ARGS)

Line 678 pre_SS(DECL_ARGS)

switch (n->type) {

case (MAN_BLOCK):

term_newln(p);

mt->lmargin = INDENT;

if (n->prev)

/* If following a prior empty `SS', no vspace. */

term_vspace(p);

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

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

break;

if (NULL == n->prev)

break;

term_vspace(p);

break;

case (MAN_HEAD):

p->flags |= TERMP_BOLD;

p->offset = HALFINDENT;

break;

default:

case (MAN_BODY):

p->offset = INDENT;

break;

default:

break;

}

return(1);

Line 603 post_SS(DECL_ARGS)

Line 712 post_SS(DECL_ARGS)

term_newln(p);

p->flags &= ~TERMP_BOLD;

break;

case (MAN_BODY):

term_newln(p);

break;

default:

break;

}

Line 613 post_SS(DECL_ARGS)

Line 725 post_SS(DECL_ARGS)

static int

pre_SH(DECL_ARGS)

{

* XXX: undocumented: using two `SH' macros in sequence has no

* vspace between calls, only a newline.

switch (n->type) {

case (MAN_BLOCK):

mt->lmargin = INDENT;

/* If following a prior empty `SH', no vspace. */

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

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

break;

Line 683 print_node(DECL_ARGS)

Line 794 print_node(DECL_ARGS)

n->string[sz - 2] == '\\')

p->flags |= TERMP_NOSPACE;

/* FIXME: this means that macro lines are munged! */

if (MANT_LITERAL & *fl) {

if (MANT_LITERAL & mt->fl) {

p->flags |= TERMP_NOSPACE;

term_flushln(p);

}

break;

default:

if (termacts[n->tok].pre)

c = (*termacts[n->tok].pre)(p, fl, n, m);

c = (*termacts[n->tok].pre)(p, mt, n, m);

break;

}

if (c && n->child)

print_body(p, fl, n->child, m);

print_body(p, mt, n->child, m);

if (MAN_TEXT != n->type)

if (termacts[n->tok].post)

(*termacts[n->tok].post)(p, fl, n, m);

(*termacts[n->tok].post)(p, mt, n, m);

}

Line 707 static void

Line 818 static void

print_body(DECL_ARGS)

{

print_node(p, fl, n, m);

print_node(p, mt, n, m);

if ( ! n->next)

return;

print_body(p, fl, n->next, m);

print_body(p, mt, n->next, m);

}

CVSweb