[BACK]Return to tbl_term.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Annotation of mandoc/tbl_term.c, Revision 1.25

1.25    ! schwarze    1: /*     $Id: tbl_term.c,v 1.24 2012/05/27 18:02:49 schwarze Exp $ */
1.1       kristaps    2: /*
1.20      kristaps    3:  * Copyright (c) 2009, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
1.23      schwarze    4:  * Copyright (c) 2011, 2012 Ingo Schwarze <schwarze@openbsd.org>
1.1       kristaps    5:  *
                      6:  * Permission to use, copy, modify, and distribute this software for any
                      7:  * purpose with or without fee is hereby granted, provided that the above
                      8:  * copyright notice and this permission notice appear in all copies.
                      9:  *
                     10:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     11:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     12:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     13:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     14:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     15:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
                     16:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     17:  */
                     18: #ifdef HAVE_CONFIG_H
                     19: #include "config.h"
                     20: #endif
                     21:
                     22: #include <assert.h>
                     23: #include <stdio.h>
                     24: #include <stdlib.h>
                     25: #include <string.h>
                     26:
                     27: #include "mandoc.h"
                     28: #include "out.h"
                     29: #include "term.h"
                     30:
1.11      kristaps   31: static size_t  term_tbl_len(size_t, void *);
                     32: static size_t  term_tbl_strlen(const char *, void *);
1.12      kristaps   33: static void    tbl_char(struct termp *, char, size_t);
1.25    ! schwarze   34: static void    tbl_data(struct termp *, const struct tbl_opts *,
1.11      kristaps   35:                        const struct tbl_dat *,
                     36:                        const struct roffcol *);
1.21      schwarze   37: static size_t  tbl_rulewidth(struct termp *, const struct tbl_head *);
                     38: static void    tbl_hframe(struct termp *, const struct tbl_span *, int);
1.11      kristaps   39: static void    tbl_literal(struct termp *, const struct tbl_dat *,
                     40:                        const struct roffcol *);
1.25    ! schwarze   41: static void    tbl_number(struct termp *, const struct tbl_opts *,
1.11      kristaps   42:                        const struct tbl_dat *,
                     43:                        const struct roffcol *);
                     44: static void    tbl_hrule(struct termp *, const struct tbl_span *);
                     45: static void    tbl_vrule(struct termp *, const struct tbl_head *);
                     46:
                     47:
                     48: static size_t
                     49: term_tbl_strlen(const char *p, void *arg)
                     50: {
                     51:
                     52:        return(term_strlen((const struct termp *)arg, p));
                     53: }
                     54:
                     55: static size_t
                     56: term_tbl_len(size_t sz, void *arg)
                     57: {
                     58:
                     59:        return(term_len((const struct termp *)arg, sz));
                     60: }
