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

Annotation of mandoc/term.c, Revision 1.281

1.281   ! schwarze    1: /*     $Id: term.c,v 1.280 2019/01/15 12:16:18 schwarze Exp $ */
1.1       kristaps    2: /*
1.198     schwarze    3:  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
1.278     schwarze    4:  * Copyright (c) 2010-2019 Ingo Schwarze <schwarze@openbsd.org>
1.1       kristaps    5:  *
                      6:  * Permission to use, copy, modify, and distribute this software for any
1.74      kristaps    7:  * purpose with or without fee is hereby granted, provided that the above
                      8:  * copyright notice and this permission notice appear in all copies.
1.1       kristaps    9:  *
1.246     schwarze   10:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
1.74      kristaps   11:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1.246     schwarze   12:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
1.74      kristaps   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.
1.1       kristaps   17:  */
1.128     kristaps   18: #include "config.h"
                     19:
1.126     kristaps   20: #include <sys/types.h>
                     21:
1.1       kristaps   22: #include <assert.h>
1.122     kristaps   23: #include <ctype.h>
1.278     schwarze   24: #include <stdint.h>
1.22      kristaps   25: #include <stdio.h>
1.1       kristaps   26: #include <stdlib.h>
                     27: #include <string.h>
                     28:
1.137     kristaps   29: #include "mandoc.h"
1.218     schwarze   30: #include "mandoc_aux.h"
1.107     kristaps   31: #include "out.h"
1.71      kristaps   32: #include "term.h"
1.105     kristaps   33: #include "main.h"
1.1       kristaps   34:
1.203     schwarze   35: static size_t           cond_width(const struct termp *, int, int *);
1.266     schwarze   36: static void             adjbuf(struct termp_col *, size_t);
1.191     kristaps   37: static void             bufferc(struct termp *, char);
                     38: static void             encode(struct termp *, const char *, size_t);
1.194     kristaps   39: static void             encode1(struct termp *, int);
1.264     schwarze   40: static void             endline(struct termp *);
1.278     schwarze   41: static void             term_field(struct termp *, size_t, size_t,
                     42:                                size_t, size_t);
                     43: static void             term_fill(struct termp *, size_t *, size_t *,
                     44:                                size_t);
1.11      kristaps   45:
1.222     schwarze   46:
1.145     kristaps   47: void
1.269     schwarze   48: term_setcol(struct termp *p, size_t maxtcol)
                     49: {
                     50:        if (maxtcol > p->maxtcol) {
                     51:                p->tcols = mandoc_recallocarray(p->tcols,
                     52:                    p->maxtcol, maxtcol, sizeof(*p->tcols));
                     53:                p->maxtcol = maxtcol;
                     54:        }
                     55:        p->lasttcol = maxtcol - 1;
                     56:        p->tcol = p->tcols;
                     57: }
                     58:
                     59: void
1.71      kristaps   60: term_free(struct termp *p)
1.14      kristaps   61: {
1.266     schwarze   62:        for (p->tcol = p->tcols; p->tcol < p->tcols + p->maxtcol; p->tcol++)
                     63:                free(p->tcol->buf);
                     64:        free(p->tcols);
1.238     schwarze   65:        free(p->fontq);
1.142     kristaps   66:        free(p);
                     67: }
                     68:
                     69: void
1.222     schwarze   70: term_begin(struct termp *p, term_margin head,
1.246     schwarze   71:                term_margin foot, const struct roff_meta *arg)
1.142     kristaps   72: {
                     73:
                     74:        p->headf = head;
                     75:        p->footf = foot;
                     76:        p->argf = arg;
1.146     kristaps   77:        (*p->begin)(p);
1.142     kristaps   78: }
                     79:
                     80: void
                     81: term_end(struct termp *p)
                     82: {
                     83:
1.146     kristaps   84:        (*p->end)(p);
1.14      kristaps   85: }
                     86:
1.71      kristaps   87: /*
1.221     schwarze   88:  * Flush a chunk of text.  By default, break the output line each time
                     89:  * the right margin is reached, and continue output on the next line
                     90:  * at the same offset as the chunk itself.  By default, also break the
1.278     schwarze   91:  * output line at the end of the chunk.  There are many flags modifying
                     92:  * this behaviour, see the comments in the body of the function.
1.71      kristaps   93:  */
                     94: void
                     95: term_flushln(struct termp *p)
