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.3 and 1.19

version 1.3, 2009/03/26 15:19:44

version 1.19, 2009/08/13 11:45:29

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

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

* above copyright notice and this permission notice appear in all

* copyright notice and this permission notice appear in all copies.

* copies.

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED

* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE

* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL

* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR

* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

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

* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

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

* PERFORMANCE OF THIS SOFTWARE.

#include <assert.h>

#include <ctype.h>

#include <err.h>

#include <stdio.h>

#include <stdlib.h>

Line 25

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

static int pre_IR(DECL_ARGS);

static int pre_PP(DECL_ARGS);

static int pre_RB(DECL_ARGS);

Line 51 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_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 79 static const struct termact termacts[MAN_MAX] = {

{ pre_PP, NULL }, /* LP */

{ pre_PP, NULL }, /* PP */

{ pre_PP, NULL }, /* P */

{ NULL, NULL }, /* IP */

{ pre_IP, NULL }, /* IP */

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

{ pre_HP, NULL }, /* HP */

{ NULL, NULL }, /* SM */

{ pre_B, post_B }, /* SB */

{ pre_BI, NULL }, /* BI */

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

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

{ pre_I, post_I }, /* I */

{ pre_IR, NULL }, /* IR */

{ pre_RI, NULL }, /* RI */

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

{ 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 87 static void print_body(DECL_ARGS);

Line 106 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 113 pre_I(DECL_ARGS)

Line 186 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 123 post_I(DECL_ARGS)

Line 217 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 131 pre_IR(DECL_ARGS)

Line 246 pre_IR(DECL_ARGS)

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

if ( ! (i % 2))

p->flags |= TERMP_UNDER;

print_node(p, nn, m);

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_UNDER;

}

Line 148 pre_IB(DECL_ARGS)

Line 265 pre_IB(DECL_ARGS)

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

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

print_node(p, nn, m);

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

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

}

return(0);

Line 165 pre_RB(DECL_ARGS)

Line 284 pre_RB(DECL_ARGS)

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

if (i % 2)

p->flags |= TERMP_BOLD;

print_node(p, nn, m);

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

if (i % 2)

p->flags &= ~TERMP_BOLD;

}

Line 183 pre_RI(DECL_ARGS)

Line 304 pre_RI(DECL_ARGS)

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

if ( ! (i % 2))

p->flags |= TERMP_UNDER;

print_node(p, nn, m);

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_UNDER;

}

Line 201 pre_BR(DECL_ARGS)

Line 324 pre_BR(DECL_ARGS)

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

if ( ! (i % 2))

p->flags |= TERMP_BOLD;

print_node(p, nn, m);

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

if ( ! (i % 2))

p->flags &= ~TERMP_BOLD;

}

Line 218 pre_BI(DECL_ARGS)

Line 343 pre_BI(DECL_ARGS)

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

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

print_node(p, nn, m);

if (i > 0)

p->flags |= TERMP_NOSPACE;

print_node(p, fl, nn, m);

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

}

return(0);

Line 246 post_B(DECL_ARGS)

Line 373 post_B(DECL_ARGS)

/* ARGSUSED */

static int

pre_sp(DECL_ARGS)

{

int i, len;

if (NULL == n->child) {

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)

{

/* TODO */

return(1);

}

/* ARGSUSED */

static int

pre_PP(DECL_ARGS)

{

term_vspace(p);

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, sv;

int ival;

fmt_block_vspace(p, n);

p->flags |= TERMP_NOSPACE;

sv = p->offset;

p->offset = INDENT;

if (NULL == n->child)

return(1);

p->flags |= TERMP_NOBREAK;

offs = sv;

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

Line 489 pre_PP(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 277 pre_TP(DECL_ARGS)

Line 510 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 291 static int

Line 526 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 302 static void

Line 550 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 312 post_SS(DECL_ARGS)

Line 565 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 325 static void

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

}

static void

print_node(DECL_ARGS)

{

int c;

int c, sz;

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 (*n->string) {

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

term_word(p, n->string);

term_vspace(p);

break;

}

term_vspace(p);

* Note! This is hacky. Here, we recognise the `\c'

* escape embedded in so many -man pages. It's supposed

* to remove the subsequent space, so we mark NOSPACE if

* it's encountered in the string.

sz = (int)strlen(n->string);

term_word(p, n->string);

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 390 print_foot(struct termp *p, const struct man_meta *met

Line 677 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");

* This is /slightly/ different from regular groff output

* because we don't have page numbers. Print the following:

* OS MDOCDATE

term_vspace(p);

p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;

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

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

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

err(1, "malloc");

* The header is strange. It has three components, which are

* really two with the first duplicated. It goes like this:

* IDENTIFIER TITLE IDENTIFIER

* The IDENTIFIER is NAME(SECTION), which is the command-name

* (if given, or "unknown" if not) followed by the manual page

* section. These are given in `Dt'. The TITLE is a free-form

* string depending on the manual volume. If not specified, it

* switches on the manual section.

if (meta->vol)

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

else

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

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