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.20 and 1.50

version 1.20, 2009/08/13 12:15:58

version 1.50, 2009/11/10 11:45:57

Line 14

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

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

#include <sys/types.h>

#include <assert.h>

#include <ctype.h>

#include <err.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "term.h"

#include "out.h"

#include "man.h"

#include "term.h"

#include "chars.h"

#include "main.h"

#define INDENT 7

#define HALFINDENT 3

#ifdef __linux__

/* FIXME: have PD set the default vspace width. */

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

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

#endif

struct mtermp {

int fl;

#define MANT_LITERAL (1 << 0)

* Default amount to indent the left margin after leading text

* has been printed (e.g., `HP' left-indent, `TP' and `IP' body

* indent). This needs to be saved because `HP' and so on, if

* not having a specified value, must default.

* Note that this is the indentation AFTER the left offset, so

* the total offset is usually offset + lmargin.

size_t lmargin;

* The default offset, i.e., the amount between any text and the

* page boundary.

size_t offset;

};

#define DECL_ARGS struct termp *p, \

int *fl, \

struct mtermp *mt, \

const struct man_node *n, \

const struct man_meta *m

Line 44 struct termact {

Line 63 struct termact {

void (*post)(DECL_ARGS);

};

#ifdef __linux__

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

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

#endif

static int a2width(const struct man_node *);

static int a2height(const struct man_node *);

static void print_man_head(struct termp *,

const struct man_meta *);

static void print_man_body(DECL_ARGS);

static void print_man_node(DECL_ARGS);

static void print_man_foot(struct termp *,

const struct man_meta *);

static void print_bvspace(struct termp *,

const struct man_node *);

static int pre_B(DECL_ARGS);

static int pre_BI(DECL_ARGS);

static int pre_BR(DECL_ARGS);

static int pre_HP(DECL_ARGS);

static int pre_I(DECL_ARGS);

static int pre_IB(DECL_ARGS);

static int pre_IP(DECL_ARGS);

static int pre_IR(DECL_ARGS);

static int pre_PP(DECL_ARGS);

static int pre_RB(DECL_ARGS);

static int pre_RI(DECL_ARGS);

static int pre_RS(DECL_ARGS);

static int pre_SH(DECL_ARGS);

static int pre_SS(DECL_ARGS);

static int pre_TP(DECL_ARGS);

static int pre_br(DECL_ARGS);

static int pre_fi(DECL_ARGS);

static int pre_ign(DECL_ARGS);

static int pre_nf(DECL_ARGS);

static int pre_r(DECL_ARGS);

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_RS(DECL_ARGS);

static void post_SH(DECL_ARGS);

static void post_SS(DECL_ARGS);

static void post_TP(DECL_ARGS);

static void post_i(DECL_ARGS);

static const struct termact termacts[MAN_MAX] = {

{ pre_br, NULL }, /* br */

{ NULL, NULL }, /* TH */

{ pre_SH, post_SH }, /* SH */

{ pre_SS, post_SS }, /* SS */

{ pre_TP, NULL }, /* TP */

{ pre_TP, post_TP }, /* TP */

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

{ pre_BI, NULL }, /* BI */

{ pre_IB, NULL }, /* IB */

{ pre_BI, NULL }, /* IB */

{ pre_BR, NULL }, /* BR */

{ pre_RB, NULL }, /* BR */

{ pre_RB, NULL }, /* RB */

{ NULL, NULL }, /* R */

{ pre_B, post_B }, /* B */

{ pre_I, post_I }, /* I */

{ pre_IR, NULL }, /* IR */

{ pre_RI, NULL }, /* IR */

{ pre_RI, NULL }, /* RI */

{ NULL, NULL }, /* na */ /* TODO: document that has no effect */

{ NULL, NULL }, /* na */

{ pre_I, post_i }, /* i */

{ pre_sp, NULL }, /* sp */

{ pre_nf, NULL }, /* nf */

{ pre_fi, NULL }, /* fi */

{ pre_r, NULL }, /* r */

{ NULL, NULL }, /* RE */

{ pre_RS, post_RS }, /* RS */

{ pre_ign, NULL }, /* DT */

{ pre_ign, NULL }, /* UC */

{ pre_ign, NULL }, /* PD */

};

static void print_head(struct termp *,

const struct man_meta *);

static void print_body(DECL_ARGS);

static void print_node(DECL_ARGS);

static void print_foot(struct termp *,

const struct man_meta *);

static void fmt_block_vspace(struct termp *,

const struct man_node *);

static int arg_width(const struct man_node *);

int

void

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

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

{

int fl;

struct termp *p;

const struct man_node *n;

const struct man_meta *m;

struct mtermp mt;

print_head(p, man_meta(m));

p = (struct termp *)arg;

if (NULL == p->symtab)

switch (p->enc) {

case (TERMENC_ASCII):

p->symtab = chars_init(CHARS_ASCII);

break;

default:

abort();

/* NOTREACHED */

}

n = man_node(man);

m = man_meta(man);

print_man_head(p, m);

p->flags |= TERMP_NOSPACE;

assert(man_node(m));

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

fl = 0;

mt.fl = 0;

if (man_node(m)->child)

mt.lmargin = INDENT;

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

mt.offset = INDENT;

print_foot(p, man_meta(m));

return(1);

if (n->child)

print_man_body(p, &mt, n->child, m);

print_man_foot(p, m);

}

static int

a2height(const struct man_node *n)

{

struct roffsu su;

assert(MAN_TEXT == n->type);

assert(n->string);

if ( ! a2roffsu(n->string, &su, SCALE_VS))

SCALE_VS_INIT(&su, strlen(n->string));

return((int)term_vspan(&su));

}

static int

a2width(const struct man_node *n)

{

struct roffsu su;

assert(MAN_TEXT == n->type);

assert(n->string);

if ( ! a2roffsu(n->string, &su, SCALE_BU))

return(-1);

return((int)term_hspan(&su));

}

static void

fmt_block_vspace(struct termp *p, const struct man_node *n)

print_bvspace(struct termp *p, const struct man_node *n)

{

term_newln(p);

Line 148 fmt_block_vspace(struct termp *p, const struct man_nod

Line 227 fmt_block_vspace(struct termp *p, const struct man_nod

}

/* ARGSUSED */

static int

arg_width(const struct man_node *n)

pre_ign(DECL_ARGS)

{

int i, len;

const char *p;

assert(MAN_TEXT == n->type);

return(0);

assert(n->string);

p = n->string;

if (0 == (len = (int)strlen(p)))

return(-1);

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

if ( ! isdigit((u_char)p[i]))

break;

if (i == len - 1) {

if ('n' == p[len - 1] || 'm' == p[len - 1])

return(atoi(p));

} else if (i == len)

return(atoi(p));

return(-1);

}

Line 181 static int

Line 241 static int

pre_I(DECL_ARGS)

{

p->flags |= TERMP_UNDER;

p->under++;

return(1);

}

Line 191 static int

Line 251 static int

pre_r(DECL_ARGS)

{

p->flags &= ~TERMP_UNDER;

p->bold = p->under = 0;

p->flags &= ~TERMP_BOLD;

return(1);

}

Line 203 post_i(DECL_ARGS)

Line 262 post_i(DECL_ARGS)

{

if (n->nchild)

p->flags &= ~TERMP_UNDER;

p->under--;

}

Line 212 static void

Line 271 static void

post_I(DECL_ARGS)

{

p->flags &= ~TERMP_UNDER;

p->under--;

}

Line 221 static int

Line 280 static int

pre_fi(DECL_ARGS)

{

*fl &= ~MANT_LITERAL;

mt->fl &= ~MANT_LITERAL;

return(1);

}

Line 232 pre_nf(DECL_ARGS)

Line 291 pre_nf(DECL_ARGS)

{

term_newln(p);

*fl |= MANT_LITERAL;

mt->fl |= MANT_LITERAL;

return(1);

}

/* ARGSUSED */

static int

pre_IR(DECL_ARGS)

pre_RB(DECL_ARGS)

{

const struct man_node *nn;

int i;

for (i = 0, nn = n->child; nn; nn = nn->next, i++) {

if ( ! (i % 2))

if (i % 2 && MAN_RB == n->tok)

p->flags |= TERMP_UNDER;

p->bold++;

if (i > 0)

else if ( ! (i % 2) && MAN_RB != n->tok)

p->flags |= TERMP_NOSPACE;

p->bold++;

print_node(p, fl, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_UNDER;

}

return(0);

}

/* ARGSUSED */

static int

pre_IB(DECL_ARGS)

{

const struct man_node *nn;

int i;

for (i = 0, nn = n->child; nn; nn = nn->next, i++) {

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

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

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

}

return(0);

}

print_man_node(p, mt, nn, m);

/* ARGSUSED */

if (i % 2 && MAN_RB == n->tok)

static int

p->bold--;

pre_RB(DECL_ARGS)

else if ( ! (i % 2) && MAN_RB != n->tok)

{

p->bold--;

const struct man_node *nn;

int i;

for (i = 0, nn = n->child; nn; nn = nn->next, i++) {

if (i % 2)

p->flags |= TERMP_BOLD;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

if (i % 2)

p->flags &= ~TERMP_BOLD;

}

return(0);

}

Line 303 pre_RI(DECL_ARGS)

Line 331 pre_RI(DECL_ARGS)

int i;

for (i = 0, nn = n->child; nn; nn = nn->next, i++) {

if ( ! (i % 2))

if (i % 2 && MAN_RI == n->tok)

p->flags |= TERMP_UNDER;

p->under++;

if (i > 0)

else if ( ! (i % 2) && MAN_RI != n->tok)

p->flags |= TERMP_NOSPACE;

p->under++;

print_node(p, fl, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_UNDER;

}

return(0);

}

/* ARGSUSED */

static int

pre_BR(DECL_ARGS)

{

const struct man_node *nn;

int i;

for (i = 0, nn = n->child; nn; nn = nn->next, i++) {

if ( ! (i % 2))

p->flags |= TERMP_BOLD;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

print_man_node(p, mt, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_BOLD;

if (i % 2 && MAN_RI == n->tok)

p->under--;

else if ( ! (i % 2) && MAN_RI != n->tok)

p->under--;

}

return(0);

}

Line 339 pre_BR(DECL_ARGS)

Line 353 pre_BR(DECL_ARGS)

static int

pre_BI(DECL_ARGS)

{

const struct man_node *nn;

int i;

for (i = 0, nn = n->child; nn; nn = nn->next, i++) {

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

if (i % 2 && MAN_BI == n->tok)

if (i > 0)

p->under++;

else if (i % 2)

p->bold++;

else if (MAN_BI == n->tok)

p->bold++;

else

p->under++;

if (i)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

print_man_node(p, mt, nn, m);

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

if (i % 2 && MAN_BI == n->tok)

p->under--;

else if (i % 2)

p->bold--;

else if (MAN_BI == n->tok)

p->bold--;

else

p->under--;

}

return(0);

}

Line 358 static int

Line 388 static int

pre_B(DECL_ARGS)

{

p->flags |= TERMP_BOLD;

p->bold++;

return(1);

}

Line 368 static void

Line 398 static void

post_B(DECL_ARGS)

{

p->flags &= ~TERMP_BOLD;

p->bold--;

}

Line 378 pre_sp(DECL_ARGS)

Line 408 pre_sp(DECL_ARGS)

{

int i, len;

if (NULL == n->child) {

len = n->child ? a2height(n->child) : 1;

term_vspace(p);

return(0);

}

len = atoi(n->child->string);

if (0 == len)

term_newln(p);

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

Line 407 pre_br(DECL_ARGS)

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

print_bvspace(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 = mt->lmargin;

ival = -1;

/* Calculate offset. */

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

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

len = (size_t)ival;

if (0 == len)

len = 1;

p->offset = mt->offset;

p->rmargin = mt->offset + len;

if (ival >= 0)

mt->lmargin = (size_t)ival;

return(1);

}

Line 432 post_HP(DECL_ARGS)

Line 477 post_HP(DECL_ARGS)

{

switch (n->type) {

case (MAN_BLOCK):

term_flushln(p);

break;

case (MAN_BODY):

term_flushln(p);

p->flags &= ~TERMP_NOBREAK;

p->flags &= ~TERMP_TWOSPACE;

p->offset = INDENT;

p->offset = mt->offset;

p->rmargin = p->maxrmargin;

break;

default:

Line 452 pre_PP(DECL_ARGS)

Line 500 pre_PP(DECL_ARGS)

switch (n->type) {

case (MAN_BLOCK):

fmt_block_vspace(p, n);

mt->lmargin = INDENT;

print_bvspace(p, n);

break;

default:

p->offset = INDENT;

p->offset = mt->offset;

break;

}

Line 467 pre_PP(DECL_ARGS)

Line 516 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):

print_bvspace(p, n);

/* FALLTHROUGH */

default:

return(1);

}

p->flags |= TERMP_NOBREAK;

len = 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 = a2width(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 = mt->offset;

p->rmargin = mt->offset + len;

if (ival < 0)

break;

p->offset = offs;

/* Set the saved left-margin. */

p->rmargin = p->maxrmargin;

mt->lmargin = (size_t)ival;

p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;

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

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

print_man_node(p, mt, nn, m);

return(0);

case (MAN_BODY):

p->offset = mt->offset + 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)

{

/* TODO */

const struct man_node *nn;

#if 0

size_t len;

const struct man_node *nn;

int ival;

size_t offs;

term_vspace(p);

switch (n->type) {

case (MAN_HEAD):

p->flags |= TERMP_NOBREAK;

p->flags |= TERMP_TWOSPACE;

break;

case (MAN_BODY):

p->flags |= TERMP_NOLPAD;

p->flags |= TERMP_NOSPACE;

break;

case (MAN_BLOCK):

print_bvspace(p, n);

/* FALLTHROUGH */

default:

return(1);

}

p->offset = INDENT;

len = (size_t)mt->lmargin;

ival = -1;

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

/* Calculate offset. */

return(1);

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

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

if (MAN_TEXT != nn->type)

if (NULL != nn->next)

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

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

offs = (size_t)atoi(nn->string);

len = (size_t)ival;

nn = nn->next;

} else

offs = INDENT;

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

switch (n->type) {

print_node(p, fl, nn, m);

case (MAN_HEAD):

/* Handle zero-length properly. */

if (0 == len)

len = 1;

term_flushln(p);

p->offset = mt->offset;

p->flags |= TERMP_NOSPACE;

p->rmargin = mt->offset + len;

p->offset += offs;

return(0);

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

#endif

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

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

print_man_node(p, mt, nn, m);

if (ival >= 0)

mt->lmargin = (size_t)ival;

return(0);

case (MAN_BODY):

p->offset = mt->offset + len;

p->rmargin = p->maxrmargin;

break;

default:

break;

}

return(1);

}

/* ARGSUSED */

static void

post_TP(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_SS(DECL_ARGS)

{

switch (n->type) {

case (MAN_BLOCK):

term_newln(p);

mt->lmargin = INDENT;

if (n->prev)

mt->offset = INDENT;

term_vspace(p);

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

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->bold++;

p->offset = HALFINDENT;

break;

case (MAN_BODY):

p->offset = mt->offset;

break;

default:

p->offset = INDENT;

break;

}

Line 586 post_SS(DECL_ARGS)

Line 727 post_SS(DECL_ARGS)

switch (n->type) {

case (MAN_HEAD):

term_newln(p);

p->flags &= ~TERMP_BOLD;

p->bold--;

break;

case (MAN_BODY):

term_newln(p);

break;

default:

break;

}

Line 598 post_SS(DECL_ARGS)

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

mt->offset = INDENT;

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

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

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

break;

term_vspace(p);

break;

case (MAN_HEAD):

p->flags |= TERMP_BOLD;

p->bold++;

p->offset = 0;

break;

case (MAN_BODY):

p->offset = INDENT;

p->offset = mt->offset;

break;

default:

break;

Line 632 post_SH(DECL_ARGS)

Line 776 post_SH(DECL_ARGS)

switch (n->type) {

case (MAN_HEAD):

term_newln(p);

p->flags &= ~TERMP_BOLD;

p->bold--;

break;

case (MAN_BODY):

term_newln(p);

Line 643 post_SH(DECL_ARGS)

Line 787 post_SH(DECL_ARGS)

}

/* ARGSUSED */

static int

pre_RS(DECL_ARGS)

{

const struct man_node *nn;

int ival;

switch (n->type) {

case (MAN_BLOCK):

term_newln(p);

return(1);

case (MAN_HEAD):

return(0);

default:

break;

}

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

mt->offset = mt->lmargin + INDENT;

p->offset = mt->offset;

return(1);

}

if ((ival = a2width(nn)) < 0)

return(1);

mt->offset = INDENT + (size_t)ival;

p->offset = mt->offset;

return(1);

}

/* ARGSUSED */

static void

print_node(DECL_ARGS)

post_RS(DECL_ARGS)

{

switch (n->type) {

case (MAN_BLOCK):

mt->offset = mt->lmargin = INDENT;

break;

default:

term_newln(p);

p->offset = INDENT;

break;

}

static void

print_man_node(DECL_ARGS)

{

int c, sz;

c = 1;

Line 668 print_node(DECL_ARGS)

Line 862 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_man_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);

}

static void

print_body(DECL_ARGS)

print_man_body(DECL_ARGS)

{

print_node(p, fl, n, m);

print_man_node(p, mt, n, m);

if ( ! n->next)

return;

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

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

}

static void

print_foot(struct termp *p, const struct man_meta *meta)

print_man_foot(struct termp *p, const struct man_meta *meta)

{

struct tm *tm;

char buf[DATESIZ];

char *buf;

if (NULL == (buf = malloc(p->rmargin)))

p->metafont = 0;

err(1, "malloc");

tm = localtime(&meta->date);

time2a(meta->date, buf, DATESIZ);

if (0 == strftime(buf, p->rmargin, "%B %d, %Y", tm))

err(1, "strftime");

term_vspace(p);

p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;

Line 732 print_foot(struct termp *p, const struct man_meta *met

Line 921 print_foot(struct termp *p, const struct man_meta *met

term_word(p, buf);

term_flushln(p);

free(buf);

}

static void

print_head(struct termp *p, const struct man_meta *meta)

print_man_head(struct termp *p, const struct man_meta *m)

{

char *buf, *title;

char buf[BUFSIZ], title[BUFSIZ];

p->rmargin = p->maxrmargin;

p->offset = 0;

buf[0] = title[0] = '\0';

if (NULL == (buf = malloc(p->rmargin)))

if (m->vol)

err(1, "malloc");

strlcpy(buf, m->vol, BUFSIZ);

if (NULL == (title = malloc(p->rmargin)))

err(1, "malloc");

if (meta->vol)

snprintf(title, BUFSIZ, "%s(%d)", m->title, m->msec);

(void)strlcpy(buf, meta->vol, p->rmargin);

else

*buf = 0;

(void)snprintf(title, p->rmargin, "%s(%d)",

meta->title, meta->msec);

p->offset = 0;

p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;

p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;

Line 783 print_head(struct termp *p, const struct man_meta *met

Line 963 print_head(struct termp *p, const struct man_meta *met

p->rmargin = p->maxrmargin;

p->offset = 0;

p->flags &= ~TERMP_NOSPACE;

free(title);

free(buf);

}

CVSweb