mandoc/mdoc_term.c - diff

Return to mdoc_term.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mdoc_term.c between version 1.268 and 1.312

version 1.268, 2014/07/02 03:48:07

version 1.312, 2015/03/06 13:09:07

Line 1

/* $Id$ */

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

Line 16

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

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

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <sys/types.h>

#include <assert.h>

#include <ctype.h>

#include <limits.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

Line 51 struct termact {

Line 50 struct termact {

void (*post)(DECL_ARGS);

};

static size_t a2width(const struct termp *, const char *);

static int a2width(const struct termp *, const char *);

static size_t a2height(const struct termp *, const char *);

static size_t a2offs(const struct termp *, const char *);

static void print_bvspace(struct termp *,

const struct mdoc_node *,

Line 67 static void synopsis_pre(struct termp *,

Line 64 static void synopsis_pre(struct termp *,

static void termp____post(DECL_ARGS);

static void termp__t_post(DECL_ARGS);

static void termp_an_post(DECL_ARGS);

static void termp_bd_post(DECL_ARGS);

static void termp_bk_post(DECL_ARGS);

static void termp_bl_post(DECL_ARGS);

static void termp_eo_post(DECL_ARGS);

static void termp_fd_post(DECL_ARGS);

static void termp_fo_post(DECL_ARGS);

static void termp_in_post(DECL_ARGS);

Line 95 static int termp_bt_pre(DECL_ARGS);

Line 92 static int termp_bt_pre(DECL_ARGS);

static int termp_bx_pre(DECL_ARGS);

static int termp_cd_pre(DECL_ARGS);

static int termp_d1_pre(DECL_ARGS);

static int termp_es_pre(DECL_ARGS);

static int termp_eo_pre(DECL_ARGS);

static int termp_ex_pre(DECL_ARGS);

static int termp_fa_pre(DECL_ARGS);

static int termp_fd_pre(DECL_ARGS);

Line 115 static int termp_quote_pre(DECL_ARGS);

Line 112 static int termp_quote_pre(DECL_ARGS);

static int termp_rs_pre(DECL_ARGS);

static int termp_rv_pre(DECL_ARGS);

static int termp_sh_pre(DECL_ARGS);

static int termp_skip_pre(DECL_ARGS);

static int termp_sm_pre(DECL_ARGS);

static int termp_sp_pre(DECL_ARGS);

static int termp_ss_pre(DECL_ARGS);

Line 140 static const struct termact termacts[MDOC_MAX] = {

Line 138 static const struct termact termacts[MDOC_MAX] = {

{ NULL, NULL }, /* El */

{ termp_it_pre, termp_it_post }, /* It */

{ termp_under_pre, NULL }, /* Ad */

{ termp_an_pre, termp_an_post }, /* An */

{ termp_an_pre, NULL }, /* An */

{ termp_under_pre, NULL }, /* Ar */

{ termp_cd_pre, NULL }, /* Cd */

{ termp_bold_pre, NULL }, /* Cm */

Line 187 static const struct termact termacts[MDOC_MAX] = {

Line 185 static const struct termact termacts[MDOC_MAX] = {

{ termp_quote_pre, termp_quote_post }, /* Bq */

{ termp_xx_pre, NULL }, /* Bsx */

{ termp_bx_pre, NULL }, /* Bx */

{ NULL, NULL }, /* Db */

{ termp_skip_pre, NULL }, /* Db */

{ NULL, NULL }, /* Dc */

{ termp_quote_pre, termp_quote_post }, /* Do */

{ termp_quote_pre, termp_quote_post }, /* Dq */

{ NULL, NULL }, /* Ec */ /* FIXME: no space */

{ NULL, NULL }, /* Ef */

{ termp_under_pre, NULL }, /* Em */

{ termp_quote_pre, termp_quote_post }, /* Eo */

{ termp_eo_pre, termp_eo_post }, /* Eo */

{ termp_xx_pre, NULL }, /* Fx */

{ termp_bold_pre, NULL }, /* Ms */

{ NULL, NULL }, /* No */

{ termp_li_pre, NULL }, /* No */

{ termp_ns_pre, NULL }, /* Ns */

{ termp_xx_pre, NULL }, /* Nx */

{ termp_xx_pre, NULL }, /* Ox */

Line 239 static const struct termact termacts[MDOC_MAX] = {

Line 237 static const struct termact termacts[MDOC_MAX] = {

{ termp_quote_pre, termp_quote_post }, /* Bro */

{ NULL, NULL }, /* Brc */

{ NULL, termp____post }, /* %C */

{ termp_es_pre, NULL }, /* Es */

{ termp_skip_pre, NULL }, /* Es */

{ termp_quote_pre, termp_quote_post }, /* En */

{ termp_xx_pre, NULL }, /* Dx */

{ NULL, termp____post }, /* %Q */

Line 254 static const struct termact termacts[MDOC_MAX] = {

Line 252 static const struct termact termacts[MDOC_MAX] = {

void

terminal_mdoc(void *arg, const struct mdoc *mdoc)

{

const struct mdoc_node *n;

const struct mdoc_meta *meta;

struct mdoc_node *n;

struct termp *p;

p = (struct termp *)arg;

if (0 == p->defindent)

p->defindent = 5;

p->overstep = 0;

p->maxrmargin = p->defrmargin;

p->rmargin = p->maxrmargin = p->defrmargin;

p->tabwidth = term_len(p, 5);

if (NULL == p->symtab)

n = mdoc_node(mdoc)->child;

p->symtab = mchars_alloc();

n = mdoc_node(mdoc);

meta = mdoc_meta(mdoc);

term_begin(p, print_mdoc_head, print_mdoc_foot, meta);

if (p->synopsisonly) {

while (n != NULL) {

if (n->child)

if (n->tok == MDOC_Sh && n->sec == SEC_SYNOPSIS) {

print_mdoc_nodelist(p, NULL, meta, n->child);

if (n->child->next->child != NULL)

print_mdoc_nodelist(p, NULL,

term_end(p);

meta, n->child->next->child);

term_newln(p);

break;

}

n = n->next;

}

} else {

if (p->defindent == 0)

p->defindent = 5;

term_begin(p, print_mdoc_head, print_mdoc_foot, meta);

if (n != NULL) {

if (n->tok != MDOC_Sh)

term_vspace(p);

print_mdoc_nodelist(p, NULL, meta, n);

}

term_end(p);

}

static void

print_mdoc_nodelist(DECL_ARGS)

{

print_mdoc_node(p, pair, meta, n);

while (n != NULL) {

if (n->next)

print_mdoc_node(p, pair, meta, n);

print_mdoc_nodelist(p, pair, meta, n->next);

n = n->next;

}

static void

Line 300 print_mdoc_node(DECL_ARGS)

Line 309 print_mdoc_node(DECL_ARGS)

chld = 1;

offset = p->offset;

rmargin = p->rmargin;

n->prev_font = term_fontq(p);

n->flags &= ~MDOC_ENDED;

n->prev_font = p->fonti;

memset(&npair, 0, sizeof(struct termpair));

npair.ppair = pair;

Line 310 print_mdoc_node(DECL_ARGS)

Line 320 print_mdoc_node(DECL_ARGS)

* invoked in a prior line, revert it to PREKEEP.

if (TERMP_KEEP & p->flags) {

if (p->flags & TERMP_KEEP && n->flags & MDOC_LINE) {

if (n->prev ? (n->prev->lastline != n->line) :

p->flags &= ~TERMP_KEEP;

(n->parent && n->parent->line != n->line)) {

p->flags |= TERMP_PREKEEP;

p->flags &= ~TERMP_KEEP;

p->flags |= TERMP_PREKEEP;

}

Line 334 print_mdoc_node(DECL_ARGS)

Line 341 print_mdoc_node(DECL_ARGS)

p->flags |= TERMP_NOSPACE;

break;

case MDOC_EQN:

if ( ! (n->flags & MDOC_LINE))

p->flags |= TERMP_NOSPACE;

term_eqn(p, n->eqn);

if (n->next != NULL && ! (n->next->flags & MDOC_LINE))

p->flags |= TERMP_NOSPACE;

break;

case MDOC_TBL:

term_tbl(p, n->span);

break;

default:

if (termacts[n->tok].pre && ENDBODY_NOT == n->end)

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

(n->end == ENDBODY_NOT || n->nchild))

chld = (*termacts[n->tok].pre)

(p, &npair, meta, n);

break;

Line 350 print_mdoc_node(DECL_ARGS)

Line 362 print_mdoc_node(DECL_ARGS)

print_mdoc_nodelist(p, &npair, meta, n->child);

term_fontpopq(p,

(ENDBODY_NOT == n->end ? n : n->pending)->prev_font);

(ENDBODY_NOT == n->end ? n : n->body)->prev_font);

switch (n->type) {

case MDOC_TEXT:

Line 370 print_mdoc_node(DECL_ARGS)

Line 382 print_mdoc_node(DECL_ARGS)

* that it must not call the post handler again.

if (ENDBODY_NOT != n->end)

n->pending->flags |= MDOC_ENDED;

n->body->flags |= MDOC_ENDED;

* End of line terminating an implicit block

Line 395 static void

Line 407 static void

print_mdoc_foot(struct termp *p, const void *arg)

{

const struct mdoc_meta *meta;

size_t sz;

meta = (const struct mdoc_meta *)arg;

Line 411 print_mdoc_foot(struct termp *p, const void *arg)

Line 424 print_mdoc_foot(struct termp *p, const void *arg)

term_vspace(p);

p->offset = 0;

p->rmargin = (p->maxrmargin -

sz = term_strlen(p, meta->date);

term_strlen(p, meta->date) + term_len(p, 1)) / 2;

p->rmargin = p->maxrmargin > sz ?

(p->maxrmargin + term_len(p, 1) - sz) / 2 : 0;

p->trailspace = 1;

p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;

Line 420 print_mdoc_foot(struct termp *p, const void *arg)

Line 434 print_mdoc_foot(struct termp *p, const void *arg)

term_flushln(p);

p->offset = p->rmargin;

p->rmargin = p->maxrmargin - term_strlen(p, meta->os);

sz = term_strlen(p, meta->os);

p->rmargin = p->maxrmargin > sz ? p->maxrmargin - sz : 0;

p->flags |= TERMP_NOSPACE;

term_word(p, meta->date);

Line 462 print_mdoc_head(struct termp *p, const void *arg)

Line 477 print_mdoc_head(struct termp *p, const void *arg)

* switches on the manual section.

p->offset = 0;

p->rmargin = p->maxrmargin;

assert(meta->vol);

if (NULL == meta->arch)

volume = mandoc_strdup(meta->vol);

Line 473 print_mdoc_head(struct termp *p, const void *arg)

Line 485 print_mdoc_head(struct termp *p, const void *arg)

meta->vol, meta->arch);

vollen = term_strlen(p, volume);

mandoc_asprintf(&title, "%s(%s)", meta->title, meta->msec);

if (NULL == meta->msec)

title = mandoc_strdup(meta->title);

else

mandoc_asprintf(&title, "%s(%s)",

meta->title, meta->msec);

titlen = term_strlen(p, title);

p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;

Line 481 print_mdoc_head(struct termp *p, const void *arg)

Line 497 print_mdoc_head(struct termp *p, const void *arg)

p->offset = 0;

p->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ?

(p->maxrmargin - vollen + term_len(p, 1)) / 2 :

p->maxrmargin - vollen;

vollen < p->maxrmargin ? p->maxrmargin - vollen : 0;

term_word(p, title);

term_flushln(p);

Line 511 print_mdoc_head(struct termp *p, const void *arg)

Line 527 print_mdoc_head(struct termp *p, const void *arg)

free(volume);

}

static size_t

static int

a2height(const struct termp *p, const char *v)

{

struct roffsu su;

assert(v);

if ( ! a2roffsu(v, &su, SCALE_VS))

SCALE_VS_INIT(&su, atoi(v));

return(term_vspan(p, &su));

}

static size_t

a2width(const struct termp *p, const char *v)

{

struct roffsu su;

assert(v);

if (a2roffsu(v, &su, SCALE_MAX) < 2) {

if ( ! a2roffsu(v, &su, SCALE_MAX))

SCALE_HS_INIT(&su, term_strlen(p, v));

su.scale /= term_strlen(p, "0");

}

return(term_hspan(p, &su));

}

static size_t

a2offs(const struct termp *p, const char *v)

{

struct roffsu su;

if ('\0' == *v)

return(0);

else if (0 == strcmp(v, "left"))

return(0);

else if (0 == strcmp(v, "indent"))

return(term_len(p, p->defindent + 1));

else if (0 == strcmp(v, "indent-two"))

return(term_len(p, (p->defindent + 1) * 2));

else if ( ! a2roffsu(v, &su, SCALE_MAX))

SCALE_HS_INIT(&su, term_strlen(p, v));

return(term_hspan(p, &su));

}

* Determine how much space to print out before block elements of `It'

* (and thus `Bl') and `Bd'. And then go ahead and print that space,

Line 578 print_bvspace(struct termp *p,

Line 562 print_bvspace(struct termp *p,

/* Do not vspace directly after Ss/Sh. */

for (nn = n; nn; nn = nn->parent) {

nn = n;

if (MDOC_BLOCK != nn->type)

while (nn->prev == NULL) {

continue;

do {

if (MDOC_Ss == nn->tok)

nn = nn->parent;

if (nn->type == MDOC_ROOT)

return;

} while (nn->type != MDOC_BLOCK);

if (nn->tok == MDOC_Sh || nn->tok == MDOC_Ss)

return;

if (MDOC_Sh == nn->tok)

if (nn->tok == MDOC_It &&

return;

nn->parent->parent->norm->Bl.type != LIST_item)

if (NULL == nn->prev)

break;

continue;

break;

}

/* A `-column' does not assert vspace within the list. */

Line 620 termp_ll_pre(DECL_ARGS)

Line 606 termp_ll_pre(DECL_ARGS)

static int

termp_it_pre(DECL_ARGS)

{

const struct mdoc_node *bl, *nn;

char buf[24];

int i;

const struct mdoc_node *bl, *nn;

size_t width, offset, ncols, dcol;

size_t ncols, dcol;

int i, offset, width;

enum mdoc_list type;

if (MDOC_BLOCK == n->type) {

Line 635 termp_it_pre(DECL_ARGS)

Line 621 termp_it_pre(DECL_ARGS)

type = bl->norm->Bl.type;

* Defaults for specific list types.

switch (type) {

case LIST_bullet:

/* FALLTHROUGH */

case LIST_dash:

/* FALLTHROUGH */

case LIST_hyphen:

/* FALLTHROUGH */

case LIST_enum:

width = term_len(p, 2);

break;

case LIST_hang:

width = term_len(p, 8);

break;

case LIST_column:

/* FALLTHROUGH */

case LIST_tag:

width = term_len(p, 10);

break;

default:

width = 0;

break;

}

offset = 0;

* First calculate width and offset. This is pretty easy unless

* we're a -column list, in which case all prior columns must

* be accounted for.

width = offset = 0;

if (bl->norm->Bl.offs != NULL) {

offset = a2width(p, bl->norm->Bl.offs);

if (offset < 0 && (size_t)(-offset) > p->offset)

offset = -p->offset;

else if (offset > SHRT_MAX)

offset = 0;

}

if (bl->norm->Bl.offs)

offset = a2offs(p, bl->norm->Bl.offs);

switch (type) {

case LIST_column:

if (MDOC_HEAD == n->type)

Line 698 termp_it_pre(DECL_ARGS)

Line 715 termp_it_pre(DECL_ARGS)

* number for buffering single arguments. See the above

* handling for column for how this changes.

assert(bl->norm->Bl.width);

width = a2width(p, bl->norm->Bl.width) + term_len(p, 2);

if (width < 0 && (size_t)(-width) > p->offset)

width = -p->offset;

else if (width > SHRT_MAX)

width = 0;

break;

}

* List-type can override the width in the case of fixed-head

* values (bullet, dash/hyphen, enum). Tags need a non-zero

* offset.

switch (type) {

case LIST_bullet:

/* FALLTHROUGH */

case LIST_dash:

/* FALLTHROUGH */

case LIST_hyphen:

/* FALLTHROUGH */

case LIST_enum:

if (width < term_len(p, 2))

width = term_len(p, 2);

break;

case LIST_hang:

if (0 == width)

width = term_len(p, 8);

break;

case LIST_column:

/* FALLTHROUGH */

case LIST_tag:

if (0 == width)

width = term_len(p, 10);

break;

default:

break;

}

* Whitespace control. Inset bodies need an initial space,

* while diagonal bodies need two.

Line 747 termp_it_pre(DECL_ARGS)

Line 736 termp_it_pre(DECL_ARGS)

term_word(p, "\\ \\ ");

break;

case LIST_inset:

if (MDOC_BODY == n->type)

if (MDOC_BODY == n->type && n->parent->head->nchild)

term_word(p, "\\ ");

break;

default:

Line 776 termp_it_pre(DECL_ARGS)

Line 765 termp_it_pre(DECL_ARGS)

case LIST_enum:

* Weird special case.

* Very narrow enum lists actually hang.

* Some very narrow lists actually hang.

if (width == term_len(p, 2))

p->flags |= TERMP_HANG;

/* FALLTHROUGH */

case LIST_bullet:

/* FALLTHROUGH */

case LIST_dash:

/* FALLTHROUGH */

case LIST_hyphen:

if (width <= (int)term_len(p, 2))

p->flags |= TERMP_HANG;

if (MDOC_HEAD != n->type)

break;

p->flags |= TERMP_NOBREAK;

Line 801 termp_it_pre(DECL_ARGS)

Line 790 termp_it_pre(DECL_ARGS)

* the "overstep" effect in term_flushln() and treat

* this as a `-ohang' list instead.

if (n->next->child &&

if (NULL != n->next &&

NULL != n->next->child &&

(MDOC_Bl == n->next->child->tok ||

MDOC_Bd == n->next->child->tok))

break;

Line 857 termp_it_pre(DECL_ARGS)

Line 847 termp_it_pre(DECL_ARGS)

* don't want to recalculate rmargin and offsets when

* using `Bd' or `Bl' within `-hang' overstep lists.

if (MDOC_HEAD == n->type && n->next->child &&

if (MDOC_HEAD == n->type &&

NULL != n->next &&

NULL != n->next->child &&

(MDOC_Bl == n->next->child->tok ||

MDOC_Bd == n->next->child->tok))

break;

Line 871 termp_it_pre(DECL_ARGS)

Line 863 termp_it_pre(DECL_ARGS)

case LIST_hyphen:

/* FALLTHROUGH */

case LIST_tag:

assert(width);

if (MDOC_HEAD == n->type)

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

else {

else

p->offset += width;

if (p->rmargin < p->offset)

p->rmargin = p->offset;

}

break;

case LIST_column:

assert(width);

Line 995 termp_it_post(DECL_ARGS)

Line 983 termp_it_post(DECL_ARGS)

static int

termp_nm_pre(DECL_ARGS)

{

const char *cp;

if (MDOC_BLOCK == n->type) {

p->flags |= TERMP_PREKEEP;

Line 1005 termp_nm_pre(DECL_ARGS)

Line 994 termp_nm_pre(DECL_ARGS)

if (NULL == n->child)

return(0);

p->flags |= TERMP_NOSPACE;

p->offset += term_len(p, 1) +

cp = NULL;

(NULL == n->prev->child ?

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

term_strlen(p, meta->name) :

cp = n->prev->child->string;

MDOC_TEXT == n->prev->child->type ?

if (cp == NULL)

term_strlen(p, n->prev->child->string) :

cp = meta->name;

term_len(p, 5));

if (cp == NULL)

if (p->rmargin < p->offset)

p->offset += term_len(p, 6);

p->rmargin = p->offset;

else

p->offset += term_len(p, 1) + term_strlen(p, cp);

return(1);

}

Line 1022 termp_nm_pre(DECL_ARGS)

Line 1012 termp_nm_pre(DECL_ARGS)

if (MDOC_HEAD == n->type)

synopsis_pre(p, n->parent);

if (MDOC_HEAD == n->type && n->next->child) {

if (MDOC_HEAD == n->type &&

NULL != n->next && NULL != n->next->child) {

p->flags |= TERMP_NOSPACE | TERMP_NOBREAK | TERMP_BRIND;

p->trailspace = 1;

p->rmargin = p->offset + term_len(p, 1);

Line 1050 termp_nm_post(DECL_ARGS)

Line 1041 termp_nm_post(DECL_ARGS)

if (MDOC_BLOCK == n->type) {

p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);

} else if (MDOC_HEAD == n->type && n->next->child) {

} else if (MDOC_HEAD == n->type &&

NULL != n->next && NULL != n->next->child) {

term_flushln(p);

p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG);

p->trailspace = 0;

Line 1065 termp_fl_pre(DECL_ARGS)

Line 1057 termp_fl_pre(DECL_ARGS)

term_fontpush(p, TERMFONT_BOLD);

term_word(p, "\\-");

if (n->child)

if ( ! (n->nchild == 0 &&

(n->next == NULL ||

n->next->type == MDOC_TEXT ||

n->next->flags & MDOC_LINE)))

p->flags |= TERMP_NOSPACE;

else if (n->next && n->next->line == n->line)

p->flags |= TERMP_NOSPACE;

return(1);

}

Line 1088 static int

Line 1081 static int

termp_an_pre(DECL_ARGS)

{

if (NULL == n->child)

if (n->norm->An.auth == AUTH_split) {

return(1);

* If not in the AUTHORS section, `An -split' will cause

* newlines to occur before the author name. If in the AUTHORS

* section, by default, the first `An' invocation is nosplit,

* then all subsequent ones, regardless of whether interspersed

* with other macros/text, are split. -split, in this case,

* will override the condition of the implied first -nosplit.

if (n->sec == SEC_AUTHORS) {

if ( ! (TERMP_ANPREC & p->flags)) {

if (TERMP_SPLIT & p->flags)

term_newln(p);

return(1);

}

if (TERMP_NOSPLIT & p->flags)

return(1);

term_newln(p);

return(1);

}

if (TERMP_SPLIT & p->flags)

term_newln(p);

return(1);

}

static void

termp_an_post(DECL_ARGS)

{

if (n->child) {

if (SEC_AUTHORS == n->sec)

p->flags |= TERMP_ANPREC;

return;

}

if (AUTH_split == n->norm->An.auth) {

p->flags &= ~TERMP_NOSPLIT;

p->flags |= TERMP_SPLIT;

} else if (AUTH_nosplit == n->norm->An.auth) {

return(0);

}

if (n->norm->An.auth == AUTH_nosplit) {

p->flags &= ~TERMP_SPLIT;

p->flags |= TERMP_NOSPLIT;

return(0);

}

if (p->flags & TERMP_SPLIT)

term_newln(p);

if (n->sec == SEC_AUTHORS && ! (p->flags & TERMP_NOSPLIT))

p->flags |= TERMP_SPLIT;

return(1);

}

static int

Line 1164 termp_rv_pre(DECL_ARGS)

Line 1127 termp_rv_pre(DECL_ARGS)

int nchild;

term_newln(p);

term_word(p, "The");

nchild = n->nchild;

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

if (nchild > 0) {

term_fontpush(p, TERMFONT_BOLD);

term_word(p, "The");

term_word(p, n->string);

term_fontpop(p);

p->flags |= TERMP_NOSPACE;

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

term_word(p, "()");

term_fontpush(p, TERMFONT_BOLD);

term_word(p, n->string);

term_fontpop(p);

if (nchild > 2 && n->next) {

p->flags |= TERMP_NOSPACE;

term_word(p, ",");

term_word(p, "()");

if (n->next == NULL)

continue;

if (nchild > 2) {

p->flags |= TERMP_NOSPACE;

term_word(p, ",");

}

if (n->next->next == NULL)

term_word(p, "and");

}

if (n->next && NULL == n->next->next)

if (nchild > 1)

term_word(p, "and");

term_word(p, "functions return");

}

else

term_word(p, "function returns");

if (nchild > 1)

term_word(p, "the value\\~0 if successful;");

term_word(p, "functions return");

} else

else

term_word(p, "Upon successful completion,"

term_word(p, "function returns");

" the value\\~0 is returned;");

term_word(p, "the value 0 if successful; otherwise the "

term_word(p, "otherwise the value\\~\\-1 is returned"

"value -1 is returned and the global variable");

" and the global variable");

term_fontpush(p, TERMFONT_UNDER);

term_word(p, "errno");

Line 1226 termp_ex_pre(DECL_ARGS)

Line 1198 termp_ex_pre(DECL_ARGS)

}

if (nchild > 1)

term_word(p, "utilities exit");

term_word(p, "utilities exit\\~0");

else

term_word(p, "utility exits");

term_word(p, "utility exits\\~0");

term_word(p, "0 on success, and >0 if an error occurs.");

term_word(p, "on success, and\\~>0 if an error occurs.");

p->flags |= TERMP_SENTENCE;

return(0);

Line 1240 static int

Line 1212 static int

termp_nd_pre(DECL_ARGS)

{

if (MDOC_BODY != n->type)

if (n->type == MDOC_BODY)

return(1);

term_word(p, "\\(en");

#if defined(__OpenBSD__) || defined(__linux__)

term_word(p, "\\(en");

#else

term_word(p, "\\(em");

#endif

return(1);

}

Line 1392 static int

Line 1358 static int

termp_sh_pre(DECL_ARGS)

{

/* No vspace between consecutive `Sh' calls. */

switch (n->type) {

case MDOC_BLOCK:

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

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

* Vertical space before sections, except

break;

* when the previous section was empty.

term_vspace(p);

if (n->prev == NULL ||

MDOC_Sh != n->prev->tok ||

(n->prev->body != NULL &&

n->prev->body->child != NULL))

term_vspace(p);

break;

case MDOC_HEAD:

term_fontpush(p, TERMFONT_BOLD);

Line 1568 termp_fa_pre(DECL_ARGS)

Line 1537 termp_fa_pre(DECL_ARGS)

static int

termp_bd_pre(DECL_ARGS)

{

size_t tabwidth, rm, rmax;

size_t tabwidth, lm, len, rm, rmax;

struct mdoc_node *nn;

int offset;

if (MDOC_BLOCK == n->type) {

print_bvspace(p, n, n);

Line 1577 termp_bd_pre(DECL_ARGS)

Line 1547 termp_bd_pre(DECL_ARGS)

} else if (MDOC_HEAD == n->type)

return(0);

if (n->norm->Bd.offs)

/* Handle the -offset argument. */

p->offset += a2offs(p, n->norm->Bd.offs);

if (n->norm->Bd.offs == NULL ||

! strcmp(n->norm->Bd.offs, "left"))

/* nothing */;

else if ( ! strcmp(n->norm->Bd.offs, "indent"))

p->offset += term_len(p, p->defindent + 1);

else if ( ! strcmp(n->norm->Bd.offs, "indent-two"))

p->offset += term_len(p, (p->defindent + 1) * 2);

else {

offset = a2width(p, n->norm->Bd.offs);

if (offset < 0 && (size_t)(-offset) > p->offset)

p->offset = 0;

else if (offset < SHRT_MAX)

p->offset += offset;

}

* If -ragged or -filled are specified, the block does nothing

* but change the indentation. If -unfilled or -literal are

Line 1589 termp_bd_pre(DECL_ARGS)

Line 1573 termp_bd_pre(DECL_ARGS)

if (DISP_literal != n->norm->Bd.type &&

DISP_unfilled != n->norm->Bd.type)

DISP_unfilled != n->norm->Bd.type &&

DISP_centered != n->norm->Bd.type)

return(1);

tabwidth = p->tabwidth;

if (DISP_literal == n->norm->Bd.type)

p->tabwidth = term_len(p, 8);

lm = p->offset;

rm = p->rmargin;

rmax = p->maxrmargin;

p->rmargin = p->maxrmargin = TERM_MAXMARGIN;

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

if (DISP_centered == n->norm->Bd.type) {

if (MDOC_TEXT == nn->type) {

len = term_strlen(p, nn->string);

p->offset = len >= rm ? 0 :

lm + len >= rm ? rm - len :

(lm + rm - len) / 2;

} else

p->offset = lm;

}

print_mdoc_node(p, pair, meta, nn);

* If the printed node flushes its own line, then we

Line 1628 termp_bd_pre(DECL_ARGS)

Line 1623 termp_bd_pre(DECL_ARGS)

default:

break;

}

if (nn->next && nn->next->line == nn->line)

if (p->flags & TERMP_NONEWLINE ||

(nn->next && ! (nn->next->flags & MDOC_LINE)))

continue;

term_flushln(p);

p->flags |= TERMP_NOSPACE;

Line 1730 static void

Line 1726 static void

termp_pf_post(DECL_ARGS)

{

p->flags |= TERMP_NOSPACE;

if ( ! (n->next == NULL || n->next->flags & MDOC_LINE))

p->flags |= TERMP_NOSPACE;

}

static int

Line 1747 termp_ss_pre(DECL_ARGS)

Line 1744 termp_ss_pre(DECL_ARGS)

term_fontpush(p, TERMFONT_BOLD);

p->offset = term_len(p, (p->defindent+1)/2);

break;

case MDOC_BODY:

p->offset = term_len(p, p->defindent);

break;

default:

break;

}

Line 1758 static void

termp_ss_post(DECL_ARGS)

{

if (MDOC_HEAD == n->type)

if (n->type == MDOC_HEAD || n->type == MDOC_BODY)

term_newln(p);

}

Line 1807 termp_in_post(DECL_ARGS)

static int

termp_sp_pre(DECL_ARGS)

{

size_t i, len;

struct roffsu su;

int i, len;

switch (n->tok) {

case MDOC_sp:

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

if (n->child) {

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

su.scale = 1.0;

len = term_vspan(p, &su);

} else

len = 1;

break;

case MDOC_br:

len = 0;

Line 1823 termp_sp_pre(DECL_ARGS)

Line 1829 termp_sp_pre(DECL_ARGS)

if (0 == len)

term_newln(p);

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

else if (len < 0)

term_vspace(p);

p->skipvsp -= len;

else

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

term_vspace(p);

return(0);

}

static int

termp_es_pre(DECL_ARGS)

termp_skip_pre(DECL_ARGS)

{

return(0);

Line 1847 termp_quote_pre(DECL_ARGS)

Line 1856 termp_quote_pre(DECL_ARGS)

case MDOC_Ao:

/* FALLTHROUGH */

case MDOC_Aq:

term_word(p, "<");

term_word(p, n->nchild == 1 &&

n->child->tok == MDOC_Mt ? "<" : "\\(la");

break;

case MDOC_Bro:

/* FALLTHROUGH */

Line 1866 termp_quote_pre(DECL_ARGS)

Line 1876 termp_quote_pre(DECL_ARGS)

case MDOC_Do:

/* FALLTHROUGH */

case MDOC_Dq:

term_word(p, "\\(lq");

term_word(p, "\\(Lq");

break;

case MDOC_En:

if (NULL == n->norm->Es ||

Line 1874 termp_quote_pre(DECL_ARGS)

Line 1884 termp_quote_pre(DECL_ARGS)

return(1);

term_word(p, n->norm->Es->child->string);

break;

case MDOC_Eo:

break;

case MDOC_Po:

/* FALLTHROUGH */

case MDOC_Pq:

Line 1908 static void

Line 1916 static void

termp_quote_post(DECL_ARGS)

{

if (MDOC_BODY != n->type && MDOC_ELEM != n->type)

if (n->type != MDOC_BODY && n->type != MDOC_ELEM)

return;

if (MDOC_En != n->tok)

p->flags |= TERMP_NOSPACE;

switch (n->tok) {

case MDOC_Ao:

/* FALLTHROUGH */

case MDOC_Aq:

term_word(p, ">");

term_word(p, n->nchild == 1 &&

n->child->tok == MDOC_Mt ? ">" : "\\(ra");

break;

case MDOC_Bro:

/* FALLTHROUGH */

Line 1937 termp_quote_post(DECL_ARGS)

Line 1945 termp_quote_post(DECL_ARGS)

case MDOC_Do:

/* FALLTHROUGH */

case MDOC_Dq:

term_word(p, "\\(rq");

term_word(p, "\\(Rq");

break;

case MDOC_En:

if (NULL != n->norm->Es &&

if (n->norm->Es == NULL ||

NULL != n->norm->Es->child &&

n->norm->Es->child == NULL ||

NULL != n->norm->Es->child->next) {

n->norm->Es->child->next == NULL)

p->flags |= TERMP_NOSPACE;

p->flags &= ~TERMP_NOSPACE;

else

term_word(p, n->norm->Es->child->next->string);

}

break;

case MDOC_Eo:

break;

case MDOC_Po:

/* FALLTHROUGH */

case MDOC_Pq:

Line 1975 termp_quote_post(DECL_ARGS)

Line 1981 termp_quote_post(DECL_ARGS)

}

static int

termp_eo_pre(DECL_ARGS)

{

if (n->type != MDOC_BODY)

return(1);

if (n->end == ENDBODY_NOT &&

n->parent->head->child == NULL &&

n->child != NULL &&

n->child->end != ENDBODY_NOT)

term_word(p, "\\&");

else if (n->end != ENDBODY_NOT ? n->child != NULL :

n->parent->head->child != NULL && (n->child != NULL ||

(n->parent->tail != NULL && n->parent->tail->child != NULL)))

p->flags |= TERMP_NOSPACE;

return(1);

}

static void

termp_eo_post(DECL_ARGS)

{

int body, tail;

if (n->type != MDOC_BODY)

return;

if (n->end != ENDBODY_NOT) {

p->flags &= ~TERMP_NOSPACE;

return;

}

body = n->child != NULL || n->parent->head->child != NULL;

tail = n->parent->tail != NULL && n->parent->tail->child != NULL;

if (body && tail)

p->flags |= TERMP_NOSPACE;

else if ( ! (body || tail))

term_word(p, "\\&");

else if ( ! tail)

p->flags &= ~TERMP_NOSPACE;

}

static int

termp_fo_pre(DECL_ARGS)

{

size_t rmargin = 0;

Line 2056 static int

Line 2106 static int

termp_sm_pre(DECL_ARGS)

{

assert(n->child && MDOC_TEXT == n->child->type);

if (NULL == n->child)

if (0 == strcmp("on", n->child->string)) {

p->flags ^= TERMP_NONOSPACE;

if (p->col)

else if (0 == strcmp("on", n->child->string))

p->flags &= ~TERMP_NOSPACE;

p->flags &= ~TERMP_NONOSPACE;

} else

else

p->flags |= TERMP_NONOSPACE;

if (p->col && ! (TERMP_NONOSPACE & p->flags))

p->flags &= ~TERMP_NOSPACE;

return(0);

}

CVSweb