1.1       kristaps   61:
                     62: void
                     63: term_tbl(struct termp *tp, const struct tbl_span *sp)
                     64: {
1.11      kristaps   65:        const struct tbl_head   *hp;
                     66:        const struct tbl_dat    *dp;
                     67:        struct roffcol          *col;
1.16      kristaps   68:        int                      spans;
1.12      kristaps   69:        size_t                   rmargin, maxrmargin;
1.11      kristaps   70:
                     71:        rmargin = tp->rmargin;
                     72:        maxrmargin = tp->maxrmargin;
                     73:
                     74:        tp->rmargin = tp->maxrmargin = TERM_MAXMARGIN;
1.1       kristaps   75:
1.4       kristaps   76:        /* Inhibit printing of spaces: we do padding ourselves. */
                     77:
                     78:        tp->flags |= TERMP_NONOSPACE;
                     79:        tp->flags |= TERMP_NOSPACE;
                     80:
                     81:        /*
1.11      kristaps   82:         * The first time we're invoked for a given table block,
                     83:         * calculate the table widths and decimal positions.
1.4       kristaps   84:         */
                     85:
1.2       kristaps   86:        if (TBL_SPAN_FIRST & sp->flags) {
1.11      kristaps   87:                term_flushln(tp);
                     88:
                     89:                tp->tbl.len = term_tbl_len;
                     90:                tp->tbl.slen = term_tbl_strlen;
                     91:                tp->tbl.arg = tp;
1.4       kristaps   92:
1.11      kristaps   93:                tblcalc(&tp->tbl, sp);
1.2       kristaps   94:        }
1.1       kristaps   95:
1.4       kristaps   96:        /* Horizontal frame at the start of boxed tables. */
                     97:
1.21      schwarze   98:        if (TBL_SPAN_FIRST & sp->flags) {
1.25    ! schwarze   99:                if (TBL_OPT_DBOX & sp->opts->opts)
1.21      schwarze  100:                        tbl_hframe(tp, sp, 1);
1.25    ! schwarze  101:                if (TBL_OPT_DBOX & sp->opts->opts ||
        !           102:                    TBL_OPT_BOX  & sp->opts->opts)
1.21      schwarze  103:                        tbl_hframe(tp, sp, 0);
                    104:        }
1.1       kristaps  105:
1.4       kristaps  106:        /* Vertical frame at the start of each row. */
1.1       kristaps  107:
1.25    ! schwarze  108:        if (TBL_OPT_BOX & sp->opts->opts || TBL_OPT_DBOX & sp->opts->opts)
1.21      schwarze  109:                term_word(tp, TBL_SPAN_HORIZ == sp->pos ||
                    110:                        TBL_SPAN_DHORIZ == sp->pos ? "+" : "|");
1.1       kristaps  111:
1.4       kristaps  112:        /*
                    113:         * Now print the actual data itself depending on the span type.
                    114:         * Spanner spans get a horizontal rule; data spanners have their
                    115:         * data printed by matching data to header.
                    116:         */
                    117:
1.1       kristaps  118:        switch (sp->pos) {
                    119:        case (TBL_SPAN_HORIZ):
                    120:                /* FALLTHROUGH */
                    121:        case (TBL_SPAN_DHORIZ):
                    122:                tbl_hrule(tp, sp);
                    123:                break;
1.4       kristaps  124:        case (TBL_SPAN_DATA):
                    125:                /* Iterate over template headers. */
                    126:                dp = sp->first;
1.16      kristaps  127:                spans = 0;
1.4       kristaps  128:                for (hp = sp->head; hp; hp = hp->next) {
1.22      schwarze  129:
1.16      kristaps  130:                        /*
                    131:                         * If the current data header is invoked during
                    132:                         * a spanner ("spans" > 0), don't emit anything
                    133:                         * at all.
                    134:                         */
1.11      kristaps  135:
1.16      kristaps  136:                        if (--spans >= 0)
                    137:                                continue;
                    138:
1.22      schwarze  139:                        /* Separate columns. */
1.21      schwarze  140:
1.22      schwarze  141:                        if (NULL != hp->prev)
                    142:                                tbl_vrule(tp, hp);
1.21      schwarze  143:
1.11      kristaps  144:                        col = &tp->tbl.cols[hp->ident];
1.25    ! schwarze  145:                        tbl_data(tp, sp->opts, dp, col);
1.1       kristaps  146:
1.16      kristaps  147:                        /*
                    148:                         * Go to the next data cell and assign the
                    149:                         * number of subsequent spans, if applicable.
                    150:                         */
                    151:
                    152:                        if (dp) {
                    153:                                spans = dp->spans;
1.1       kristaps  154:                                dp = dp->next;
1.16      kristaps  155:                        }
1.1       kristaps  156:                }
1.4       kristaps  157:                break;
1.1       kristaps  158:        }
                    159:
1.21      schwarze  160:        /* Vertical frame at the end of each row. */
                    161:
1.25    ! schwarze  162:        if (TBL_OPT_BOX & sp->opts->opts || TBL_OPT_DBOX & sp->opts->opts)
1.21      schwarze  163:                term_word(tp, TBL_SPAN_HORIZ == sp->pos ||
                    164:                        TBL_SPAN_DHORIZ == sp->pos ? "+" : " |");
1.1       kristaps  165:        term_flushln(tp);
                    166:
1.4       kristaps  167:        /*
                    168:         * If we're the last row, clean up after ourselves: clear the
                    169:         * existing table configuration and set it to NULL.
                    170:         */
                    171:
1.2       kristaps  172:        if (TBL_SPAN_LAST & sp->flags) {
1.25    ! schwarze  173:                if (TBL_OPT_DBOX & sp->opts->opts ||
        !           174:                    TBL_OPT_BOX  & sp->opts->opts) {
1.21      schwarze  175:                        tbl_hframe(tp, sp, 0);
1.24      schwarze  176:                        tp->skipvsp = 1;
                    177:                }
1.25    ! schwarze  178:                if (TBL_OPT_DBOX & sp->opts->opts) {
1.21      schwarze  179:                        tbl_hframe(tp, sp, 1);
1.24      schwarze  180:                        tp->skipvsp = 2;
                    181:                }
1.11      kristaps  182:                assert(tp->tbl.cols);
                    183:                free(tp->tbl.cols);
                    184:                tp->tbl.cols = NULL;
1.2       kristaps  185:        }
1.1       kristaps  186:
                    187:        tp->flags &= ~TERMP_NONOSPACE;
1.11      kristaps  188:        tp->rmargin = rmargin;
                    189:        tp->maxrmargin = maxrmargin;
1.1       kristaps  190:
                    191: }
                    192:
1.21      schwarze  193: /*
                    194:  * Horizontal rules extend across the entire table.
                    195:  * Calculate the width by iterating over columns.
                    196:  */
                    197: static size_t
                    198: tbl_rulewidth(struct termp *tp, const struct tbl_head *hp)
                    199: {
                    200:        size_t           width;
                    201:
                    202:        width = tp->tbl.cols[hp->ident].width;
1.22      schwarze  203:
                    204:        /* Account for leading blanks. */
                    205:        if (hp->prev)
                    206:                width += 2 - hp->vert;
                    207:
                    208:        /* Account for trailing blank. */
                    209:        width++;
                    210:
1.21      schwarze  211:        return(width);
                    212: }
                    213:
                    214: /*
                    215:  * Rules inside the table can be single or double
                    216:  * and have crossings with vertical rules marked with pluses.
                    217:  */
1.1       kristaps  218: static void
                    219: tbl_hrule(struct termp *tp, const struct tbl_span *sp)
                    220: {
                    221:        const struct tbl_head *hp;
                    222:        char             c;
                    223:
                    224:        c = '-';
                    225:        if (TBL_SPAN_DHORIZ == sp->pos)
                    226:                c = '=';
                    227:
1.22      schwarze  228:        for (hp = sp->head; hp; hp = hp->next) {
                    229:                if (hp->prev && hp->vert)
                    230:                        tbl_char(tp, '+', hp->vert);
                    231:                tbl_char(tp, c, tbl_rulewidth(tp, hp));
                    232:        }
1.1       kristaps  233: }
                    234:
1.21      schwarze  235: /*
                    236:  * Rules above and below the table are always single
                    237:  * and have an additional plus at the beginning and end.
                    238:  * For double frames, this function is called twice,
                    239:  * and the outer one does not have crossings.
                    240:  */
1.1       kristaps  241: static void
1.21      schwarze  242: tbl_hframe(struct termp *tp, const struct tbl_span *sp, int outer)
1.1       kristaps  243: {
                    244:        const struct tbl_head *hp;
                    245:
                    246:        term_word(tp, "+");
1.22      schwarze  247:        for (hp = sp->head; hp; hp = hp->next) {
                    248:                if (hp->prev && hp->vert)
                    249:                        tbl_char(tp, (outer ? '-' : '+'), hp->vert);
                    250:                tbl_char(tp, '-', tbl_rulewidth(tp, hp));
                    251:        }
1.1       kristaps  252:        term_word(tp, "+");
                    253:        term_flushln(tp);
                    254: }
                    255:
                    256: static void