1.53      kristaps   96: {
1.278     schwarze   97:        size_t   vbl;      /* Number of blanks to prepend to the output. */
                     98:        size_t   vbr;      /* Actual visual position of the end of field. */
                     99:        size_t   vfield;   /* Desired visual field width. */
                    100:        size_t   vtarget;  /* Desired visual position of the right margin. */
                    101:        size_t   ic;       /* Character position in the input buffer. */
                    102:        size_t   nbr;      /* Number of characters to print in this field. */
                    103:
                    104:        /*
                    105:         * Normally, start writing at the left margin, but with the
                    106:         * NOPAD flag, start writing at the current position instead.
                    107:         */
1.53      kristaps  108:
1.266     schwarze  109:        vbl = (p->flags & TERMP_NOPAD) || p->tcol->offset < p->viscol ?
                    110:            0 : p->tcol->offset - p->viscol;
1.263     schwarze  111:        if (p->minbl && vbl < p->minbl)
                    112:                vbl = p->minbl;
1.115     kristaps  113:
1.274     schwarze  114:        if ((p->flags & TERMP_MULTICOL) == 0)
1.267     schwarze  115:                p->tcol->col = 0;
1.278     schwarze  116:
                    117:        /* Loop over output lines. */
                    118:
                    119:        for (;;) {
                    120:                vfield = p->tcol->rmargin > p->viscol + vbl ?
                    121:                    p->tcol->rmargin - p->viscol - vbl : 0;
1.267     schwarze  122:
1.71      kristaps  123:                /*
1.278     schwarze  124:                 * Normally, break the line at the the right margin
                    125:                 * of the field, but with the NOBREAK flag, only
                    126:                 * break it at the max right margin of the screen,
                    127:                 * and with the BRNEVER flag, never break it at all.
1.138     schwarze  128:                 */
1.267     schwarze  129:
1.278     schwarze  130:                vtarget = p->flags & TERMP_BRNEVER ? SIZE_MAX :
                    131:                    (p->flags & TERMP_NOBREAK) == 0 ? vfield :
                    132:                    p->maxrmargin > p->viscol + vbl ?
                    133:                    p->maxrmargin - p->viscol - vbl : 0;
                    134:
                    135:                /*
                    136:                 * Figure out how much text will fit in the field.
                    137:                 * If there is whitespace only, print nothing.
                    138:                 */
                    139:
                    140:                term_fill(p, &nbr, &vbr, vtarget);
                    141:                if (nbr == 0)
                    142:                        break;
1.279     schwarze  143:
                    144:                /*
                    145:                 * With the CENTER or RIGHT flag, increase the indentation
                    146:                 * to center the text between the left and right margins
                    147:                 * or to adjust it to the right margin, respectively.
                    148:                 */
                    149:
                    150:                if (vbr < vtarget) {
                    151:                        if (p->flags & TERMP_CENTER)
                    152:                                vbl += (vtarget - vbr) / 2;
                    153:                        else if (p->flags & TERMP_RIGHT)
                    154:                                vbl += vtarget - vbr;
                    155:                }
                    156:
                    157:                /* Finally, print the field content. */
1.278     schwarze  158:
                    159:                term_field(p, vbl, nbr, vbr, vtarget);
1.138     schwarze  160:
                    161:                /*
1.278     schwarze  162:                 * If there is no text left in the field, exit the loop.
                    163:                 * If the BRTRSP flag is set, consider trailing
                    164:                 * whitespace significant when deciding whether
                    165:                 * the field fits or not.
1.71      kristaps  166:                 */
                    167:
1.278     schwarze  168:                for (ic = p->tcol->col; ic < p->tcol->lastcol; ic++) {
                    169:                        switch (p->tcol->buf[ic]) {
                    170:                        case '\t':
                    171:                                if (p->flags & TERMP_BRTRSP)
                    172:                                        vbr = term_tab_next(vbr);
                    173:                                continue;
                    174:                        case ' ':
                    175:                                if (p->flags & TERMP_BRTRSP)
                    176:                                        vbr += (*p->width)(p, ' ');
1.270     schwarze  177:                                continue;
1.278     schwarze  178:                        case '\n':
                    179:                        case ASCII_BREAK:
                    180:                                continue;
                    181:                        default:
                    182:                                break;
1.270     schwarze  183:                        }
1.278     schwarze  184:                        break;
                    185:                }
                    186:                if (ic == p->tcol->lastcol)
                    187:                        break;
1.154     kristaps  188:
1.278     schwarze  189:                /*
                    190:                 * At the location of an automtic line break, input
                    191:                 * space characters are consumed by the line break.
                    192:                 */
1.154     kristaps  193:
1.278     schwarze  194:                while (p->tcol->col < p->tcol->lastcol &&
                    195:                    p->tcol->buf[p->tcol->col] == ' ')
                    196:                        p->tcol->col++;
1.154     kristaps  197:
1.278     schwarze  198:                /*
                    199:                 * In multi-column mode, leave the rest of the text
                    200:                 * in the buffer to be handled by a subsequent
                    201:                 * invocation, such that the other columns of the
                    202:                 * table can be handled first.
                    203:                 * In single-column mode, simply break the line.
                    204:                 */
                    205:
                    206:                if (p->flags & TERMP_MULTICOL)
                    207:                        return;
1.217     schwarze  208:
1.278     schwarze  209:                endline(p);
                    210:                p->viscol = 0;
1.53      kristaps  211:
1.71      kristaps  212:                /*
1.278     schwarze  213:                 * Normally, start the next line at the same indentation
                    214:                 * as this one, but with the BRIND flag, start it at the
                    215:                 * right margin instead.  This is used together with
                    216:                 * NOBREAK for the tags in various kinds of tagged lists.
1.81      kristaps  217:                 */
1.267     schwarze  218:
1.278     schwarze  219:                vbl = p->flags & TERMP_BRIND ?
                    220:                    p->tcol->rmargin : p->tcol->offset;
                    221:        }
1.267     schwarze  222:
1.278     schwarze  223:        /* Reset output state in preparation for the next field. */
1.205     schwarze  224:
1.278     schwarze  225:        p->col = p->tcol->col = p->tcol->lastcol = 0;
                    226:        p->minbl = p->trailspace;
                    227:        p->flags &= ~(TERMP_BACKAFTER | TERMP_BACKBEFORE | TERMP_NOPAD);
1.260     schwarze  228:
1.278     schwarze  229:        if (p->flags & TERMP_MULTICOL)
                    230:                return;
1.260     schwarze  231:
1.278     schwarze  232:        /*
                    233:         * The HANG flag means that the next field
                    234:         * always follows on the same line.
                    235:         * The NOBREAK flag means that the next field
                    236:         * follows on the same line unless the field was overrun.
                    237:         * Normally, break the line at the end of each field.
                    238:         */
1.205     schwarze  239:
1.278     schwarze  240:        if ((p->flags & TERMP_HANG) == 0 &&
                    241:            ((p->flags & TERMP_NOBREAK) == 0 ||
                    242:             vbr + term_len(p, p->trailspace) > vfield))
                    243:                endline(p);
                    244: }
