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.25 and 1.37

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

version 1.37, 2009/10/18 11:14:04

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>

Line 21

Line 23

#include <stdlib.h>

#include <string.h>

#include "term.h"

#include "man.h"

#include "term.h"

#include "chars.h"

#include "main.h"

#include "out.h"

#define INDENT 7

#define HALFINDENT 3

Line 30

Line 35

struct mtermp {

int fl;

#define MANT_LITERAL (1 << 0)

int lmargin;

* 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, \

Line 45 struct termact {

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

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

Line 67 static void post_B(DECL_ARGS);

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

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

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

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

{ NULL, NULL }, /* RS */

{ pre_RS, post_RS }, /* RS */

{ pre_ign, NULL }, /* DT */

{ pre_ign, NULL }, /* UC */

};

#ifdef __linux__

Line 117 static void print_foot(struct termp *,

Line 139 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 *);

static int a2width(const char *);

int

void

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

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

{

struct mtermp mt;

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_head(p, m);

p->flags |= TERMP_NOSPACE;

assert(man_node(m));

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

mt.fl = 0;

mt.lmargin = INDENT;

mt.offset = INDENT;

if (man_node(m)->child)

if (n->child)

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

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

print_foot(p, man_meta(m));

print_foot(p, m);

return(1);

}

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

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

static int

arg_width(const struct man_node *n)

a2width(const char *p)

{

int i, len;

struct roffsu su;

const char *p;

double r;

assert(MAN_TEXT == n->type);

if ( ! a2roffsu(p, &su))

assert(n->string);

return(-1);

p = n->string;

switch (su.unit) {

case (SCALE_CM):

r = 4 * su.scale;

break;

case (SCALE_IN):

r = 10 * su.scale;

break;

case (SCALE_PC):

r = 2 * su.scale;

break;

case (SCALE_PT):

r = (su.scale / 10) + 1;

break;

case (SCALE_MM):

r = su.scale / 1000;

break;

case (SCALE_VS):

r = su.scale * 2 - 1;

break;

default:

r = su.scale + 1;

break;

}

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

if (r < 0.0)

return(-1);

r = 0.0;

return((int)/* LINTED */

r);

}

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

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

break;

if (i == len - 1) {

/* ARGSUSED */

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

static int

return(atoi(p));

pre_ign(DECL_ARGS)

} else if (i == len)

{

return(atoi(p));

return(-1);

return(0);

}

Line 191 static int

Line 249 static int

pre_I(DECL_ARGS)

{

p->flags |= TERMP_UNDER;

p->under++;

return(1);

}

Line 201 static int

Line 259 static int

pre_r(DECL_ARGS)

{

p->flags &= ~TERMP_UNDER;

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

p->flags &= ~TERMP_BOLD;

return(1);

}

Line 213 post_i(DECL_ARGS)

Line 270 post_i(DECL_ARGS)

{

if (n->nchild)

p->flags &= ~TERMP_UNDER;

p->under--;

}

Line 222 static void

Line 279 static void

post_I(DECL_ARGS)

{

p->flags &= ~TERMP_UNDER;

p->under--;

}

Line 256 pre_IR(DECL_ARGS)

Line 313 pre_IR(DECL_ARGS)

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

if ( ! (i % 2))

p->flags |= TERMP_UNDER;

p->under++;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, mt, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_UNDER;

p->under--;

}

return(0);

}

Line 269 pre_IR(DECL_ARGS)

Line 326 pre_IR(DECL_ARGS)

/* 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, mt, nn, m);

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

}

return(0);

}

/* ARGSUSED */

static int

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

p->bold++;

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

p->bold++;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, mt, nn, m);

if (i % 2)

p->flags &= ~TERMP_BOLD;

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

p->bold--;

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

p->bold--;

}

return(0);

}

Line 314 pre_RI(DECL_ARGS)

Line 360 pre_RI(DECL_ARGS)

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

if ( ! (i % 2))

p->flags |= TERMP_UNDER;

p->under++;

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, mt, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_UNDER;

p->under--;

}

return(0);

}

Line 327 pre_RI(DECL_ARGS)

Line 373 pre_RI(DECL_ARGS)

/* 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, mt, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_BOLD;

}

return(0);

}

/* ARGSUSED */

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, 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 368 static int

Line 410 static int

pre_B(DECL_ARGS)

{

p->flags |= TERMP_BOLD;

p->bold++;

return(1);

}

Line 378 static void

Line 420 static void

post_B(DECL_ARGS)

{

p->flags &= ~TERMP_BOLD;

p->bold--;

}

Line 433 pre_HP(DECL_ARGS)

Line 475 pre_HP(DECL_ARGS)

