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

Annotation of mandoc/out.c, Revision 1.66

1.66    ! schwarze    1: /*     $Id: out.c,v 1.65 2017/06/08 18:11:22 schwarze Exp $ */
1.1       kristaps    2: /*
1.36      schwarze    3:  * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
1.63      schwarze    4:  * Copyright (c) 2011, 2014, 2015, 2017 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:  */
1.12      kristaps   18: #include "config.h"
                     19:
1.1       kristaps   20: #include <sys/types.h>
                     21:
1.6       kristaps   22: #include <assert.h>
1.1       kristaps   23: #include <stdlib.h>
1.6       kristaps   24: #include <string.h>
1.7       kristaps   25: #include <time.h>
1.1       kristaps   26:
1.47      schwarze   27: #include "mandoc_aux.h"
1.30      kristaps   28: #include "mandoc.h"
1.1       kristaps   29: #include "out.h"
                     30:
1.30      kristaps   31: static void    tblcalc_data(struct rofftbl *, struct roffcol *,
1.65      schwarze   32:                        const struct tbl_opts *, const struct tbl_dat *,
                     33:                        size_t);
1.30      kristaps   34: static void    tblcalc_literal(struct rofftbl *, struct roffcol *,
1.65      schwarze   35:                        const struct tbl_dat *, size_t);
1.30      kristaps   36: static void    tblcalc_number(struct rofftbl *, struct roffcol *,
1.45      schwarze   37:                        const struct tbl_opts *, const struct tbl_dat *);
1.30      kristaps   38:
1.48      schwarze   39:
                     40: /*
1.55      schwarze   41:  * Parse the *src string and store a scaling unit into *dst.
                     42:  * If the string doesn't specify the unit, use the default.
                     43:  * If no default is specified, fail.
1.64      schwarze   44:  * Return a pointer to the byte after the last byte used,
                     45:  * or NULL on total failure.
1.3       kristaps   46:  */
1.64      schwarze   47: const char *
1.5       kristaps   48: a2roffsu(const char *src, struct roffsu *dst, enum roffscale def)
1.1       kristaps   49: {
1.55      schwarze   50:        char            *endptr;
1.1       kristaps   51:
1.56      schwarze   52:        dst->unit = def == SCALE_MAX ? SCALE_BU : def;
                     53:        dst->scale = strtod(src, &endptr);
                     54:        if (endptr == src)
1.64      schwarze   55:                return NULL;
1.5       kristaps   56:
1.56      schwarze   57:        switch (*endptr++) {
1.48      schwarze   58:        case 'c':
1.56      schwarze   59:                dst->unit = SCALE_CM;
1.3       kristaps   60:                break;
1.48      schwarze   61:        case 'i':
1.56      schwarze   62:                dst->unit = SCALE_IN;
                     63:                break;
                     64:        case 'f':
                     65:                dst->unit = SCALE_FS;
                     66:                break;
                     67:        case 'M':
                     68:                dst->unit = SCALE_MM;
                     69:                break;
                     70:        case 'm':
                     71:                dst->unit = SCALE_EM;
                     72:                break;
                     73:        case 'n':
                     74:                dst->unit = SCALE_EN;
1.3       kristaps   75:                break;
1.48      schwarze   76:        case 'P':
1.56      schwarze   77:                dst->unit = SCALE_PC;
1.3       kristaps   78:                break;
1.48      schwarze   79:        case 'p':
1.56      schwarze   80:                dst->unit = SCALE_PT;
1.3       kristaps   81:                break;
1.56      schwarze   82:        case 'u':
                     83:                dst->unit = SCALE_BU;
1.3       kristaps   84:                break;
1.48      schwarze   85:        case 'v':
1.56      schwarze   86:                dst->unit = SCALE_VS;
1.3       kristaps   87:                break;
1.48      schwarze   88:        case '\0':
1.56      schwarze   89:                endptr--;
                     90:                /* FALLTHROUGH */
                     91:        default:
1.5       kristaps   92:                if (SCALE_MAX == def)
1.64      schwarze   93:                        return NULL;
1.56      schwarze   94:                dst->unit = def;
1.3       kristaps   95:                break;
                     96:        }
1.64      schwarze   97:        return endptr;
1.8       kristaps   98: }
1.30      kristaps   99:
                    100: /*
                    101:  * Calculate the abstract widths and decimal positions of columns in a
                    102:  * table.  This routine allocates the columns structures then runs over
                    103:  * all rows and cells in the table.  The function pointers in "tbl" are
                    104:  * used for the actual width calculations.
                    105:  */
                    106: void
