mandoc/tbl_term.c - diff

Return to tbl_term.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/tbl_term.c between version 1.10 and 1.11

version 1.10, 2011/01/04 15:02:00

version 1.11, 2011/01/05 15:37:23

Line 30

/* FIXME: `n' modifier doesn't always do the right thing. */

/* FIXME: `n' modifier doesn't use the cell-spacing buffer. */

static inline void tbl_char(struct termp *, char, int);

static size_t term_tbl_len(size_t, void *);

static void tbl_hframe(struct termp *,

static size_t term_tbl_strlen(const char *, void *);

const struct tbl_span *);

static void tbl_char(struct termp *, char, int);

static void tbl_data_number(struct termp *,

static void tbl_data(struct termp *, const struct tbl *,

const struct tbl *,

const struct tbl_dat *,

const struct roffcol *);

const struct termp_tbl *);

static void tbl_hframe(struct termp *, const struct tbl_span *);

static void tbl_data_literal(struct termp *,

static void tbl_literal(struct termp *, const struct tbl_dat *,

const struct tbl_dat *,

const struct roffcol *);

const struct termp_tbl *);

static void tbl_number(struct termp *, const struct tbl *,

static void tbl_data(struct termp *, const struct tbl *,

const struct tbl_dat *,

const struct roffcol *);

const struct termp_tbl *);

static void tbl_hrule(struct termp *, const struct tbl_span *);

static void tbl_spanner(struct termp *,

static void tbl_vframe(struct termp *, const struct tbl *);

const struct tbl_head *);

static void tbl_vrule(struct termp *, const struct tbl_head *);

static void tbl_hrule(struct termp *,

const struct tbl_span *);

static void tbl_vframe(struct termp *,

const struct tbl *);

static void tbl_calc(struct termp *,

const struct tbl_span *);

static void tbl_calc_data(struct termp *,

const struct tbl *,

const struct tbl_dat *,

struct termp_tbl *);

static void tbl_calc_data_literal(struct termp *,

const struct tbl_dat *,

struct termp_tbl *);

static void tbl_calc_data_number(struct termp *,

const struct tbl *,

const struct tbl_dat *,

struct termp_tbl *);

static size_t

term_tbl_strlen(const char *p, void *arg)

{

return(term_strlen((const struct termp *)arg, p));

}

static size_t

term_tbl_len(size_t sz, void *arg)

{

return(term_len((const struct termp *)arg, sz));

}

void

term_tbl(struct termp *tp, const struct tbl_span *sp)

{

const struct tbl_head *hp;

const struct tbl_dat *dp;

struct roffcol *col;

int rmargin, maxrmargin;

rmargin = tp->rmargin;

maxrmargin = tp->maxrmargin;

tp->rmargin = tp->maxrmargin = TERM_MAXMARGIN;

/* Inhibit printing of spaces: we do padding ourselves. */

tp->flags |= TERMP_NONOSPACE;

tp->flags |= TERMP_NOSPACE;

* The first time we're invoked for a given table block, create

* The first time we're invoked for a given table block,

* the termp_tbl structure. This contains the column

* calculate the table widths and decimal positions.

* configuration for the entire table, e.g., table-wide column

* width, decimal point, etc.

if (TBL_SPAN_FIRST & sp->flags) {

assert(NULL == tp->tbl);

tp->tbl = calloc

(sp->tbl->cols, sizeof(struct termp_tbl));

if (NULL == tp->tbl) {

perror(NULL);

exit(EXIT_FAILURE);

}

tbl_calc(tp, sp);

/* Flush out any preceding data. */

term_flushln(tp);

tp->tbl.len = term_tbl_len;

tp->tbl.slen = term_tbl_strlen;

tp->tbl.arg = tp;

tblcalc(&tp->tbl, sp);

}

/* Horizontal frame at the start of boxed tables. */

Line 124 term_tbl(struct termp *tp, const struct tbl_span *sp)

Line 123 term_tbl(struct termp *tp, const struct tbl_span *sp)

case (TBL_HEAD_VERT):

/* FALLTHROUGH */

case (TBL_HEAD_DVERT):

tbl_spanner(tp, hp);

tbl_vrule(tp, hp);

continue;

case (TBL_HEAD_DATA):

break;

}

tbl_data(tp, sp->tbl, dp,

&tp->tbl[hp->ident]);