1.138     schwarze  245:
1.278     schwarze  246: /*
                    247:  * Store the number of input characters to print in this field in *nbr
                    248:  * and their total visual width to print in *vbr.
                    249:  * If there is only whitespace in the field, both remain zero.
                    250:  * The desired visual width of the field is provided by vtarget.
                    251:  * If the first word is longer, the field will be overrun.
                    252:  */
                    253: static void
                    254: term_fill(struct termp *p, size_t *nbr, size_t *vbr, size_t vtarget)
                    255: {
                    256:        size_t   ic;        /* Character position in the input buffer. */
                    257:        size_t   vis;       /* Visual position of the current character. */
                    258:        size_t   vn;        /* Visual position of the next character. */
                    259:        int      breakline; /* Break at the end of this word. */
                    260:        int      graph;     /* Last character was non-blank. */
                    261:
                    262:        *nbr = *vbr = vis = 0;
                    263:        breakline = graph = 0;
                    264:        for (ic = p->tcol->col; ic < p->tcol->lastcol; ic++) {
                    265:                switch (p->tcol->buf[ic]) {
                    266:                case '\b':  /* Escape \o (overstrike) or backspace markup. */
                    267:                        assert(ic > 0);
                    268:                        vis -= (*p->width)(p, p->tcol->buf[ic - 1]);
                    269:                        continue;
1.267     schwarze  270:
1.278     schwarze  271:                case '\t':  /* Normal ASCII whitespace. */
                    272:                case ' ':
                    273:                case ASCII_BREAK:  /* Escape \: (breakpoint). */
                    274:                        switch (p->tcol->buf[ic]) {
                    275:                        case '\t':
                    276:                                vn = term_tab_next(vis);
1.140     kristaps  277:                                break;
1.278     schwarze  278:                        case ' ':
                    279:                                vn = vis + (*p->width)(p, ' ');
1.138     schwarze  280:                                break;
1.278     schwarze  281:                        case ASCII_BREAK:
                    282:                                vn = vis;
1.71      kristaps  283:                                break;
1.281   ! schwarze  284:                        default:
        !           285:                                abort();
1.136     schwarze  286:                        }
1.278     schwarze  287:                        /* Can break at the end of a word. */
                    288:                        if (breakline || vn > vtarget)
                    289:                                break;
                    290:                        if (graph) {
                    291:                                *nbr = ic;
                    292:                                *vbr = vis;
                    293:                                graph = 0;
1.136     schwarze  294:                        }
1.278     schwarze  295:                        vis = vn;
                    296:                        continue;
                    297:
                    298:                case '\n':  /* Escape \p (break at the end of the word). */
                    299:                        breakline = 1;
                    300:                        continue;
1.130     kristaps  301:
1.278     schwarze  302:                case ASCII_HYPH:  /* Breakable hyphen. */
                    303:                        graph = 1;
1.136     schwarze  304:                        /*
1.278     schwarze  305:                         * We are about to decide whether to break the
                    306:                         * line or not, so we no longer need this hyphen
                    307:                         * to be marked as breakable.  Put back a real
                    308:                         * hyphen such that we get the correct width.
1.136     schwarze  309:                         */
1.278     schwarze  310:                        p->tcol->buf[ic] = '-';
                    311:                        vis += (*p->width)(p, '-');
                    312:                        if (vis > vtarget) {
                    313:                                ic++;
                    314:                                break;
1.200     schwarze  315:                        }
1.278     schwarze  316:                        *nbr = ic + 1;
                    317:                        *vbr = vis;
                    318:                        continue;
1.200     schwarze  319:
1.278     schwarze  320:                case ASCII_NBRSP:  /* Non-breakable space. */
                    321:                        p->tcol->buf[ic] = ' ';
                    322:                        /* FALLTHROUGH */
                    323:                default:  /* Printable character. */
                    324:                        graph = 1;
                    325:                        vis += (*p->width)(p, p->tcol->buf[ic]);
                    326:                        if (vis > vtarget && *nbr > 0)
                    327:                                return;
                    328:                        continue;
1.136     schwarze  329:                }
1.278     schwarze  330:                break;
                    331:        }
1.270     schwarze  332:
1.278     schwarze  333:        /*
                    334:         * If the last word extends to the end of the field without any
                    335:         * trailing whitespace, the loop could not check yet whether it
                    336:         * can remain on this line.  So do the check now.
                    337:         */
1.270     schwarze  338:
1.278     schwarze  339:        if (graph && (vis <= vtarget || *nbr == 0)) {
                    340:                *nbr = ic;
                    341:                *vbr = vis;
                    342:        }
                    343: }
1.270     schwarze  344:
1.278     schwarze  345: /*
                    346:  * Print the contents of one field
                    347:  * with an indentation of       vbl      visual columns,
                    348:  * an input string length of    nbr      characters,
                    349:  * an output width of           vbr      visual columns,
                    350:  * and a desired field width of         vtarget  visual columns.
                    351:  */
                    352: static void
                    353: term_field(struct termp *p, size_t vbl, size_t nbr, size_t vbr, size_t vtarget)
                    354: {
                    355:        size_t   ic;    /* Character position in the input buffer. */
                    356:        size_t   vis;   /* Visual position of the current character. */
                    357:        size_t   dv;    /* Visual width of the current character. */
                    358:        size_t   vn;    /* Visual position of the next character. */
1.270     schwarze  359:
1.278     schwarze  360:        vis = 0;
                    361:        for (ic = p->tcol->col; ic < nbr; ic++) {
1.270     schwarze  362:
1.278     schwarze  363:                /*
                    364:                 * To avoid the printing of trailing whitespace,
                    365:                 * do not print whitespace right away, only count it.
                    366:                 */
1.270     schwarze  367:
1.278     schwarze  368:                switch (p->tcol->buf[ic]) {
                    369:                case '\n':
                    370:                case ASCII_BREAK:
                    371:                        continue;
                    372:                case '\t':
                    373:                        vn = term_tab_next(vis);
                    374:                        vbl += vn - vis;
                    375:                        vis = vn;
                    376:                        continue;
                    377:                case ' ':
                    378:                case ASCII_NBRSP:
1.280     schwarze  379:                        dv = (*p->width)(p, ' ');
                    380:                        vbl += dv;
                    381:                        vis += dv;
1.278     schwarze  382:                        continue;
                    383:                default:
                    384:                        break;
                    385:                }
1.168     schwarze  386:
1.278     schwarze  387:                /*
                    388:                 * We found a non-blank character to print,
                    389:                 * so write preceding white space now.
                    390:                 */
1.267     schwarze  391:
1.278     schwarze  392:                if (vbl > 0) {
                    393:                        (*p->advance)(p, vbl);
                    394:                        p->viscol += vbl;
                    395:                        vbl = 0;
                    396:                }
1.111     kristaps  397:
1.278     schwarze  398:                /* Print the character and adjust the visual position. */
1.15      kristaps  399:
1.278     schwarze  400:                (*p->letter)(p, p->tcol->buf[ic]);
                    401:                if (p->tcol->buf[ic] == '\b') {
                    402:                        dv = (*p->width)(p, p->tcol->buf[ic - 1]);
                    403:                        p->viscol -= dv;
                    404:                        vis -= dv;
                    405:                } else {
                    406:                        dv = (*p->width)(p, p->tcol->buf[ic]);
                    407:                        p->viscol += dv;
                    408:                        vis += dv;
                    409:                }
                    410:        }
                    411:        p->tcol->col = nbr;
1.264     schwarze  412: }
                    413:
                    414: static void
                    415: endline(struct termp *p)
                    416: {
                    417:        if ((p->flags & (TERMP_NEWMC | TERMP_ENDMC)) == TERMP_ENDMC) {
                    418:                p->mc = NULL;
                    419:                p->flags &= ~TERMP_ENDMC;
                    420:        }
                    421:        if (p->mc != NULL) {
                    422:                if (p->viscol && p->maxrmargin >= p->viscol)
                    423:                        (*p->advance)(p, p->maxrmargin - p->viscol + 1);
                    424:                p->flags |= TERMP_NOBUF | TERMP_NOSPACE;
                    425:                term_word(p, p->mc);
                    426:                p->flags &= ~(TERMP_NOBUF | TERMP_NEWMC);
                    427:        }
                    428:        p->viscol = 0;
                    429:        p->minbl = 0;
                    430:        (*p->endline)(p);
1.15      kristaps  431: }
                    432:
1.222     schwarze  433: /*
1.71      kristaps  434:  * A newline only breaks an existing line; it won't assert vertical
                    435:  * space.  All data in the output buffer is flushed prior to the newline
                    436:  * assertion.
                    437:  */
                    438: void
                    439: term_newln(struct termp *p)
1.15      kristaps  440: {
                    441:
1.71      kristaps  442:        p->flags |= TERMP_NOSPACE;
1.269     schwarze  443:        if (p->tcol->lastcol || p->viscol)
1.200     schwarze  444:                term_flushln(p);
1.16      kristaps  445: }
                    446:
1.71      kristaps  447: /*
                    448:  * Asserts a vertical space (a full, empty line-break between lines).
                    449:  * Note that if used twice, this will cause two blank spaces and so on.
                    450:  * All data in the output buffer is flushed prior to the newline
                    451:  * assertion.
                    452:  */
                    453: void
                    454: term_vspace(struct termp *p)
1.16      kristaps  455: {
                    456:
1.62      kristaps  457:        term_newln(p);
1.139     schwarze  458:        p->viscol = 0;
1.264     schwarze  459:        p->minbl = 0;
1.202     schwarze  460:        if (0 < p->skipvsp)
                    461:                p->skipvsp--;
                    462:        else
                    463:                (*p->endline)(p);
1.16      kristaps  464: }
                    465:
1.238     schwarze  466: /* Swap current and previous font; for \fP and .ft P */
1.125     kristaps  467: void
                    468: term_fontlast(struct termp *p)
                    469: {
                    470:        enum termfont    f;
                    471:
                    472:        f = p->fontl;
                    473:        p->fontl = p->fontq[p->fonti];
                    474:        p->fontq[p->fonti] = f;
                    475: }
                    476:
1.238     schwarze  477: /* Set font, save current, discard previous; for \f, .ft, .B etc. */
1.125     kristaps  478: void
                    479: term_fontrepl(struct termp *p, enum termfont f)
                    480: {
                    481:
                    482:        p->fontl = p->fontq[p->fonti];
                    483:        p->fontq[p->fonti] = f;
                    484: }
                    485:
1.238     schwarze  486: /* Set font, save previous. */
1.125     kristaps  487: void
                    488: term_fontpush(struct termp *p, enum termfont f)
                    489: {
                    490:
                    491:        p->fontl = p->fontq[p->fonti];
1.238     schwarze  492:        if (++p->fonti == p->fontsz) {
                    493:                p->fontsz += 8;
                    494:                p->fontq = mandoc_reallocarray(p->fontq,
1.256     schwarze  495:                    p->fontsz, sizeof(*p->fontq));
1.238     schwarze  496:        }
                    497:        p->fontq[p->fonti] = f;
1.125     kristaps  498: }
                    499:
1.238     schwarze  500: /* Flush to make the saved pointer current again. */
1.125     kristaps  501: void
1.244     schwarze  502: term_fontpopq(struct termp *p, int i)
1.125     kristaps  503: {
                    504:
1.244     schwarze  505:        assert(i >= 0);
                    506:        if (p->fonti > i)
                    507:                p->fonti = i;
1.125     kristaps  508: }
1.94      kristaps  509:
1.238     schwarze  510: /* Pop one font off the stack. */
1.125     kristaps  511: void
                    512: term_fontpop(struct termp *p)
                    513: {
                    514:
                    515:        assert(p->fonti);
                    516:        p->fonti--;
1.17      kristaps  517: }
                    518:
1.71      kristaps  519: /*
                    520:  * Handle pwords, partial words, which may be either a single word or a
                    521:  * phrase that cannot be broken down (such as a literal string).  This
                    522:  * handles word styling.
                    523:  */
1.86      kristaps  524: void
                    525: term_word(struct termp *p, const char *word)