return(0);

}

len = (size_t)mt->lmargin;

len = mt->lmargin;

ival = -1;

/* Calculate offset. */

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

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

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

assert(MAN_TEXT == nn->type);

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

len = (size_t)ival;

}

if (0 == len)

len = 1;

p->offset = INDENT;

p->offset = mt->offset;

p->rmargin = INDENT + len;

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

if (ival >= 0)

mt->lmargin = ival;

mt->lmargin = (size_t)ival;

return(1);

}

Line 468 post_HP(DECL_ARGS)

Line 512 post_HP(DECL_ARGS)

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 488 pre_PP(DECL_ARGS)

Line 532 pre_PP(DECL_ARGS)

fmt_block_vspace(p, n);

break;

default:

p->offset = INDENT;

p->offset = mt->offset;

break;

}

Line 520 pre_IP(DECL_ARGS)

Line 564 pre_IP(DECL_ARGS)

return(1);

}

len = (size_t)mt->lmargin;

len = mt->lmargin;

ival = -1;

/* Calculate offset. */

Line 529 pre_IP(DECL_ARGS)

Line 573 pre_IP(DECL_ARGS)

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

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

/* Do nothing. */ ;

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

assert(MAN_TEXT == nn->type);

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

len = (size_t)ival;

}

Line 539 pre_IP(DECL_ARGS)

Line 584 pre_IP(DECL_ARGS)

if (0 == len)

len = 1;

p->offset = INDENT;

p->offset = mt->offset;

p->rmargin = INDENT + len;

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

if (ival < 0)

break;

/* Set the saved left-margin. */

mt->lmargin = ival;

mt->lmargin = (size_t)ival;

/* 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->offset = mt->offset + len;

p->rmargin = p->maxrmargin;

break;

default:

Line 615 pre_TP(DECL_ARGS)

Line 660 pre_TP(DECL_ARGS)

/* Calculate offset. */

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

if (NULL != nn->next)

if (NULL != nn->next) {

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

assert(MAN_TEXT == nn->type);

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

len = (size_t)ival;

}

switch (n->type) {

case (MAN_HEAD):

Line 625 pre_TP(DECL_ARGS)

Line 672 pre_TP(DECL_ARGS)

if (0 == len)

len = 1;

p->offset = INDENT;

p->offset = mt->offset;

p->rmargin = INDENT + len;

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

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

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

Line 634 pre_TP(DECL_ARGS)

Line 681 pre_TP(DECL_ARGS)

print_node(p, mt, nn, m);

if (ival >= 0)

mt->lmargin = ival;

mt->lmargin = (size_t)ival;

return(0);

case (MAN_BODY):

p->offset = INDENT + len;

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

p->rmargin = p->maxrmargin;

break;

default:

Line 679 pre_SS(DECL_ARGS)

Line 726 pre_SS(DECL_ARGS)

switch (n->type) {

case (MAN_BLOCK):

mt->lmargin = INDENT;

mt->offset = INDENT;

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

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

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

Line 688 pre_SS(DECL_ARGS)

Line 736 pre_SS(DECL_ARGS)

term_vspace(p);

break;

case (MAN_HEAD):

p->flags |= TERMP_BOLD;

p->bold++;

p->offset = HALFINDENT;

break;

case (MAN_BODY):

p->offset = INDENT;

p->offset = mt->offset;

break;

default:

break;

Line 710 post_SS(DECL_ARGS)

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

Line 729 pre_SH(DECL_ARGS)

Line 777 pre_SH(DECL_ARGS)

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)

Line 736 pre_SH(DECL_ARGS)

Line 785 pre_SH(DECL_ARGS)

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 758 post_SH(DECL_ARGS)

Line 807 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 769 post_SH(DECL_ARGS)

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

}

assert(MAN_TEXT == nn->type);

if ((ival = a2width(nn->string)) < 0)

return(1);

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

p->offset = mt->offset;

return(1);

}

/* ARGSUSED */

static void

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_node(DECL_ARGS)

{

int c, sz;

Line 829 static void

Line 929 static void

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

{

struct tm *tm;

char *buf;

char buf[BUFSIZ];

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

err(1, "malloc");

tm = localtime(&meta->date);

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

err(1, "strftime");

(void)strlcpy(buf, "(invalid date)", BUFSIZ);

term_vspace(p);

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

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

term_word(p, buf);

term_flushln(p);

free(buf);

}

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

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

p->offset = 0;

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

err(1, "malloc");

err(EXIT_FAILURE, "malloc");

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

err(1, "malloc");

err(EXIT_FAILURE, "malloc");

if (meta->vol)

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

CVSweb