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.8 and 1.20

version 1.8, 2009/04/12 19:45:26

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

Line 1

/* $Id$ */

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

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

Line 15

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

#include <assert.h>

#include <ctype.h>

#include <err.h>

#include <stdio.h>

#include <stdlib.h>

Line 23

Line 24

#include "term.h"

#include "man.h"

#define INDENT 7

#define HALFINDENT 3

#ifdef __linux__

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

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

#endif

#define MANT_LITERAL (1 << 0)

#define DECL_ARGS struct termp *p, \

int *fl, \

const struct man_node *n, \

const struct man_meta *m

Line 40 struct termact {

Line 47 struct termact {

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

Line 50 static int pre_RI(DECL_ARGS);

Line 58 static int pre_RI(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_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_HP(DECL_ARGS);

static void post_SH(DECL_ARGS);

static void post_SS(DECL_ARGS);

static void post_i(DECL_ARGS);

static const struct termact termacts[MAN_MAX] = {

{ NULL, NULL }, /* __ */

{ pre_br, NULL }, /* br */

{ NULL, NULL }, /* TH */

{ pre_SH, post_SH }, /* SH */

{ pre_SS, post_SS }, /* SS */

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

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

{ pre_PP, NULL }, /* PP */

{ pre_PP, NULL }, /* P */

{ pre_IP, NULL }, /* IP */

{ pre_PP, NULL }, /* HP */ /* FIXME */

{ pre_HP, post_HP }, /* HP */

{ NULL, NULL }, /* SM */

{ pre_B, post_B }, /* SB */

{ pre_BI, NULL }, /* BI */

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

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

{ pre_I, post_I }, /* I */

{ pre_IR, NULL }, /* IR */

{ pre_RI, NULL }, /* RI */

{ pre_PP, NULL }, /* br */

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

{ NULL, NULL }, /* na */

{ pre_I, post_i }, /* i */

{ pre_I, post_I }, /* i */

{ pre_sp, NULL }, /* sp */

{ pre_nf, NULL }, /* nf */

{ pre_fi, NULL }, /* fi */

{ pre_r, NULL }, /* r */

};

static void print_head(struct termp *,

Line 89 static void print_body(DECL_ARGS);

Line 107 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

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

{

int fl;

print_head(p, man_meta(m));

p->flags |= TERMP_NOSPACE;

print_body(p, man_node(m), man_meta(m));

assert(man_node(m));

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

fl = 0;

if (man_node(m)->child)

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

print_foot(p, man_meta(m));

return(1);

}

static void

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

{

term_newln(p);

if (NULL == n->prev)

return;

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

return;

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

return;

term_vspace(p);

}

static int

arg_width(const struct man_node *n)

{

int i, len;

const char *p;

assert(MAN_TEXT == n->type);

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

}

/* ARGSUSED */

static int

pre_I(DECL_ARGS)

Line 115 pre_I(DECL_ARGS)

Line 187 pre_I(DECL_ARGS)

/* ARGSUSED */

static int

pre_r(DECL_ARGS)

{

p->flags &= ~TERMP_UNDER;

p->flags &= ~TERMP_BOLD;

return(1);

}

/* ARGSUSED */

static void

post_i(DECL_ARGS)

{

if (n->nchild)

p->flags &= ~TERMP_UNDER;

}

/* ARGSUSED */

static void

post_I(DECL_ARGS)

{

Line 125 post_I(DECL_ARGS)

Line 218 post_I(DECL_ARGS)

/* ARGSUSED */

static int

pre_fi(DECL_ARGS)

{

*fl &= ~MANT_LITERAL;

return(1);

}

/* ARGSUSED */

static int

pre_nf(DECL_ARGS)

{

term_newln(p);

*fl |= MANT_LITERAL;

return(1);

}

/* ARGSUSED */

static int

pre_IR(DECL_ARGS)

{

const struct man_node *nn;

Line 135 pre_IR(DECL_ARGS)

Line 249 pre_IR(DECL_ARGS)

p->flags |= TERMP_UNDER;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, nn, m);

print_node(p, fl, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_UNDER;

}

Line 154 pre_IB(DECL_ARGS)

Line 268 pre_IB(DECL_ARGS)

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

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, nn, m);

print_node(p, fl, nn, m);

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

}

return(0);

Line 173 pre_RB(DECL_ARGS)

Line 287 pre_RB(DECL_ARGS)

p->flags |= TERMP_BOLD;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, nn, m);

print_node(p, fl, nn, m);

if (i % 2)

p->flags &= ~TERMP_BOLD;

}

Line 193 pre_RI(DECL_ARGS)

Line 307 pre_RI(DECL_ARGS)

p->flags |= TERMP_UNDER;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, nn, m);

print_node(p, fl, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_UNDER;

}

Line 213 pre_BR(DECL_ARGS)

Line 327 pre_BR(DECL_ARGS)

p->flags |= TERMP_BOLD;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, nn, m);

print_node(p, fl, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_BOLD;

}

Line 232 pre_BI(DECL_ARGS)

Line 346 pre_BI(DECL_ARGS)

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

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, nn, m);

print_node(p, fl, nn, m);

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

}

return(0);

Line 260 post_B(DECL_ARGS)

Line 374 post_B(DECL_ARGS)

/* ARGSUSED */

static int

pre_PP(DECL_ARGS)

pre_sp(DECL_ARGS)

{

int i, len;

term_vspace(p);

if (NULL == n->child) {

p->offset = INDENT;

term_vspace(p);

return(0);

}

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

if (0 == len)

term_newln(p);

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

term_vspace(p);

return(0);

}