col = &tp->tbl.cols[hp->ident];

tbl_data(tp, sp->tbl, dp, col);

/* Go to the next data cell. */

if (dp)

dp = dp->next;

Line 149 term_tbl(struct termp *tp, const struct tbl_span *sp)

if (TBL_SPAN_LAST & sp->flags) {

tbl_hframe(tp, sp);

assert(tp->tbl);

assert(tp->tbl.cols);

free(tp->tbl);

free(tp->tbl.cols);

tp->tbl = NULL;

tp->tbl.cols = NULL;

}

tp->flags &= ~TERMP_NONOSPACE;

tp->rmargin = rmargin;

tp->maxrmargin = maxrmargin;

}

Line 178 tbl_hrule(struct termp *tp, const struct tbl_span *sp)

Line 180 tbl_hrule(struct termp *tp, const struct tbl_span *sp)

/* FIXME: don't use `+' between data and a spanner! */

for (hp = sp->head; hp; hp = hp->next) {

width = tp->tbl[hp->ident].width;

width = tp->tbl.cols[hp->ident].width;

switch (hp->pos) {

case (TBL_HEAD_DATA):

tbl_char(tp, c, width);

Line 217 tbl_hframe(struct termp *tp, const struct tbl_span *sp

Line 219 tbl_hframe(struct termp *tp, const struct tbl_span *sp

if (TBL_OPT_DBOX & sp->tbl->opts) {

term_word(tp, "+");

for (hp = sp->head; hp; hp = hp->next) {

width = tp->tbl[hp->ident].width;

width = tp->tbl.cols[hp->ident].width;

tbl_char(tp, '-', width);

}

term_word(tp, "+");

Line 226 tbl_hframe(struct termp *tp, const struct tbl_span *sp

Line 228 tbl_hframe(struct termp *tp, const struct tbl_span *sp

term_word(tp, "+");

for (hp = sp->head; hp; hp = hp->next) {

width = tp->tbl[hp->ident].width;

width = tp->tbl.cols[hp->ident].width;

switch (hp->pos) {

case (TBL_HEAD_DATA):

tbl_char(tp, '-', width);

Line 243 tbl_hframe(struct termp *tp, const struct tbl_span *sp

Line 245 tbl_hframe(struct termp *tp, const struct tbl_span *sp

static void

tbl_data(struct termp *tp, const struct tbl *tbl,

const struct tbl_dat *dp,

const struct termp_tbl *tbp)

const struct roffcol *col)

{

enum tbl_cellt pos;

if (NULL == dp) {

tbl_char(tp, ASCII_NBRSP, tbp->width);

tbl_char(tp, ASCII_NBRSP, col->width);

return;

}

switch (dp->pos) {

case (TBL_DATA_NONE):

tbl_char(tp, ASCII_NBRSP, tbp->width);

tbl_char(tp, ASCII_NBRSP, col->width);

return;

case (TBL_DATA_HORIZ):

/* FALLTHROUGH */

case (TBL_DATA_NHORIZ):

tbl_char(tp, '-', tbp->width);

tbl_char(tp, '-', col->width);

return;

case (TBL_DATA_NDHORIZ):

/* FALLTHROUGH */

case (TBL_DATA_DHORIZ):

tbl_char(tp, '=', tbp->width);

tbl_char(tp, '=', col->width);

return;

default:

break;

Line 274 tbl_data(struct termp *tp, const struct tbl *tbl,

Line 276 tbl_data(struct termp *tp, const struct tbl *tbl,

switch (pos) {

case (TBL_CELL_HORIZ):

tbl_char(tp, '-', tbp->width);

tbl_char(tp, '-', col->width);

break;

case (TBL_CELL_DHORIZ):

tbl_char(tp, '=', tbp->width);

tbl_char(tp, '=', col->width);

break;

case (TBL_CELL_LONG):

/* FALLTHROUGH */

Line 286 tbl_data(struct termp *tp, const struct tbl *tbl,

Line 288 tbl_data(struct termp *tp, const struct tbl *tbl,

case (TBL_CELL_LEFT):

/* FALLTHROUGH */

case (TBL_CELL_RIGHT):

tbl_data_literal(tp, dp, tbp);

tbl_literal(tp, dp, col);

break;

case (TBL_CELL_NUMBER):

tbl_data_number(tp, tbl, dp, tbp);

tbl_number(tp, tbl, dp, col);

break;

default:

abort();

/* NOTREACHED */

}

static void

tbl_spanner(struct termp *tp, const struct tbl_head *hp)

tbl_vrule(struct termp *tp, const struct tbl_head *hp)

{

switch (hp->pos) {

Line 315 tbl_spanner(struct termp *tp, const struct tbl_head *h

Line 318 tbl_spanner(struct termp *tp, const struct tbl_head *h

static void

tbl_vframe(struct termp *tp, const struct tbl *tbl)

{

/* Always just a single vertical line. */

if (TBL_OPT_BOX & tbl->opts || TBL_OPT_DBOX & tbl->opts)

term_word(tp, "|");

}

static inline void

static void

tbl_char(struct termp *tp, char c, int len)

{

int i, sz;

char cp[2];

const char cp[2] = {c, '\0'};

cp[0] = c;

cp[1] = '\0';

sz = term_strlen(tp, cp);

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

Line 337 tbl_char(struct termp *tp, char c, int len)

Line 336 tbl_char(struct termp *tp, char c, int len)

}

static void

tbl_data_literal(struct termp *tp,

tbl_literal(struct termp *tp, const struct tbl_dat *dp,

const struct tbl_dat *dp,

const struct roffcol *col)

const struct termp_tbl *tblp)

{

int padl, padr, ssz;

enum tbl_cellt pos;

Line 352 tbl_data_literal(struct termp *tp,

Line 350 tbl_data_literal(struct termp *tp,

switch (pos) {

case (TBL_CELL_LONG):

padl = ssz;

padr = tblp->width - term_strlen(tp, dp->string) - ssz;

padr = col->width - term_strlen(tp, dp->string) - ssz;

break;

case (TBL_CELL_CENTRE):

padl = tblp->width - term_strlen(tp, dp->string);

padl = col->width - term_strlen(tp, dp->string);

if (padl % 2)

padr++;

padl /= 2;

padr += padl;

break;

case (TBL_CELL_RIGHT):

padl = tblp->width - term_strlen(tp, dp->string);

padl = col->width - term_strlen(tp, dp->string);

break;

default:

padr = tblp->width - term_strlen(tp, dp->string);

padr = col->width - term_strlen(tp, dp->string);

break;

}

Line 375 tbl_data_literal(struct termp *tp,

Line 373 tbl_data_literal(struct termp *tp,

}

static void

tbl_data_number(struct termp *tp, const struct tbl *tbl,

tbl_number(struct termp *tp, const struct tbl *tbl,

const struct tbl_dat *dp,

const struct termp_tbl *tblp)

const struct roffcol *col)

{

char *decp, buf[2];

char *cp;

int d, padl, sz, psz, ssz, i;

char buf[2];

const char *str;

size_t sz, psz, ssz, d, padl;

int i;

* See calc_data_number(). Left-pad by taking the offset of our

* and the maximum decimal; right-pad by the remaining amount.

sz = term_strlen(tp, dp->string);

str = "";

psz = term_strlen(tp, ".");

if (dp->string)

str = dp->string;

if (NULL != (decp = strchr(dp->string, tbl->decimal))) {

sz = term_strlen(tp, str);

buf[1] = '\0';

for (ssz = i = 0; decp != &dp->string[i]; i++) {

buf[0] = dp->string[i];

ssz += term_strlen(tp, buf);

}

d = ssz + psz;

} else

d = sz + psz;

assert(d <= tblp->decimal);

buf[0] = tbl->decimal;

assert(sz - d <= tblp->width - tblp->decimal);

buf[1] = '\0';

padl = tblp->decimal - d + term_len(tp, 1);

psz = term_strlen(tp, buf);

assert(tblp->width - sz - padl);

tbl_char(tp, ASCII_NBRSP, padl);

if (NULL != (cp = strchr(str, tbl->decimal))) {

term_word(tp, dp->string);

tbl_char(tp, ASCII_NBRSP, tblp->width - sz - padl);

}

static void

tbl_calc(struct termp *tp, const struct tbl_span *sp)

{

const struct tbl_dat *dp;

const struct tbl_head *hp;

struct termp_tbl *p;

/* Calculate width as the max of column cells' widths. */

hp = sp->head;

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

if (TBL_SPAN_DATA != sp->pos)

continue;

for (dp = sp->first; dp; dp = dp->next) {

if (NULL == dp->layout)

continue;

p = &tp->tbl[dp->layout->head->ident];

tbl_calc_data(tp, sp->tbl, dp, p);

}

/* Calculate width as the simple spanner value. */

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

switch (hp->pos) {

case (TBL_HEAD_VERT):

tp->tbl[hp->ident].width = term_len(tp, 1);

break;

case (TBL_HEAD_DVERT):

tp->tbl[hp->ident].width = term_len(tp, 2);

break;

default:

break;

}

static void

tbl_calc_data(struct termp *tp, const struct tbl *tbl,

const struct tbl_dat *dp, struct termp_tbl *tblp)

{

int sz;

/* Branch down into data sub-types. */

switch (dp->layout->pos) {

case (TBL_CELL_HORIZ):

/* FALLTHROUGH */

case (TBL_CELL_DHORIZ):

sz = term_len(tp, 1);

if (tblp->width < sz)

tblp->width = sz;

break;

case (TBL_CELL_LONG):

/* FALLTHROUGH */

case (TBL_CELL_CENTRE):

/* FALLTHROUGH */

case (TBL_CELL_LEFT):

/* FALLTHROUGH */

case (TBL_CELL_RIGHT):

tbl_calc_data_literal(tp, dp, tblp);

break;

case (TBL_CELL_NUMBER):

tbl_calc_data_number(tp, tbl, dp, tblp);

break;

default:

abort();

/* NOTREACHED */

}

static void

tbl_calc_data_number(struct termp *tp, const struct tbl *tbl,

const struct tbl_dat *dp, struct termp_tbl *tblp)

{

int sz, d, psz, i, ssz;

char *cp, buf[2];

* First calculate number width and decimal place (last + 1 for

* no-decimal numbers). If the stored decimal is subsequent

* ours, make our size longer by that difference

* (right-"shifting"); similarly, if ours is subsequent the

* stored, then extend the stored size by the difference.

* Finally, re-assign the stored values.

/* TODO: use spacing modifier. */

assert(dp->string);

sz = term_strlen(tp, dp->string);

psz = term_strlen(tp, ".");

if (NULL != (cp = strchr(dp->string, tbl->decimal))) {

buf[1] = '\0';

for (ssz = i = 0; cp != &dp->string[i]; i++) {

for (ssz = 0, i = 0; cp != &str[i]; i++) {

buf[0] = dp->string[i];

buf[0] = str[i];

ssz += term_strlen(tp, buf);

}

d = ssz + psz;

Line 516 tbl_calc_data_number(struct termp *tp, const struct tb

Line 410 tbl_calc_data_number(struct termp *tp, const struct tb

d = sz + psz;

sz += term_len(tp, 2);

d += term_len(tp, 1);

if (tblp->decimal > d) {

padl = col->decimal - d;

sz += tblp->decimal - d;

d = tblp->decimal;

} else

tblp->width += d - tblp->decimal;

if (sz > tblp->width)

tbl_char(tp, ASCII_NBRSP, padl);

tblp->width = sz;

term_word(tp, dp->string);

if (d > tblp->decimal)

tbl_char(tp, ASCII_NBRSP, col->width - sz - padl);

tblp->decimal = d;

}

static void

tbl_calc_data_literal(struct termp *tp,

const struct tbl_dat *dp,

struct termp_tbl *tblp)

{

int sz, bufsz, spsz;

* Calculate our width and use the spacing, with a minimum

* spacing dictated by position (centre, e.g,. gets a space on

* either side, while right/left get a single adjacent space).

assert(dp->string);

sz = term_strlen(tp, dp->string);

switch (dp->layout->pos) {

case (TBL_CELL_LONG):

/* FALLTHROUGH */

case (TBL_CELL_CENTRE):

bufsz = term_len(tp, 2);

break;

default:

bufsz = term_len(tp, 1);

break;

}

spsz = 0;

if (dp->layout->spacing)

spsz = term_len(tp, dp->layout->spacing);

if (spsz)

bufsz = bufsz > spsz ? bufsz : spsz;

sz += bufsz;

if (tblp->width < sz)

tblp->width = sz;

}

CVSweb