1.65      kristaps  526: {
1.261     schwarze  527:        struct roffsu    su;
1.214     schwarze  528:        const char       nbrsp[2] = { ASCII_NBRSP, 0 };
1.191     kristaps  529:        const char      *seq, *cp;
1.194     kristaps  530:        int              sz, uc;
1.262     schwarze  531:        size_t           csz, lsz, ssz;
1.184     kristaps  532:        enum mandoc_esc  esc;
1.100     kristaps  533:
1.264     schwarze  534:        if ((p->flags & TERMP_NOBUF) == 0) {
                    535:                if ((p->flags & TERMP_NOSPACE) == 0) {
                    536:                        if ((p->flags & TERMP_KEEP) == 0) {
1.151     schwarze  537:                                bufferc(p, ' ');
1.264     schwarze  538:                                if (p->flags & TERMP_SENTENCE)
                    539:                                        bufferc(p, ' ');
                    540:                        } else
                    541:                                bufferc(p, ASCII_NBRSP);
                    542:                }
                    543:                if (p->flags & TERMP_PREKEEP)
                    544:                        p->flags |= TERMP_KEEP;
                    545:                if (p->flags & TERMP_NONOSPACE)
                    546:                        p->flags |= TERMP_NOSPACE;
                    547:                else
                    548:                        p->flags &= ~TERMP_NOSPACE;
                    549:                p->flags &= ~(TERMP_SENTENCE | TERMP_NONEWLINE);
                    550:                p->skipvsp = 0;
1.133     kristaps  551:        }
1.65      kristaps  552:
1.184     kristaps  553:        while ('\0' != *word) {
1.203     schwarze  554:                if ('\\' != *word) {
1.214     schwarze  555:                        if (TERMP_NBRWORD & p->flags) {
                    556:                                if (' ' == *word) {
                    557:                                        encode(p, nbrsp, 1);
                    558:                                        word++;
                    559:                                        continue;
                    560:                                }
                    561:                                ssz = strcspn(word, "\\ ");
                    562:                        } else
                    563:                                ssz = strcspn(word, "\\");
1.162     kristaps  564:                        encode(p, word, ssz);
1.203     schwarze  565:                        word += (int)ssz;
1.124     kristaps  566:                        continue;
1.203     schwarze  567:                }
1.124     kristaps  568:
1.184     kristaps  569:                word++;
                    570:                esc = mandoc_escape(&word, &seq, &sz);
                    571:                switch (esc) {
1.222     schwarze  572:                case ESCAPE_UNICODE:
1.229     schwarze  573:                        uc = mchars_num2uc(seq + 1, sz - 1);
1.192     kristaps  574:                        break;
1.222     schwarze  575:                case ESCAPE_NUMBERED:
1.233     schwarze  576:                        uc = mchars_num2char(seq, sz);
                    577:                        if (uc < 0)
                    578:                                continue;
1.184     kristaps  579:                        break;
1.222     schwarze  580:                case ESCAPE_SPECIAL:
1.229     schwarze  581:                        if (p->enc == TERMENC_ASCII) {
1.254     schwarze  582:                                cp = mchars_spec2str(seq, sz, &ssz);
1.232     schwarze  583:                                if (cp != NULL)
1.229     schwarze  584:                                        encode(p, cp, ssz);
                    585:                        } else {
1.254     schwarze  586:                                uc = mchars_spec2cp(seq, sz);
1.230     schwarze  587:                                if (uc > 0)
                    588:                                        encode1(p, uc);
1.229     schwarze  589:                        }
1.233     schwarze  590:                        continue;
1.277     schwarze  591:                case ESCAPE_UNDEF:
                    592:                        uc = *seq;
                    593:                        break;
1.222     schwarze  594:                case ESCAPE_FONTBOLD:
1.125     kristaps  595:                        term_fontrepl(p, TERMFONT_BOLD);
1.233     schwarze  596:                        continue;
1.222     schwarze  597:                case ESCAPE_FONTITALIC:
1.125     kristaps  598:                        term_fontrepl(p, TERMFONT_UNDER);
1.233     schwarze  599:                        continue;
1.222     schwarze  600:                case ESCAPE_FONTBI:
1.209     schwarze  601:                        term_fontrepl(p, TERMFONT_BI);
1.233     schwarze  602:                        continue;
1.222     schwarze  603:                case ESCAPE_FONT:
1.276     schwarze  604:                case ESCAPE_FONTCW:
1.222     schwarze  605:                case ESCAPE_FONTROMAN:
1.125     kristaps  606:                        term_fontrepl(p, TERMFONT_NONE);
1.233     schwarze  607:                        continue;
1.222     schwarze  608:                case ESCAPE_FONTPREV:
1.125     kristaps  609:                        term_fontlast(p);
1.270     schwarze  610:                        continue;
                    611:                case ESCAPE_BREAK:
                    612:                        bufferc(p, '\n');
1.233     schwarze  613:                        continue;
1.222     schwarze  614:                case ESCAPE_NOSPACE:
1.248     schwarze  615:                        if (p->flags & TERMP_BACKAFTER)
                    616:                                p->flags &= ~TERMP_BACKAFTER;
                    617:                        else if (*word == '\0')
1.237     schwarze  618:                                p->flags |= (TERMP_NOSPACE | TERMP_NONEWLINE);
1.261     schwarze  619:                        continue;
1.275     schwarze  620:                case ESCAPE_DEVICE:
                    621:                        if (p->type == TERMTYPE_PDF)
                    622:                                encode(p, "pdf", 3);
                    623:                        else if (p->type == TERMTYPE_PS)
                    624:                                encode(p, "ps", 2);
                    625:                        else if (p->enc == TERMENC_ASCII)
                    626:                                encode(p, "ascii", 5);
                    627:                        else
                    628:                                encode(p, "utf8", 4);
                    629:                        continue;
1.261     schwarze  630:                case ESCAPE_HORIZ:
1.273     schwarze  631:                        if (*seq == '|') {
                    632:                                seq++;
                    633:                                uc = -p->col;
                    634:                        } else
                    635:                                uc = 0;
1.268     schwarze  636:                        if (a2roffsu(seq, &su, SCALE_EM) == NULL)
1.261     schwarze  637:                                continue;
1.273     schwarze  638:                        uc += term_hen(p, &su);
1.261     schwarze  639:                        if (uc > 0)
                    640:                                while (uc-- > 0)
                    641:                                        bufferc(p, ASCII_NBRSP);
                    642:                        else if (p->col > (size_t)(-uc))
                    643:                                p->col += uc;
                    644:                        else {
                    645:                                uc += p->col;
                    646:                                p->col = 0;
1.266     schwarze  647:                                if (p->tcol->offset > (size_t)(-uc)) {
1.261     schwarze  648:                                        p->ti += uc;
1.266     schwarze  649:                                        p->tcol->offset += uc;
1.261     schwarze  650:                                } else {
1.266     schwarze  651:                                        p->ti -= p->tcol->offset;
                    652:                                        p->tcol->offset = 0;
1.261     schwarze  653:                                }
1.262     schwarze  654:                        }
                    655:                        continue;
                    656:                case ESCAPE_HLINE:
1.272     schwarze  657:                        if ((cp = a2roffsu(seq, &su, SCALE_EM)) == NULL)
1.262     schwarze  658:                                continue;
1.271     schwarze  659:                        uc = term_hen(p, &su);
1.262     schwarze  660:                        if (uc <= 0) {
1.266     schwarze  661:                                if (p->tcol->rmargin <= p->tcol->offset)
1.262     schwarze  662:                                        continue;
1.266     schwarze  663:                                lsz = p->tcol->rmargin - p->tcol->offset;
1.262     schwarze  664:                        } else
                    665:                                lsz = uc;
1.272     schwarze  666:                        if (*cp == seq[-1])
1.262     schwarze  667:                                uc = -1;
1.272     schwarze  668:                        else if (*cp == '\\') {
                    669:                                seq = cp + 1;
1.262     schwarze  670:                                esc = mandoc_escape(&seq, &cp, &sz);
                    671:                                switch (esc) {
                    672:                                case ESCAPE_UNICODE:
                    673:                                        uc = mchars_num2uc(cp + 1, sz - 1);
                    674:                                        break;
                    675:                                case ESCAPE_NUMBERED:
                    676:                                        uc = mchars_num2char(cp, sz);
                    677:                                        break;
                    678:                                case ESCAPE_SPECIAL:
                    679:                                        uc = mchars_spec2cp(cp, sz);
                    680:                                        break;
1.277     schwarze  681:                                case ESCAPE_UNDEF:
                    682:                                        uc = *seq;
                    683:                                        break;
1.262     schwarze  684:                                default:
                    685:                                        uc = -1;
                    686:                                        break;
                    687:                                }
                    688:                        } else
1.272     schwarze  689:                                uc = *cp;
1.262     schwarze  690:                        if (uc < 0x20 || (uc > 0x7E && uc < 0xA0))
                    691:                                uc = '_';
                    692:                        if (p->enc == TERMENC_ASCII) {
                    693:                                cp = ascii_uc2str(uc);
                    694:                                csz = term_strlen(p, cp);
                    695:                                ssz = strlen(cp);
                    696:                        } else
                    697:                                csz = (*p->width)(p, uc);
                    698:                        while (lsz >= csz) {
                    699:                                if (p->enc == TERMENC_ASCII)
                    700:                                        encode(p, cp, ssz);
                    701:                                else
                    702:                                        encode1(p, uc);
                    703:                                lsz -= csz;
1.261     schwarze  704:                        }
1.233     schwarze  705:                        continue;
1.222     schwarze  706:                case ESCAPE_SKIPCHAR:
1.248     schwarze  707:                        p->flags |= TERMP_BACKAFTER;
1.233     schwarze  708:                        continue;
1.243     schwarze  709:                case ESCAPE_OVERSTRIKE:
                    710:                        cp = seq + sz;
                    711:                        while (seq < cp) {
                    712:                                if (*seq == '\\') {
                    713:                                        mandoc_escape(&seq, NULL, NULL);
                    714:                                        continue;
                    715:                                }
                    716:                                encode1(p, *seq++);
1.248     schwarze  717:                                if (seq < cp) {
                    718:                                        if (p->flags & TERMP_BACKBEFORE)
                    719:                                                p->flags |= TERMP_BACKAFTER;
                    720:                                        else
                    721:                                                p->flags |= TERMP_BACKBEFORE;
                    722:                                }
1.243     schwarze  723:                        }
1.249     schwarze  724:                        /* Trim trailing backspace/blank pair. */
1.269     schwarze  725:                        if (p->tcol->lastcol > 2 &&
                    726:                            (p->tcol->buf[p->tcol->lastcol - 1] == ' ' ||
                    727:                             p->tcol->buf[p->tcol->lastcol - 1] == '\t'))
                    728:                                p->tcol->lastcol -= 2;
                    729:                        if (p->col > p->tcol->lastcol)
                    730:                                p->col = p->tcol->lastcol;
1.248     schwarze  731:                        continue;
1.124     kristaps  732:                default:
1.233     schwarze  733:                        continue;
                    734:                }
                    735:
                    736:                /*
                    737:                 * Common handling for Unicode and numbered
                    738:                 * character escape sequences.
                    739:                 */
                    740:
                    741:                if (p->enc == TERMENC_ASCII) {
                    742:                        cp = ascii_uc2str(uc);
                    743:                        encode(p, cp, strlen(cp));
                    744:                } else {
                    745:                        if ((uc < 0x20 && uc != 0x09) ||
                    746:                            (uc > 0x7E && uc < 0xA0))
                    747:                                uc = 0xFFFD;
                    748:                        encode1(p, uc);
1.124     kristaps  749:                }
                    750:        }
1.214     schwarze  751:        p->flags &= ~TERMP_NBRWORD;
1.65      kristaps  752: }
                    753:
1.71      kristaps  754: static void
1.266     schwarze  755: adjbuf(struct termp_col *c, size_t sz)
1.51      kristaps  756: {
1.266     schwarze  757:        if (c->maxcols == 0)
                    758:                c->maxcols = 1024;
                    759:        while (c->maxcols <= sz)
                    760:                c->maxcols <<= 2;
                    761:        c->buf = mandoc_reallocarray(c->buf, c->maxcols, sizeof(*c->buf));
1.51      kristaps  762: }
                    763:
1.79      kristaps  764: static void
1.125     kristaps  765: bufferc(struct termp *p, char c)
                    766: {
1.264     schwarze  767:        if (p->flags & TERMP_NOBUF) {
                    768:                (*p->letter)(p, c);
                    769:                return;
                    770:        }
1.266     schwarze  771:        if (p->col + 1 >= p->tcol->maxcols)
                    772:                adjbuf(p->tcol, p->col + 1);
1.269     schwarze  773:        if (p->tcol->lastcol <= p->col || (c != ' ' && c != ASCII_NBRSP))
1.266     schwarze  774:                p->tcol->buf[p->col] = c;
1.269     schwarze  775:        if (p->tcol->lastcol < ++p->col)
                    776:                p->tcol->lastcol = p->col;
1.125     kristaps  777: }
                    778:
1.194     kristaps  779: /*
                    780:  * See encode().
                    781:  * Do this for a single (probably unicode) value.
                    782:  * Does not check for non-decorated glyphs.
                    783:  */
                    784: static void
                    785: encode1(struct termp *p, int c)
                    786: {
                    787:        enum termfont     f;
                    788:
1.264     schwarze  789:        if (p->flags & TERMP_NOBUF) {
                    790:                (*p->letter)(p, c);
                    791:                return;
                    792:        }
                    793:
1.266     schwarze  794:        if (p->col + 7 >= p->tcol->maxcols)
                    795:                adjbuf(p->tcol, p->col + 7);
1.194     kristaps  796:
1.255     schwarze  797:        f = (c == ASCII_HYPH || c > 127 || isgraph(c)) ?
1.248     schwarze  798:            p->fontq[p->fonti] : TERMFONT_NONE;
1.194     kristaps  799:
1.248     schwarze  800:        if (p->flags & TERMP_BACKBEFORE) {
1.266     schwarze  801:                if (p->tcol->buf[p->col - 1] == ' ' ||
                    802:                    p->tcol->buf[p->col - 1] == '\t')
1.249     schwarze  803:                        p->col--;
                    804:                else
1.266     schwarze  805:                        p->tcol->buf[p->col++] = '\b';
1.248     schwarze  806:                p->flags &= ~TERMP_BACKBEFORE;
                    807:        }
1.266     schwarze  808:        if (f == TERMFONT_UNDER || f == TERMFONT_BI) {
                    809:                p->tcol->buf[p->col++] = '_';
                    810:                p->tcol->buf[p->col++] = '\b';
                    811:        }
                    812:        if (f == TERMFONT_BOLD || f == TERMFONT_BI) {
                    813:                if (c == ASCII_HYPH)
                    814:                        p->tcol->buf[p->col++] = '-';
1.209     schwarze  815:                else
1.266     schwarze  816:                        p->tcol->buf[p->col++] = c;
                    817:                p->tcol->buf[p->col++] = '\b';
1.209     schwarze  818:        }
1.269     schwarze  819:        if (p->tcol->lastcol <= p->col || (c != ' ' && c != ASCII_NBRSP))
1.266     schwarze  820:                p->tcol->buf[p->col] = c;
1.269     schwarze  821:        if (p->tcol->lastcol < ++p->col)
                    822:                p->tcol->lastcol = p->col;
1.248     schwarze  823:        if (p->flags & TERMP_BACKAFTER) {
                    824:                p->flags |= TERMP_BACKBEFORE;
                    825:                p->flags &= ~TERMP_BACKAFTER;
                    826:        }
1.194     kristaps  827: }
                    828:
1.125     kristaps  829: static void
                    830: encode(struct termp *p, const char *word, size_t sz)
                    831: {
1.210     schwarze  832:        size_t            i;
1.264     schwarze  833:
                    834:        if (p->flags & TERMP_NOBUF) {
                    835:                for (i = 0; i < sz; i++)
                    836:                        (*p->letter)(p, word[i]);
                    837:                return;
                    838:        }
1.188     kristaps  839:
1.266     schwarze  840:        if (p->col + 2 + (sz * 5) >= p->tcol->maxcols)
                    841:                adjbuf(p->tcol, p->col + 2 + (sz * 5));
1.165     kristaps  842:
1.210     schwarze  843:        for (i = 0; i < sz; i++) {
1.209     schwarze  844:                if (ASCII_HYPH == word[i] ||
                    845:                    isgraph((unsigned char)word[i]))
                    846:                        encode1(p, word[i]);
1.259     schwarze  847:                else {
1.269     schwarze  848:                        if (p->tcol->lastcol <= p->col ||
1.265     schwarze  849:                            (word[i] != ' ' && word[i] != ASCII_NBRSP))
1.266     schwarze  850:                                p->tcol->buf[p->col] = word[i];
1.265     schwarze  851:                        p->col++;
1.259     schwarze  852:
                    853:                        /*
                    854:                         * Postpone the effect of \z while handling
                    855:                         * an overstrike sequence from ascii_uc2str().
                    856:                         */
                    857:
                    858:                        if (word[i] == '\b' &&
                    859:                            (p->flags & TERMP_BACKBEFORE)) {
                    860:                                p->flags &= ~TERMP_BACKBEFORE;
                    861:                                p->flags |= TERMP_BACKAFTER;
                    862:                        }
                    863:                }
1.79      kristaps  864:        }
1.269     schwarze  865:        if (p->tcol->lastcol < p->col)
                    866:                p->tcol->lastcol = p->col;
1.219     schwarze  867: }
                    868:
                    869: void
                    870: term_setwidth(struct termp *p, const char *wstr)
                    871: {
                    872:        struct roffsu    su;
1.247     schwarze  873:        int              iop, width;
1.219     schwarze  874:
1.220     schwarze  875:        iop = 0;
                    876:        width = 0;
1.219     schwarze  877:        if (NULL != wstr) {
                    878:                switch (*wstr) {
1.222     schwarze  879:                case '+':
1.219     schwarze  880:                        iop = 1;
                    881:                        wstr++;
                    882:                        break;
1.222     schwarze  883:                case '-':
1.219     schwarze  884:                        iop = -1;
                    885:                        wstr++;
                    886:                        break;
                    887:                default:
                    888:                        break;
                    889:                }
1.268     schwarze  890:                if (a2roffsu(wstr, &su, SCALE_MAX) != NULL)
1.220     schwarze  891:                        width = term_hspan(p, &su);
                    892:                else
1.219     schwarze  893:                        iop = 0;
                    894:        }
                    895:        (*p->setwidth)(p, iop, width);
1.79      kristaps  896: }
1.106     kristaps  897:
1.107     kristaps  898: size_t
1.149     kristaps  899: term_len(const struct termp *p, size_t sz)
                    900: {
                    901:
1.252     schwarze  902:        return (*p->width)(p, ' ') * sz;
1.149     kristaps  903: }
                    904:
1.203     schwarze  905: static size_t
                    906: cond_width(const struct termp *p, int c, int *skip)
                    907: {
                    908:
                    909:        if (*skip) {
                    910:                (*skip) = 0;
1.252     schwarze  911:                return 0;
1.203     schwarze  912:        } else
1.252     schwarze  913:                return (*p->width)(p, c);
1.203     schwarze  914: }
1.149     kristaps  915:
                    916: size_t
                    917: term_strlen(const struct termp *p, const char *cp)
                    918: {
1.184     kristaps  919:        size_t           sz, rsz, i;
1.233     schwarze  920:        int              ssz, skip, uc;
1.171     kristaps  921:        const char      *seq, *rhs;
1.196     kristaps  922:        enum mandoc_esc  esc;
1.216     schwarze  923:        static const char rej[] = { '\\', ASCII_NBRSP, ASCII_HYPH,
                    924:                        ASCII_BREAK, '\0' };
1.171     kristaps  925:
1.184     kristaps  926:        /*
                    927:         * Account for escaped sequences within string length
                    928:         * calculations.  This follows the logic in term_word() as we
                    929:         * must calculate the width of produced strings.
                    930:         */
                    931:
                    932:        sz = 0;
1.203     schwarze  933:        skip = 0;
1.189     kristaps  934:        while ('\0' != *cp) {
                    935:                rsz = strcspn(cp, rej);
                    936:                for (i = 0; i < rsz; i++)
1.203     schwarze  937:                        sz += cond_width(p, *cp++, &skip);
1.189     kristaps  938:
1.184     kristaps  939:                switch (*cp) {
1.222     schwarze  940:                case '\\':
1.189     kristaps  941:                        cp++;
1.277     schwarze  942:                        rhs = NULL;
1.196     kristaps  943:                        esc = mandoc_escape(&cp, &seq, &ssz);
                    944:                        switch (esc) {
1.222     schwarze  945:                        case ESCAPE_UNICODE:
1.234     schwarze  946:                                uc = mchars_num2uc(seq + 1, ssz - 1);
1.194     kristaps  947:                                break;
1.222     schwarze  948:                        case ESCAPE_NUMBERED:
1.233     schwarze  949:                                uc = mchars_num2char(seq, ssz);
                    950:                                if (uc < 0)
                    951:                                        continue;
1.171     kristaps  952:                                break;
1.222     schwarze  953:                        case ESCAPE_SPECIAL:
1.233     schwarze  954:                                if (p->enc == TERMENC_ASCII) {
1.254     schwarze  955:                                        rhs = mchars_spec2str(seq, ssz, &rsz);
1.233     schwarze  956:                                        if (rhs != NULL)
                    957:                                                break;
                    958:                                } else {
1.254     schwarze  959:                                        uc = mchars_spec2cp(seq, ssz);
1.233     schwarze  960:                                        if (uc > 0)
                    961:                                                sz += cond_width(p, uc, &skip);
1.229     schwarze  962:                                }
1.233     schwarze  963:                                continue;
1.277     schwarze  964:                        case ESCAPE_UNDEF:
                    965:                                uc = *seq;
                    966:                                break;
1.275     schwarze  967:                        case ESCAPE_DEVICE:
                    968:                                if (p->type == TERMTYPE_PDF) {
                    969:                                        rhs = "pdf";
                    970:                                        rsz = 3;
                    971:                                } else if (p->type == TERMTYPE_PS) {
                    972:                                        rhs = "ps";
                    973:                                        rsz = 2;
                    974:                                } else if (p->enc == TERMENC_ASCII) {
                    975:                                        rhs = "ascii";
                    976:                                        rsz = 5;
                    977:                                } else {
                    978:                                        rhs = "utf8";
                    979:                                        rsz = 4;
                    980:                                }
                    981:                                break;
1.222     schwarze  982:                        case ESCAPE_SKIPCHAR:
1.203     schwarze  983:                                skip = 1;
1.243     schwarze  984:                                continue;
                    985:                        case ESCAPE_OVERSTRIKE:
                    986:                                rsz = 0;
                    987:                                rhs = seq + ssz;
                    988:                                while (seq < rhs) {
                    989:                                        if (*seq == '\\') {
                    990:                                                mandoc_escape(&seq, NULL, NULL);
                    991:                                                continue;
                    992:                                        }
                    993:                                        i = (*p->width)(p, *seq++);
                    994:                                        if (rsz < i)
                    995:                                                rsz = i;
                    996:                                }
                    997:                                sz += rsz;
1.233     schwarze  998:                                continue;
1.171     kristaps  999:                        default:
1.233     schwarze 1000:                                continue;
1.171     kristaps 1001:                        }
1.149     kristaps 1002:
1.233     schwarze 1003:                        /*
                   1004:                         * Common handling for Unicode and numbered
                   1005:                         * character escape sequences.
                   1006:                         */
                   1007:
                   1008:                        if (rhs == NULL) {
                   1009:                                if (p->enc == TERMENC_ASCII) {
                   1010:                                        rhs = ascii_uc2str(uc);
                   1011:                                        rsz = strlen(rhs);
                   1012:                                } else {
                   1013:                                        if ((uc < 0x20 && uc != 0x09) ||
                   1014:                                            (uc > 0x7E && uc < 0xA0))
                   1015:                                                uc = 0xFFFD;
                   1016:                                        sz += cond_width(p, uc, &skip);
                   1017:                                        continue;
                   1018:                                }
                   1019:                        }
1.184     kristaps 1020:
1.203     schwarze 1021:                        if (skip) {
                   1022:                                skip = 0;
                   1023:                                break;
                   1024:                        }
1.233     schwarze 1025:
                   1026:                        /*
                   1027:                         * Common handling for all escape sequences
                   1028:                         * printing more than one character.
                   1029:                         */
1.203     schwarze 1030:
1.184     kristaps 1031:                        for (i = 0; i < rsz; i++)
                   1032:                                sz += (*p->width)(p, *rhs++);
                   1033:                        break;
1.222     schwarze 1034:                case ASCII_NBRSP:
1.203     schwarze 1035:                        sz += cond_width(p, ' ', &skip);
1.176     kristaps 1036:                        cp++;
1.184     kristaps 1037:                        break;
1.222     schwarze 1038:                case ASCII_HYPH:
1.203     schwarze 1039:                        sz += cond_width(p, '-', &skip);
1.176     kristaps 1040:                        cp++;
1.184     kristaps 1041:                        break;
                   1042:                default:
                   1043:                        break;
                   1044:                }
1.189     kristaps 1045:        }
1.149     kristaps 1046:
1.252     schwarze 1047:        return sz;
1.149     kristaps 1048: }
                   1049:
1.240     schwarze 1050: int
1.149     kristaps 1051: term_vspan(const struct termp *p, const struct roffsu *su)
1.106     kristaps 1052: {
                   1053:        double           r;
1.241     schwarze 1054:        int              ri;
1.106     kristaps 1055:
1.107     kristaps 1056:        switch (su->unit) {
1.239     schwarze 1057:        case SCALE_BU:
                   1058:                r = su->scale / 40.0;
                   1059:                break;
1.222     schwarze 1060:        case SCALE_CM:
1.239     schwarze 1061:                r = su->scale * 6.0 / 2.54;
                   1062:                break;
                   1063:        case SCALE_FS:
                   1064:                r = su->scale * 65536.0 / 40.0;
1.106     kristaps 1065:                break;
1.222     schwarze 1066:        case SCALE_IN:
1.225     schwarze 1067:                r = su->scale * 6.0;
1.106     kristaps 1068:                break;
1.239     schwarze 1069:        case SCALE_MM:
                   1070:                r = su->scale * 0.006;
                   1071:                break;
1.222     schwarze 1072:        case SCALE_PC:
1.107     kristaps 1073:                r = su->scale;
1.106     kristaps 1074:                break;
1.222     schwarze 1075:        case SCALE_PT:
1.239     schwarze 1076:                r = su->scale / 12.0;
1.106     kristaps 1077:                break;
1.239     schwarze 1078:        case SCALE_EN:
                   1079:        case SCALE_EM:
                   1080:                r = su->scale * 0.6;
1.106     kristaps 1081:                break;
1.222     schwarze 1082:        case SCALE_VS:
1.107     kristaps 1083:                r = su->scale;
1.106     kristaps 1084:                break;
                   1085:        default:
1.239     schwarze 1086:                abort();
1.106     kristaps 1087:        }
1.241     schwarze 1088:        ri = r > 0.0 ? r + 0.4995 : r - 0.4995;
1.252     schwarze 1089:        return ri < 66 ? ri : 1;
1.106     kristaps 1090: }
                   1091:
1.247     schwarze 1092: /*
1.271     schwarze 1093:  * Convert a scaling width to basic units, rounding towards 0.
1.247     schwarze 1094:  */
1.240     schwarze 1095: int
1.149     kristaps 1096: term_hspan(const struct termp *p, const struct roffsu *su)
1.106     kristaps 1097: {
1.108     kristaps 1098:
1.252     schwarze 1099:        return (*p->hspan)(p, su);
1.271     schwarze 1100: }
                   1101:
                   1102: /*
                   1103:  * Convert a scaling width to basic units, rounding to closest.
                   1104:  */
                   1105: int
                   1106: term_hen(const struct termp *p, const struct roffsu *su)
                   1107: {
                   1108:        int bu;
                   1109:
                   1110:        if ((bu = (*p->hspan)(p, su)) >= 0)
                   1111:                return (bu + 11) / 24;
                   1112:        else
                   1113:                return -((-bu + 11) / 24);
1.106     kristaps 1114: }

CVSweb