1.25    ! schwarze  257: tbl_data(struct termp *tp, const struct tbl_opts *opts,
1.2       kristaps  258:                const struct tbl_dat *dp,
1.11      kristaps  259:                const struct roffcol *col)
1.1       kristaps  260: {
                    261:
                    262:        if (NULL == dp) {
1.11      kristaps  263:                tbl_char(tp, ASCII_NBRSP, col->width);
1.1       kristaps  264:                return;
                    265:        }
1.16      kristaps  266:        assert(dp->layout);
1.1       kristaps  267:
                    268:        switch (dp->pos) {
1.10      kristaps  269:        case (TBL_DATA_NONE):
1.11      kristaps  270:                tbl_char(tp, ASCII_NBRSP, col->width);
1.10      kristaps  271:                return;
1.1       kristaps  272:        case (TBL_DATA_HORIZ):
                    273:                /* FALLTHROUGH */
1.7       kristaps  274:        case (TBL_DATA_NHORIZ):
1.11      kristaps  275:                tbl_char(tp, '-', col->width);
1.7       kristaps  276:                return;
                    277:        case (TBL_DATA_NDHORIZ):
                    278:                /* FALLTHROUGH */
1.1       kristaps  279:        case (TBL_DATA_DHORIZ):
1.11      kristaps  280:                tbl_char(tp, '=', col->width);
1.1       kristaps  281:                return;
                    282:        default:
                    283:                break;
                    284:        }
                    285:
1.16      kristaps  286:        switch (dp->layout->pos) {
1.1       kristaps  287:        case (TBL_CELL_HORIZ):
1.11      kristaps  288:                tbl_char(tp, '-', col->width);
1.7       kristaps  289:                break;
1.1       kristaps  290:        case (TBL_CELL_DHORIZ):
1.11      kristaps  291:                tbl_char(tp, '=', col->width);
1.1       kristaps  292:                break;
                    293:        case (TBL_CELL_LONG):
                    294:                /* FALLTHROUGH */
                    295:        case (TBL_CELL_CENTRE):
                    296:                /* FALLTHROUGH */
                    297:        case (TBL_CELL_LEFT):
                    298:                /* FALLTHROUGH */
                    299:        case (TBL_CELL_RIGHT):
1.11      kristaps  300:                tbl_literal(tp, dp, col);
1.1       kristaps  301:                break;
                    302:        case (TBL_CELL_NUMBER):
1.25    ! schwarze  303:                tbl_number(tp, opts, dp, col);
1.18      kristaps  304:                break;
                    305:        case (TBL_CELL_DOWN):
                    306:                tbl_char(tp, ASCII_NBRSP, col->width);
1.1       kristaps  307:                break;
                    308:        default:
                    309:                abort();
                    310:                /* NOTREACHED */
                    311:        }
                    312: }
1.11      kristaps  313:
1.1       kristaps  314: static void
1.11      kristaps  315: tbl_vrule(struct termp *tp, const struct tbl_head *hp)
1.1       kristaps  316: {
                    317:
1.22      schwarze  318:        tbl_char(tp, ASCII_NBRSP, 1);
                    319:        if (0 < hp->vert)
                    320:                tbl_char(tp, '|', hp->vert);
                    321:        if (2 > hp->vert)
                    322:                tbl_char(tp, ASCII_NBRSP, 2 - hp->vert);
1.1       kristaps  323: }
                    324:
                    325: static void
1.12      kristaps  326: tbl_char(struct termp *tp, char c, size_t len)
1.1       kristaps  327: {
1.12      kristaps  328:        size_t          i, sz;
                    329:        char            cp[2];
                    330:
                    331:        cp[0] = c;
                    332:        cp[1] = '\0';
1.1       kristaps  333:
1.3       kristaps  334:        sz = term_strlen(tp, cp);
                    335:
                    336:        for (i = 0; i < len; i += sz)
1.1       kristaps  337:                term_word(tp, cp);
                    338: }
                    339:
                    340: static void
1.11      kristaps  341: tbl_literal(struct termp *tp, const struct tbl_dat *dp,
                    342:                const struct roffcol *col)