/* ARGSUSED */

static int

pre_br(DECL_ARGS)

{

term_newln(p);

return(0);

}

/* ARGSUSED */

static int

pre_HP(DECL_ARGS)

{

switch (n->type) {

case (MAN_BLOCK):

fmt_block_vspace(p, n);

break;

case (MAN_BODY):

p->flags |= TERMP_NOBREAK;

p->flags |= TERMP_TWOSPACE;

p->offset = INDENT;

p->rmargin = INDENT * 2;

break;

default:

return(0);

}

return(1);

}

/* ARGSUSED */

static void

post_HP(DECL_ARGS)

{

switch (n->type) {

case (MAN_BODY):

term_flushln(p);

p->flags &= ~TERMP_NOBREAK;

p->flags &= ~TERMP_TWOSPACE;

p->offset = INDENT;

p->rmargin = p->maxrmargin;

break;

default:

break;

}

/* ARGSUSED */

static int

pre_PP(DECL_ARGS)

{

switch (n->type) {

case (MAN_BLOCK):

fmt_block_vspace(p, n);

break;

default:

p->offset = INDENT;

break;

}

return(1);

}

/* ARGSUSED */

static int

pre_IP(DECL_ARGS)

{

/* TODO */

#if 0

const struct man_node *nn;

size_t offs;

size_t offs, sv;

int ival;

term_vspace(p);

fmt_block_vspace(p, n);

p->flags |= TERMP_NOSPACE;

sv = p->offset;

p->offset = INDENT;

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

if (NULL == n->child)

return(1);

if (MAN_TEXT != nn->type)

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

if (nn->next) {

p->flags |= TERMP_NOBREAK;

if (MAN_TEXT != nn->next->type)

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

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

} else

offs = strlen(nn->string);

p->flags |= TERMP_NOSPACE;

offs = sv;

p->offset += offs;

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

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

* prior saved offset. XXX - obviously not documented.

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

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;

term_flushln(p);

p->offset = offs;

p->rmargin = p->maxrmargin;

p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;

return(0);

#endif

return(1);

}

Line 301 pre_IP(DECL_ARGS)

Line 522 pre_IP(DECL_ARGS)

static int

pre_TP(DECL_ARGS)

{

/* TODO */

#if 0

const struct man_node *nn;

size_t offs;

term_vspace(p);

p->offset = INDENT;

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

Line 319 pre_TP(DECL_ARGS)

Line 543 pre_TP(DECL_ARGS)

offs = INDENT;

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

print_node(p, nn, m);

print_node(p, fl, nn, m);

term_flushln(p);

p->flags |= TERMP_NOSPACE;

p->offset += offs;

return(0);

#endif

return(1);

}

Line 333 static int

Line 559 static int

pre_SS(DECL_ARGS)

{

term_vspace(p);

switch (n->type) {

p->flags |= TERMP_BOLD;

case (MAN_BLOCK):

term_newln(p);

if (n->prev)

term_vspace(p);

break;

case (MAN_HEAD):

p->flags |= TERMP_BOLD;

p->offset = HALFINDENT;

break;

default:

p->offset = INDENT;

break;

}

return(1);

}

Line 344 static void

Line 583 static void

post_SS(DECL_ARGS)

{

term_flushln(p);

switch (n->type) {

p->flags &= ~TERMP_BOLD;

case (MAN_HEAD):

p->flags |= TERMP_NOSPACE;

term_newln(p);

p->flags &= ~TERMP_BOLD;

break;

default:

break;

}

Line 354 post_SS(DECL_ARGS)

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

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->offset = 0;

break;

case (MAN_BODY):

p->offset = INDENT;

break;

default:

break;

}

term_vspace(p);

p->offset = 0;

p->flags |= TERMP_BOLD;

return(1);

}

Line 367 static void

Line 629 static void

post_SH(DECL_ARGS)

{

term_flushln(p);

switch (n->type) {

p->offset = INDENT;

case (MAN_HEAD):

p->flags &= ~TERMP_BOLD;

term_newln(p);

p->flags |= TERMP_NOSPACE;

p->flags &= ~TERMP_BOLD;

break;

case (MAN_BODY):

term_newln(p);

break;

default:

break;

}

Line 382 print_node(DECL_ARGS)

Line 651 print_node(DECL_ARGS)

c = 1;

switch (n->type) {

case(MAN_ELEM):

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

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

break;

case(MAN_TEXT):

if (0 == *n->string) {

term_vspace(p);

Line 402 print_node(DECL_ARGS)

Line 667 print_node(DECL_ARGS)

if (sz >= 2 && n->string[sz - 1] == 'c' &&

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

p->flags |= TERMP_NOSPACE;

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

if (MANT_LITERAL & *fl) {

p->flags |= TERMP_NOSPACE;

term_flushln(p);

}

break;

default:

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

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

break;

}

if (c && n->child)

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

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

switch (n->type) {

if (MAN_TEXT != n->type)

case (MAN_ELEM):

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

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

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

break;

default:

break;

}

static void

print_body(DECL_ARGS)

{

print_node(p, n, m);

print_node(p, fl, n, m);

if ( ! n->next)

return;

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

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

}

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

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

tm = localtime(&meta->date);

#ifdef __OpenBSD__

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

#else

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

#endif

err(1, "strftime");

term_vspace(p);

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

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

meta->title, meta->msec);

p->offset = 0;

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

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

p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;

term_word(p, title);

CVSweb