mandoc/out.c - diff

Return to out.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/out.c between version 1.57 and 1.69

version 1.57, 2014/12/23 13:48:57

version 1.69, 2017/06/15 00:27:52

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 29

#include "out.h"

static void tblcalc_data(struct rofftbl *, struct roffcol *,

const struct tbl_opts *, const struct tbl_dat *);

const struct tbl_opts *, const struct tbl_dat *,

size_t);

static void tblcalc_literal(struct rofftbl *, struct roffcol *,

const struct tbl_dat *);

const struct tbl_dat *, size_t);

static void tblcalc_number(struct rofftbl *, struct roffcol *,

const struct tbl_opts *, const struct tbl_dat *);

Line 40 static void tblcalc_number(struct rofftbl *, struct ro

Line 41 static void tblcalc_number(struct rofftbl *, struct ro

* Parse the *src string and store a scaling unit into *dst.

* If the string doesn't specify the unit, use the default.

* If no default is specified, fail.

* Return 2 on complete success, 1 when a conversion was done,

* Return a pointer to the byte after the last byte used,

* but there was trailing garbage, and 0 on total failure.

* or NULL on total failure.

int

const char *

a2roffsu(const char *src, struct roffsu *dst, enum roffscale def)

{

char *endptr;

Line 51 a2roffsu(const char *src, struct roffsu *dst, enum rof

Line 52 a2roffsu(const char *src, struct roffsu *dst, enum rof

dst->unit = def == SCALE_MAX ? SCALE_BU : def;

dst->scale = strtod(src, &endptr);

if (endptr == src)

return(0);

return NULL;

switch (*endptr++) {

case 'c':

Line 84 a2roffsu(const char *src, struct roffsu *dst, enum rof

Line 85 a2roffsu(const char *src, struct roffsu *dst, enum rof

case 'v':

dst->unit = SCALE_VS;

break;

case '\0':

endptr--;

/* FALLTHROUGH */

default:

endptr--;

if (SCALE_MAX == def)

return(0);

return NULL;

dst->unit = def;

break;

}

return endptr;

return(*endptr == '\0' ? 2 : 1);

}

Line 105 a2roffsu(const char *src, struct roffsu *dst, enum rof

Line 103 a2roffsu(const char *src, struct roffsu *dst, enum rof

void

tblcalc(struct rofftbl *tbl, const struct tbl_span *sp,

size_t totalwidth)

size_t offset, size_t rmargin)

{

struct roffsu su;

const struct tbl_opts *opts;

const struct tbl_dat *dp;

struct roffcol *col;

size_t ewidth, xwidth;

int spans;

int icol, maxcol, necol, nxcol;

int icol, maxcol, necol, nxcol, quirkcol;

* Allocate the master column specifiers. These will hold the

Line 122 tblcalc(struct rofftbl *tbl, const struct tbl_span *sp

assert(NULL == tbl->cols);

tbl->cols = mandoc_calloc((size_t)sp->opts->cols,

sizeof(struct roffcol));

opts = sp->opts;

for (maxcol = -1; sp; sp = sp->next) {

if (TBL_SPAN_DATA != sp->pos)

Line 138 tblcalc(struct rofftbl *tbl, const struct tbl_span *sp

Line 139 tblcalc(struct rofftbl *tbl, const struct tbl_span *sp

spans = dp->spans;

if (1 < spans)

continue;

icol = dp->layout->head->ident;

icol = dp->layout->col;

if (maxcol < icol)

maxcol = icol;

col = tbl->cols + icol;

col->flags |= dp->layout->flags;

if (dp->layout->flags & TBL_CELL_WIGN)

continue;

tblcalc_data(tbl, col, sp->opts, dp);

if (dp->layout->wstr != NULL &&

dp->layout->width == 0 &&

a2roffsu(dp->layout->wstr, &su, SCALE_EN)

!= NULL)

dp->layout->width =

(*tbl->sulen)(&su, tbl->arg);

if (col->width < dp->layout->width)

col->width = dp->layout->width;

tblcalc_data(tbl, col, opts, dp,

dp->block == 0 ? 0 :

dp->layout->width ? dp->layout->width :

rmargin ? (rmargin + sp->opts->cols / 2)

/ (sp->opts->cols + 1) : 0);

}

Line 182 tblcalc(struct rofftbl *tbl, const struct tbl_span *sp

Line 195 tblcalc(struct rofftbl *tbl, const struct tbl_span *sp

continue;

if (col->width == ewidth)

continue;

if (nxcol && totalwidth)

if (nxcol && rmargin)

xwidth += ewidth - col->width;

col->width = ewidth;

}

Line 194 tblcalc(struct rofftbl *tbl, const struct tbl_span *sp

Line 207 tblcalc(struct rofftbl *tbl, const struct tbl_span *sp

* Distribute the available width evenly.

if (nxcol && totalwidth) {

if (nxcol && rmargin) {

xwidth = totalwidth - 3*maxcol - xwidth;

xwidth += 3*maxcol +

(opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX) ?

2 : !!opts->lvert + !!opts->rvert);

if (rmargin <= offset + xwidth)

return;

xwidth = rmargin - offset - xwidth;

* Emulate a bug in GNU tbl width calculation that

* manifests itself for large numbers of x-columns.

* Emulating it for 5 x-columns gives identical

* behaviour for up to 6 x-columns.

if (nxcol == 5) {

quirkcol = xwidth % nxcol + 2;

if (quirkcol != 3 && quirkcol != 4)

quirkcol = -1;

} else

quirkcol = -1;

necol = 0;

ewidth = 0;

for (icol = 0; icol <= maxcol; icol++) {

col = tbl->cols + icol;

if ( ! (col->flags & TBL_CELL_WMAX))

continue;

col->width = xwidth / nxcol--;

col->width = (double)xwidth * ++necol / nxcol

xwidth -= col->width;

- ewidth + 0.4995;

if (necol == quirkcol)

col->width--;

ewidth += col->width;

}

static void

tblcalc_data(struct rofftbl *tbl, struct roffcol *col,

const struct tbl_opts *opts, const struct tbl_dat *dp)

const struct tbl_opts *opts, const struct tbl_dat *dp, size_t mw)

{

size_t sz;

Line 216 tblcalc_data(struct rofftbl *tbl, struct roffcol *col,

Line 254 tblcalc_data(struct rofftbl *tbl, struct roffcol *col,

switch (dp->layout->pos) {

case TBL_CELL_HORIZ:

/* FALLTHROUGH */

case TBL_CELL_DHORIZ:

sz = (*tbl->len)(1, tbl->arg);

if (col->width < sz)

col->width = sz;

break;

case TBL_CELL_LONG:

/* FALLTHROUGH */

case TBL_CELL_CENTRE:

/* FALLTHROUGH */

case TBL_CELL_LEFT:

/* FALLTHROUGH */

case TBL_CELL_RIGHT:

tblcalc_literal(tbl, col, dp);

tblcalc_literal(tbl, col, dp, mw);

break;

case TBL_CELL_NUMBER:

tblcalc_number(tbl, col, opts, dp);

Line 238 tblcalc_data(struct rofftbl *tbl, struct roffcol *col,

Line 272 tblcalc_data(struct rofftbl *tbl, struct roffcol *col,

break;

default:

abort();

/* NOTREACHED */

}

static void

tblcalc_literal(struct rofftbl *tbl, struct roffcol *col,

const struct tbl_dat *dp)

const struct tbl_dat *dp, size_t mw)

{

size_t sz;

const char *str; /* Beginning of the first line. */

const char *str;

const char *beg; /* Beginning of the current line. */

char *end; /* End of the current line. */

size_t lsz; /* Length of the current line. */

size_t wsz; /* Length of the current word. */

str = dp->string ? dp->string : "";

if (dp->string == NULL || *dp->string == '\0')

sz = (*tbl->slen)(str, tbl->arg);

return;

str = mw ? mandoc_strdup(dp->string) : dp->string;

if (col->width < sz)

lsz = 0;

col->width = sz;

for (beg = str; beg != NULL && *beg != '\0'; beg = end) {

end = mw ? strchr(beg, ' ') : NULL;

if (end != NULL) {

*end++ = '\0';

while (*end == ' ')

end++;

}

wsz = (*tbl->slen)(beg, tbl->arg);

if (mw && lsz && lsz + 1 + wsz <= mw)

lsz += 1 + wsz;

else

lsz = wsz;

if (col->width < lsz)

col->width = lsz;

}

if (mw)

free((void *)str);

}

static void

CVSweb