1.52      schwarze  107: tblcalc(struct rofftbl *tbl, const struct tbl_span *sp,
1.66    ! schwarze  108:     size_t offset, size_t rmargin)
1.30      kristaps  109: {
1.65      schwarze  110:        struct roffsu            su;
1.58      schwarze  111:        const struct tbl_opts   *opts;
1.30      kristaps  112:        const struct tbl_dat    *dp;
                    113:        struct roffcol          *col;
1.52      schwarze  114:        size_t                   ewidth, xwidth;
1.43      schwarze  115:        int                      spans;
1.58      schwarze  116:        int                      icol, maxcol, necol, nxcol, quirkcol;
1.30      kristaps  117:
                    118:        /*
                    119:         * Allocate the master column specifiers.  These will hold the
                    120:         * widths and decimal positions for all cells in the column.  It
                    121:         * must be freed and nullified by the caller.
                    122:         */
                    123:
                    124:        assert(NULL == tbl->cols);
1.48      schwarze  125:        tbl->cols = mandoc_calloc((size_t)sp->opts->cols,
                    126:            sizeof(struct roffcol));
1.58      schwarze  127:        opts = sp->opts;
1.30      kristaps  128:
1.53      schwarze  129:        for (maxcol = -1; sp; sp = sp->next) {
1.30      kristaps  130:                if (TBL_SPAN_DATA != sp->pos)
                    131:                        continue;
1.43      schwarze  132:                spans = 1;
1.30      kristaps  133:                /*
                    134:                 * Account for the data cells in the layout, matching it
                    135:                 * to data cells in the data section.
                    136:                 */
                    137:                for (dp = sp->first; dp; dp = dp->next) {
1.43      schwarze  138:                        /* Do not used spanned cells in the calculation. */
                    139:                        if (0 < --spans)
                    140:                                continue;
                    141:                        spans = dp->spans;
                    142:                        if (1 < spans)
                    143:                                continue;
1.59      schwarze  144:                        icol = dp->layout->col;
1.52      schwarze  145:                        if (maxcol < icol)
                    146:                                maxcol = icol;
                    147:                        col = tbl->cols + icol;
                    148:                        col->flags |= dp->layout->flags;
                    149:                        if (dp->layout->flags & TBL_CELL_WIGN)
                    150:                                continue;
1.65      schwarze  151:                        if (dp->layout->wstr != NULL &&
                    152:                            dp->layout->width == 0 &&
                    153:                            a2roffsu(dp->layout->wstr, &su, SCALE_EN)
                    154:                            != NULL)
                    155:                                dp->layout->width =
                    156:                                    (*tbl->sulen)(&su, tbl->arg);
                    157:                        if (col->width < dp->layout->width)
                    158:                                col->width = dp->layout->width;
1.66    ! schwarze  159:                        tblcalc_data(tbl, col, opts, dp,
        !           160:                            rmargin && dp->block ?
        !           161:                            rmargin / (sp->opts->cols + 1) : 0);
1.52      schwarze  162:                }
                    163:        }
                    164:
                    165:        /*
                    166:         * Count columns to equalize and columns to maximize.
                    167:         * Find maximum width of the columns to equalize.
                    168:         * Find total width of the columns *not* to maximize.
                    169:         */
                    170:
                    171:        necol = nxcol = 0;
                    172:        ewidth = xwidth = 0;
                    173:        for (icol = 0; icol <= maxcol; icol++) {
                    174:                col = tbl->cols + icol;
                    175:                if (col->flags & TBL_CELL_EQUAL) {
                    176:                        necol++;
                    177:                        if (ewidth < col->width)
                    178:                                ewidth = col->width;
                    179:                }
                    180:                if (col->flags & TBL_CELL_WMAX)
                    181:                        nxcol++;
                    182:                else
                    183:                        xwidth += col->width;
                    184:        }
                    185:
                    186:        /*
                    187:         * Equalize columns, if requested for any of them.
                    188:         * Update total width of the columns not to maximize.
                    189:         */
                    190:
                    191:        if (necol) {
                    192:                for (icol = 0; icol <= maxcol; icol++) {
                    193:                        col = tbl->cols + icol;
                    194:                        if ( ! (col->flags & TBL_CELL_EQUAL))
                    195:                                continue;
                    196:                        if (col->width == ewidth)
                    197:                                continue;
1.66    ! schwarze  198:                        if (nxcol && rmargin)
1.52      schwarze  199:                                xwidth += ewidth - col->width;
                    200:                        col->width = ewidth;
                    201:                }
                    202:        }
                    203:
                    204:        /*
                    205:         * If there are any columns to maximize, find the total
                    206:         * available width, deducting 3n margins between columns.
                    207:         * Distribute the available width evenly.
                    208:         */
                    209:
1.66    ! schwarze  210:        if (nxcol && rmargin) {
1.63      schwarze  211:                xwidth += 3*maxcol +
1.58      schwarze  212:                    (opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX) ?
                    213:                     2 : !!opts->lvert + !!opts->rvert);
1.66    ! schwarze  214:                if (rmargin <= offset + xwidth)
1.63      schwarze  215:                        return;
1.66    ! schwarze  216:                xwidth = rmargin - offset - xwidth;
1.58      schwarze  217:
                    218:                /*
                    219:                 * Emulate a bug in GNU tbl width calculation that
                    220:                 * manifests itself for large numbers of x-columns.
                    221:                 * Emulating it for 5 x-columns gives identical
                    222:                 * behaviour for up to 6 x-columns.
                    223:                 */
                    224:
                    225:                if (nxcol == 5) {
                    226:                        quirkcol = xwidth % nxcol + 2;
                    227:                        if (quirkcol != 3 && quirkcol != 4)
                    228:                                quirkcol = -1;
                    229:                } else
                    230:                        quirkcol = -1;
                    231:
                    232:                necol = 0;
                    233:                ewidth = 0;
1.52      schwarze  234:                for (icol = 0; icol <= maxcol; icol++) {
                    235:                        col = tbl->cols + icol;
                    236:                        if ( ! (col->flags & TBL_CELL_WMAX))
                    237:                                continue;
1.58      schwarze  238:                        col->width = (double)xwidth * ++necol / nxcol
                    239:                            - ewidth + 0.4995;
                    240:                        if (necol == quirkcol)
                    241:                                col->width--;
                    242:                        ewidth += col->width;
1.30      kristaps  243:                }
                    244:        }
                    245: }
                    246:
                    247: static void
                    248: tblcalc_data(struct rofftbl *tbl, struct roffcol *col,
1.65      schwarze  249:     const struct tbl_opts *opts, const struct tbl_dat *dp, size_t mw)
1.30      kristaps  250: {
                    251:        size_t           sz;
                    252:
                    253:        /* Branch down into data sub-types. */
                    254:
                    255:        switch (dp->layout->pos) {
1.48      schwarze  256:        case TBL_CELL_HORIZ:
                    257:        case TBL_CELL_DHORIZ:
1.30      kristaps  258:                sz = (*tbl->len)(1, tbl->arg);
                    259:                if (col->width < sz)
                    260:                        col->width = sz;
                    261:                break;
1.48      schwarze  262:        case TBL_CELL_LONG:
                    263:        case TBL_CELL_CENTRE:
                    264:        case TBL_CELL_LEFT:
                    265:        case TBL_CELL_RIGHT:
1.65      schwarze  266:                tblcalc_literal(tbl, col, dp, mw);
1.30      kristaps  267:                break;
1.48      schwarze  268:        case TBL_CELL_NUMBER:
1.45      schwarze  269:                tblcalc_number(tbl, col, opts, dp);
1.35      kristaps  270:                break;
1.48      schwarze  271:        case TBL_CELL_DOWN:
1.30      kristaps  272:                break;
                    273:        default:
                    274:                abort();
                    275:        }
                    276: }
                    277:
                    278: static void
                    279: tblcalc_literal(struct rofftbl *tbl, struct roffcol *col,
1.65      schwarze  280:     const struct tbl_dat *dp, size_t mw)
1.30      kristaps  281: {
1.65      schwarze  282:        const char      *str;   /* Beginning of the first line. */
                    283:        const char      *beg;   /* Beginning of the current line. */
                    284:        char            *end;   /* End of the current line. */
1.66    ! schwarze  285:        size_t           lsz;   /* Length of the current line. */
        !           286:        size_t           wsz;   /* Length of the current word. */
1.65      schwarze  287:
                    288:        if (dp->string == NULL || *dp->string == '\0')
                    289:                return;
                    290:        str = mw ? mandoc_strdup(dp->string) : dp->string;
1.66    ! schwarze  291:        lsz = 0;
1.65      schwarze  292:        for (beg = str; beg != NULL && *beg != '\0'; beg = end) {
                    293:                end = mw ? strchr(beg, ' ') : NULL;
                    294:                if (end != NULL) {
                    295:                        *end++ = '\0';
                    296:                        while (*end == ' ')
                    297:                                end++;
                    298:                }
1.66    ! schwarze  299:                wsz = (*tbl->slen)(beg, tbl->arg);
        !           300:                if (mw && lsz && lsz + 1 + wsz <= mw)
        !           301:                        lsz += 1 + wsz;
        !           302:                else
        !           303:                        lsz = wsz;
        !           304:                if (col->width < lsz)
        !           305:                        col->width = lsz;
1.65      schwarze  306:        }
                    307:        if (mw)
                    308:                free((void *)str);
1.30      kristaps  309: }
                    310:
                    311: static void
                    312: tblcalc_number(struct rofftbl *tbl, struct roffcol *col,
1.45      schwarze  313:                const struct tbl_opts *opts, const struct tbl_dat *dp)
1.30      kristaps  314: {
1.48      schwarze  315:        int              i;
1.34      kristaps  316:        size_t           sz, psz, ssz, d;
                    317:        const char      *str;
1.30      kristaps  318:        char            *cp;
                    319:        char             buf[2];
                    320:
                    321:        /*
                    322:         * First calculate number width and decimal place (last + 1 for
1.43      schwarze  323:         * non-decimal numbers).  If the stored decimal is subsequent to
1.30      kristaps  324:         * ours, make our size longer by that difference
                    325:         * (right-"shifting"); similarly, if ours is subsequent the
                    326:         * stored, then extend the stored size by the difference.
                    327:         * Finally, re-assign the stored values.
                    328:         */
                    329:
1.34      kristaps  330:        str = dp->string ? dp->string : "";
                    331:        sz = (*tbl->slen)(str, tbl->arg);
1.30      kristaps  332:
1.34      kristaps  333:        /* FIXME: TBL_DATA_HORIZ et al.? */
1.30      kristaps  334:
1.45      schwarze  335:        buf[0] = opts->decimal;
1.30      kristaps  336:        buf[1] = '\0';
                    337:
                    338:        psz = (*tbl->slen)(buf, tbl->arg);
                    339:
1.45      schwarze  340:        if (NULL != (cp = strrchr(str, opts->decimal))) {
1.30      kristaps  341:                buf[1] = '\0';
                    342:                for (ssz = 0, i = 0; cp != &str[i]; i++) {
                    343:                        buf[0] = str[i];
                    344:                        ssz += (*tbl->slen)(buf, tbl->arg);
                    345:                }
                    346:                d = ssz + psz;
                    347:        } else
                    348:                d = sz + psz;
                    349:
                    350:        /* Adjust the settings for this column. */
                    351:
                    352:        if (col->decimal > d) {
                    353:                sz += col->decimal - d;
                    354:                d = col->decimal;
                    355:        } else
                    356:                col->width += d - col->decimal;
                    357:
                    358:        if (sz > col->width)
                    359:                col->width = sz;
                    360:        if (d > col->decimal)
                    361:                col->decimal = d;
                    362: }

CVSweb