1.1       kristaps  343: {
1.23      schwarze  344:        struct tbl_head         *hp;
                    345:        size_t                   width, len, padl, padr;
                    346:        int                      spans;
1.1       kristaps  347:
1.17      kristaps  348:        assert(dp->string);
1.21      schwarze  349:        len = term_strlen(tp, dp->string);
1.23      schwarze  350:
                    351:        hp = dp->layout->head->next;
                    352:        width = col->width;
                    353:        for (spans = dp->spans; spans--; hp = hp->next)
                    354:                width += tp->tbl.cols[hp->ident].width + 3;
                    355:
                    356:        padr = width > len ? width - len : 0;
1.21      schwarze  357:        padl = 0;
1.1       kristaps  358:
1.16      kristaps  359:        switch (dp->layout->pos) {
1.1       kristaps  360:        case (TBL_CELL_LONG):
1.21      schwarze  361:                padl = term_len(tp, 1);
                    362:                padr = padr > padl ? padr - padl : 0;
1.1       kristaps  363:                break;
                    364:        case (TBL_CELL_CENTRE):
1.21      schwarze  365:                if (2 > padr)
1.19      schwarze  366:                        break;
1.21      schwarze  367:                padl = padr / 2;
1.19      schwarze  368:                padr -= padl;
1.1       kristaps  369:                break;
                    370:        case (TBL_CELL_RIGHT):
1.21      schwarze  371:                padl = padr;
                    372:                padr = 0;
1.1       kristaps  373:                break;
                    374:        default:
                    375:                break;
                    376:        }
                    377:
                    378:        tbl_char(tp, ASCII_NBRSP, padl);
1.17      kristaps  379:        term_word(tp, dp->string);
1.21      schwarze  380:        tbl_char(tp, ASCII_NBRSP, padr);
1.1       kristaps  381: }
                    382:
                    383: static void
1.25    ! schwarze  384: tbl_number(struct termp *tp, const struct tbl_opts *opts,
1.2       kristaps  385:                const struct tbl_dat *dp,
1.11      kristaps  386:                const struct roffcol *col)
1.1       kristaps  387: {
1.11      kristaps  388:        char            *cp;
                    389:        char             buf[2];
                    390:        size_t           sz, psz, ssz, d, padl;
                    391:        int              i;
1.1       kristaps  392:
                    393:        /*
                    394:         * See calc_data_number().  Left-pad by taking the offset of our
                    395:         * and the maximum decimal; right-pad by the remaining amount.
                    396:         */
                    397:
1.17      kristaps  398:        assert(dp->string);
1.2       kristaps  399:
1.17      kristaps  400:        sz = term_strlen(tp, dp->string);
1.2       kristaps  401:
1.25    ! schwarze  402:        buf[0] = opts->decimal;
1.11      kristaps  403:        buf[1] = '\0';
1.2       kristaps  404:
1.11      kristaps  405:        psz = term_strlen(tp, buf);
1.10      kristaps  406:
1.25    ! schwarze  407:        if (NULL != (cp = strrchr(dp->string, opts->decimal))) {
1.5       kristaps  408:                buf[1] = '\0';
1.17      kristaps  409:                for (ssz = 0, i = 0; cp != &dp->string[i]; i++) {
                    410:                        buf[0] = dp->string[i];
1.5       kristaps  411:                        ssz += term_strlen(tp, buf);
                    412:                }
                    413:                d = ssz + psz;
                    414:        } else
                    415:                d = sz + psz;
1.2       kristaps  416:
1.11      kristaps  417:        padl = col->decimal - d;
1.2       kristaps  418:
1.11      kristaps  419:        tbl_char(tp, ASCII_NBRSP, padl);
1.17      kristaps  420:        term_word(tp, dp->string);
1.21      schwarze  421:        if (col->width > sz + padl)
                    422:                tbl_char(tp, ASCII_NBRSP, col->width - sz - padl);
1.2       kristaps  423: }
                    424:

CVSweb