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

Annotation of mandoc/man_term.c, Revision 1.157

1.157   ! schwarze    1: /*     $Id: man_term.c,v 1.156 2014/11/21 01:52:53 schwarze Exp $ */
1.1       kristaps    2: /*
1.128     schwarze    3:  * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
1.140     schwarze    4:  * Copyright (c) 2010-2014 Ingo Schwarze <schwarze@openbsd.org>
1.1       kristaps    5:  *
                      6:  * Permission to use, copy, modify, and distribute this software for any
1.8       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.8       kristaps   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.
1.1       kristaps   17:  */
1.55      kristaps   18: #include "config.h"
                     19:
1.28      kristaps   20: #include <sys/types.h>
                     21:
1.1       kristaps   22: #include <assert.h>
1.18      kristaps   23: #include <ctype.h>
1.1       kristaps   24: #include <stdio.h>
                     25: #include <stdlib.h>
                     26: #include <string.h>
                     27:
1.71      kristaps   28: #include "mandoc.h"
1.147     schwarze   29: #include "mandoc_aux.h"
1.40      kristaps   30: #include "out.h"
1.36      kristaps   31: #include "man.h"
1.1       kristaps   32: #include "term.h"
1.36      kristaps   33: #include "main.h"
1.1       kristaps   34:
1.116     schwarze   35: #define        MAXMARGINS        64 /* maximum number of indented scopes */
1.18      kristaps   36:
1.24      kristaps   37: struct mtermp {
                     38:        int               fl;
1.19      kristaps   39: #define        MANT_LITERAL     (1 << 0)
1.116     schwarze   40:        size_t            lmargin[MAXMARGINS]; /* margins (incl. visible page) */
                     41:        int               lmargincur; /* index of current margin */
                     42:        int               lmarginsz; /* actual number of nested margins */
                     43:        size_t            offset; /* default offset to visible page */
1.134     schwarze   44:        int               pardist; /* vert. space before par., unit: [v] */
1.24      kristaps   45: };
1.19      kristaps   46:
1.146     schwarze   47: #define        DECL_ARGS         struct termp *p, \
1.24      kristaps   48:                          struct mtermp *mt, \
1.1       kristaps   49:                          const struct man_node *n, \
1.135     schwarze   50:                          const struct man_meta *meta
1.1       kristaps   51:
                     52: struct termact {
                     53:        int             (*pre)(DECL_ARGS);
                     54:        void            (*post)(DECL_ARGS);
1.56      kristaps   55:        int               flags;
                     56: #define        MAN_NOTEXT       (1 << 0) /* Never has text children. */
1.1       kristaps   57: };
                     58:
1.77      kristaps   59: static int               a2width(const struct termp *, const char *);
                     60: static size_t            a2height(const struct termp *, const char *);
1.39      kristaps   61:
1.52      kristaps   62: static void              print_man_nodelist(DECL_ARGS);
1.45      kristaps   63: static void              print_man_node(DECL_ARGS);
1.74      kristaps   64: static void              print_man_head(struct termp *, const void *);
1.73      kristaps   65: static void              print_man_foot(struct termp *, const void *);
1.146     schwarze   66: static void              print_bvspace(struct termp *,
1.134     schwarze   67:                                const struct man_node *, int);
1.39      kristaps   68:
1.1       kristaps   69: static int               pre_B(DECL_ARGS);
1.19      kristaps   70: static int               pre_HP(DECL_ARGS);
1.1       kristaps   71: static int               pre_I(DECL_ARGS);
1.4       kristaps   72: static int               pre_IP(DECL_ARGS);
1.127     kristaps   73: static int               pre_OP(DECL_ARGS);
1.134     schwarze   74: static int               pre_PD(DECL_ARGS);
1.1       kristaps   75: static int               pre_PP(DECL_ARGS);
1.26      kristaps   76: static int               pre_RS(DECL_ARGS);
1.1       kristaps   77: static int               pre_SH(DECL_ARGS);
                     78: static int               pre_SS(DECL_ARGS);
                     79: static int               pre_TP(DECL_ARGS);
1.137     schwarze   80: static int               pre_UR(DECL_ARGS);
1.127     kristaps   81: static int               pre_alternate(DECL_ARGS);
                     82: static int               pre_ft(DECL_ARGS);
1.29      kristaps   83: static int               pre_ign(DECL_ARGS);
1.83      kristaps   84: static int               pre_in(DECL_ARGS);
1.84      kristaps   85: static int               pre_literal(DECL_ARGS);
1.143     schwarze   86: static int               pre_ll(DECL_ARGS);
1.19      kristaps   87: static int               pre_sp(DECL_ARGS);
1.1       kristaps   88:
1.22      kristaps   89: static void              post_IP(DECL_ARGS);
1.20      kristaps   90: static void              post_HP(DECL_ARGS);
1.26      kristaps   91: static void              post_RS(DECL_ARGS);
1.1       kristaps   92: static void              post_SH(DECL_ARGS);
                     93: static void              post_SS(DECL_ARGS);
1.21      kristaps   94: static void              post_TP(DECL_ARGS);
1.137     schwarze   95: static void              post_UR(DECL_ARGS);
1.1       kristaps   96:
1.32      kristaps   97: static const struct termact termacts[MAN_MAX] = {
1.82      kristaps   98:        { pre_sp, NULL, MAN_NOTEXT }, /* br */
1.56      kristaps   99:        { NULL, NULL, 0 }, /* TH */
                    100:        { pre_SH, post_SH, 0 }, /* SH */
                    101:        { pre_SS, post_SS, 0 }, /* SS */
                    102:        { pre_TP, post_TP, 0 }, /* TP */
                    103:        { pre_PP, NULL, 0 }, /* LP */
                    104:        { pre_PP, NULL, 0 }, /* PP */
                    105:        { pre_PP, NULL, 0 }, /* P */
                    106:        { pre_IP, post_IP, 0 }, /* IP */
1.146     schwarze  107:        { pre_HP, post_HP, 0 }, /* HP */
1.56      kristaps  108:        { NULL, NULL, 0 }, /* SM */
                    109:        { pre_B, NULL, 0 }, /* SB */
1.88      kristaps  110:        { pre_alternate, NULL, 0 }, /* BI */
                    111:        { pre_alternate, NULL, 0 }, /* IB */
                    112:        { pre_alternate, NULL, 0 }, /* BR */
                    113:        { pre_alternate, NULL, 0 }, /* RB */
1.56      kristaps  114:        { NULL, NULL, 0 }, /* R */
                    115:        { pre_B, NULL, 0 }, /* B */
                    116:        { pre_I, NULL, 0 }, /* I */
1.88      kristaps  117:        { pre_alternate, NULL, 0 }, /* IR */
                    118:        { pre_alternate, NULL, 0 }, /* RI */
1.99      schwarze  119:        { pre_ign, NULL, MAN_NOTEXT }, /* na */
1.56      kristaps  120:        { pre_sp, NULL, MAN_NOTEXT }, /* sp */
1.84      kristaps  121:        { pre_literal, NULL, 0 }, /* nf */
                    122:        { pre_literal, NULL, 0 }, /* fi */
1.56      kristaps  123:        { NULL, NULL, 0 }, /* RE */
                    124:        { pre_RS, post_RS, 0 }, /* RS */
                    125:        { pre_ign, NULL, 0 }, /* DT */
                    126:        { pre_ign, NULL, 0 }, /* UC */
1.134     schwarze  127:        { pre_PD, NULL, MAN_NOTEXT }, /* PD */
1.70      joerg     128:        { pre_ign, NULL, 0 }, /* AT */
1.83      kristaps  129:        { pre_in, NULL, MAN_NOTEXT }, /* in */
1.89      kristaps  130:        { pre_ft, NULL, MAN_NOTEXT }, /* ft */
1.127     kristaps  131:        { pre_OP, NULL, 0 }, /* OP */
1.129     schwarze  132:        { pre_literal, NULL, 0 }, /* EX */
                    133:        { pre_literal, NULL, 0 }, /* EE */
1.137     schwarze  134:        { pre_UR, post_UR, 0 }, /* UR */
                    135:        { NULL, NULL, 0 }, /* UE */
1.143     schwarze  136:        { pre_ll, NULL, MAN_NOTEXT }, /* ll */
1.1       kristaps  137: };
                    138:
                    139:
1.31      kristaps  140: void
1.36      kristaps  141: terminal_man(void *arg, const struct man *man)
1.1       kristaps  142: {
1.36      kristaps  143:        struct termp            *p;
1.135     schwarze  144:        const struct man_meta   *meta;
1.151     schwarze  145:        struct man_node         *n;
1.36      kristaps  146:        struct mtermp            mt;
                    147:
                    148:        p = (struct termp *)arg;
                    149:
1.58      kristaps  150:        p->overstep = 0;
1.151     schwarze  151:        p->rmargin = p->maxrmargin = p->defrmargin;
1.77      kristaps  152:        p->tabwidth = term_len(p, 5);
1.36      kristaps  153:
1.151     schwarze  154:        n = man_node(man)->child;
1.135     schwarze  155:        meta = man_meta(man);
1.1       kristaps  156:
1.116     schwarze  157:        memset(&mt, 0, sizeof(struct mtermp));
                    158:
1.122     schwarze  159:        mt.lmargin[mt.lmargincur] = term_len(p, p->defindent);
                    160:        mt.offset = term_len(p, p->defindent);
1.134     schwarze  161:        mt.pardist = 1;
1.24      kristaps  162:
1.151     schwarze  163:        if (p->synopsisonly) {
                    164:                while (n != NULL) {
                    165:                        if (n->tok == MAN_SH &&
                    166:                            n->child->child->type == MAN_TEXT &&
                    167:                            !strcmp(n->child->child->string, "SYNOPSIS")) {
                    168:                                if (n->child->next->child != NULL)
                    169:                                        print_man_nodelist(p, &mt,
                    170:                                            n->child->next->child, meta);
                    171:                                term_newln(p);
                    172:                                break;
                    173:                        }
                    174:                        n = n->next;
                    175:                }
                    176:        } else {
                    177:                if (p->defindent == 0)
                    178:                        p->defindent = 7;
                    179:                term_begin(p, print_man_head, print_man_foot, meta);
                    180:                p->flags |= TERMP_NOSPACE;
                    181:                if (n != NULL)
                    182:                        print_man_nodelist(p, &mt, n, meta);
                    183:                term_end(p);
                    184:        }
1.1       kristaps  185: }
                    186:
                    187:
1.77      kristaps  188: static size_t
                    189: a2height(const struct termp *p, const char *cp)
1.18      kristaps  190: {
1.40      kristaps  191:        struct roffsu    su;
1.18      kristaps  192:
1.77      kristaps  193:        if ( ! a2roffsu(cp, &su, SCALE_VS))
1.112     kristaps  194:                SCALE_VS_INIT(&su, atoi(cp));
1.18      kristaps  195:
1.77      kristaps  196:        return(term_vspan(p, &su));
1.18      kristaps  197: }
                    198:
                    199: static int
1.77      kristaps  200: a2width(const struct termp *p, const char *cp)
1.38      kristaps  201: {
1.40      kristaps  202:        struct roffsu    su;
1.38      kristaps  203:
1.77      kristaps  204:        if ( ! a2roffsu(cp, &su, SCALE_BU))
1.41      kristaps  205:                return(-1);
1.40      kristaps  206:
1.77      kristaps  207:        return((int)term_hspan(p, &su));
1.38      kristaps  208: }
                    209:
1.111     kristaps  210: /*
                    211:  * Printing leading vertical space before a block.
                    212:  * This is used for the paragraph macros.
                    213:  * The rules are pretty simple, since there's very little nesting going
                    214:  * on here.  Basically, if we're the first within another block (SS/SH),
                    215:  * then don't emit vertical space.  If we are (RS), then do.  If not the
                    216:  * first, print it.
                    217:  */
1.39      kristaps  218: static void
1.134     schwarze  219: print_bvspace(struct termp *p, const struct man_node *n, int pardist)
1.18      kristaps  220: {
1.134     schwarze  221:        int      i;
1.111     kristaps  222:
1.39      kristaps  223:        term_newln(p);
1.101     schwarze  224:
1.111     kristaps  225:        if (n->body && n->body->child)
                    226:                if (MAN_TBL == n->body->child->type)
                    227:                        return;
                    228:
                    229:        if (MAN_ROOT == n->parent->type || MAN_RS != n->parent->tok)
                    230:                if (NULL == n->prev)
                    231:                        return;
1.18      kristaps  232:
1.134     schwarze  233:        for (i = 0; i < pardist; i++)
                    234:                term_vspace(p);
1.18      kristaps  235: }
                    236:
1.146     schwarze  237:
1.1       kristaps  238: static int
1.29      kristaps  239: pre_ign(DECL_ARGS)
                    240: {
                    241:
1.143     schwarze  242:        return(0);
                    243: }
                    244:
                    245: static int
                    246: pre_ll(DECL_ARGS)
                    247: {
                    248:
1.144     schwarze  249:        term_setwidth(p, n->nchild ? n->child->string : NULL);
1.29      kristaps  250:        return(0);
                    251: }
                    252:
                    253: static int
1.1       kristaps  254: pre_I(DECL_ARGS)
                    255: {
                    256:
1.52      kristaps  257:        term_fontrepl(p, TERMFONT_UNDER);
1.19      kristaps  258:        return(1);
                    259: }
                    260:
1.3       kristaps  261: static int
1.84      kristaps  262: pre_literal(DECL_ARGS)
1.19      kristaps  263: {
                    264:
1.81      kristaps  265:        term_newln(p);
1.88      kristaps  266:
1.129     schwarze  267:        if (MAN_nf == n->tok || MAN_EX == n->tok)
1.84      kristaps  268:                mt->fl |= MANT_LITERAL;
1.88      kristaps  269:        else
1.84      kristaps  270:                mt->fl &= ~MANT_LITERAL;
                    271:
1.117     schwarze  272:        /*
                    273:         * Unlike .IP and .TP, .HP does not have a HEAD.
                    274:         * So in case a second call to term_flushln() is needed,
                    275:         * indentation has to be set up explicitly.
                    276:         */
                    277:        if (MAN_HP == n->parent->tok && p->rmargin < p->maxrmargin) {
1.121     schwarze  278:                p->offset = p->rmargin;
1.117     schwarze  279:                p->rmargin = p->maxrmargin;
1.139     schwarze  280:                p->trailspace = 0;
1.145     schwarze  281:                p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
1.117     schwarze  282:                p->flags |= TERMP_NOSPACE;
                    283:        }
                    284:
1.99      schwarze  285:        return(0);
1.19      kristaps  286: }
                    287:
                    288: static int
1.134     schwarze  289: pre_PD(DECL_ARGS)
                    290: {
                    291:
                    292:        n = n->child;
                    293:        if (0 == n) {
                    294:                mt->pardist = 1;
                    295:                return(0);
                    296:        }
                    297:        assert(MAN_TEXT == n->type);
                    298:        mt->pardist = atoi(n->string);
                    299:        return(0);
                    300: }
                    301:
                    302: static int
1.88      kristaps  303: pre_alternate(DECL_ARGS)
1.3       kristaps  304: {
1.88      kristaps  305:        enum termfont            font[2];
                    306:        const struct man_node   *nn;
                    307:        int                      savelit, i;
1.3       kristaps  308:
1.88      kristaps  309:        switch (n->tok) {
1.146     schwarze  310:        case MAN_RB:
1.88      kristaps  311:                font[0] = TERMFONT_NONE;
                    312:                font[1] = TERMFONT_BOLD;
                    313:                break;
1.146     schwarze  314:        case MAN_RI:
1.88      kristaps  315:                font[0] = TERMFONT_NONE;
                    316:                font[1] = TERMFONT_UNDER;
                    317:                break;
1.146     schwarze  318:        case MAN_BR:
1.88      kristaps  319:                font[0] = TERMFONT_BOLD;
                    320:                font[1] = TERMFONT_NONE;
                    321:                break;
1.146     schwarze  322:        case MAN_BI:
1.88      kristaps  323:                font[0] = TERMFONT_BOLD;
                    324:                font[1] = TERMFONT_UNDER;
                    325:                break;
1.146     schwarze  326:        case MAN_IR:
1.88      kristaps  327:                font[0] = TERMFONT_UNDER;
                    328:                font[1] = TERMFONT_NONE;
                    329:                break;
1.146     schwarze  330:        case MAN_IB:
1.88      kristaps  331:                font[0] = TERMFONT_UNDER;
                    332:                font[1] = TERMFONT_BOLD;
                    333:                break;
                    334:        default:
                    335:                abort();
                    336:        }
1.35      kristaps  337:
1.88      kristaps  338:        savelit = MANT_LITERAL & mt->fl;
                    339:        mt->fl &= ~MANT_LITERAL;
1.35      kristaps  340:
1.88      kristaps  341:        for (i = 0, nn = n->child; nn; nn = nn->next, i = 1 - i) {
                    342:                term_fontrepl(p, font[i]);
                    343:                if (savelit && NULL == nn->next)
                    344:                        mt->fl |= MANT_LITERAL;
1.135     schwarze  345:                print_man_node(p, mt, nn, meta);
1.88      kristaps  346:                if (nn->next)
1.4       kristaps  347:                        p->flags |= TERMP_NOSPACE;
1.3       kristaps  348:        }
                    349:
                    350:        return(0);
                    351: }
                    352:
1.1       kristaps  353: static int
                    354: pre_B(DECL_ARGS)
                    355: {
                    356:
1.52      kristaps  357:        term_fontrepl(p, TERMFONT_BOLD);
1.1       kristaps  358:        return(1);
1.127     kristaps  359: }
                    360:
                    361: static int
                    362: pre_OP(DECL_ARGS)
                    363: {
                    364:
                    365:        term_word(p, "[");
                    366:        p->flags |= TERMP_NOSPACE;
                    367:
                    368:        if (NULL != (n = n->child)) {
                    369:                term_fontrepl(p, TERMFONT_BOLD);
                    370:                term_word(p, n->string);
                    371:        }
                    372:        if (NULL != n && NULL != n->next) {
                    373:                term_fontrepl(p, TERMFONT_UNDER);
                    374:                term_word(p, n->next->string);
                    375:        }
                    376:
                    377:        term_fontrepl(p, TERMFONT_NONE);
                    378:        p->flags |= TERMP_NOSPACE;
                    379:        term_word(p, "]");
                    380:        return(0);
1.89      kristaps  381: }
                    382:
                    383: static int
                    384: pre_ft(DECL_ARGS)
                    385: {
                    386:        const char      *cp;
                    387:
                    388:        if (NULL == n->child) {
                    389:                term_fontlast(p);
                    390:                return(0);
                    391:        }
                    392:
                    393:        cp = n->child->string;
                    394:        switch (*cp) {
1.146     schwarze  395:        case '4':
1.89      kristaps  396:                /* FALLTHROUGH */
1.146     schwarze  397:        case '3':
1.89      kristaps  398:                /* FALLTHROUGH */
1.146     schwarze  399:        case 'B':
1.89      kristaps  400:                term_fontrepl(p, TERMFONT_BOLD);
                    401:                break;
1.146     schwarze  402:        case '2':
1.89      kristaps  403:                /* FALLTHROUGH */
1.146     schwarze  404:        case 'I':
1.89      kristaps  405:                term_fontrepl(p, TERMFONT_UNDER);
                    406:                break;
1.146     schwarze  407:        case 'P':
1.89      kristaps  408:                term_fontlast(p);
                    409:                break;
1.146     schwarze  410:        case '1':
1.89      kristaps  411:                /* FALLTHROUGH */
1.146     schwarze  412:        case 'C':
1.89      kristaps  413:                /* FALLTHROUGH */
1.146     schwarze  414:        case 'R':
1.89      kristaps  415:                term_fontrepl(p, TERMFONT_NONE);
                    416:                break;
                    417:        default:
                    418:                break;
                    419:        }
                    420:        return(0);
1.83      kristaps  421: }
                    422:
                    423: static int
                    424: pre_in(DECL_ARGS)
                    425: {
                    426:        int              len, less;
                    427:        size_t           v;
                    428:        const char      *cp;
                    429:
                    430:        term_newln(p);
                    431:
                    432:        if (NULL == n->child) {
                    433:                p->offset = mt->offset;
                    434:                return(0);
                    435:        }
                    436:
                    437:        cp = n->child->string;
                    438:        less = 0;
                    439:
                    440:        if ('-' == *cp)
                    441:                less = -1;
                    442:        else if ('+' == *cp)
                    443:                less = 1;
                    444:        else
                    445:                cp--;
                    446:
                    447:        if ((len = a2width(p, ++cp)) < 0)
                    448:                return(0);
                    449:
                    450:        v = (size_t)len;
                    451:
                    452:        if (less < 0)
                    453:                p->offset -= p->offset > v ? v : p->offset;
                    454:        else if (less > 0)
                    455:                p->offset += v;
1.146     schwarze  456:        else
1.83      kristaps  457:                p->offset = v;
1.95      kristaps  458:
1.83      kristaps  459:        return(0);
1.1       kristaps  460: }
                    461:
                    462: static int
1.19      kristaps  463: pre_sp(DECL_ARGS)
                    464: {
1.131     schwarze  465:        char            *s;
1.77      kristaps  466:        size_t           i, len;
1.131     schwarze  467:        int              neg;
1.112     kristaps  468:
                    469:        if ((NULL == n->prev && n->parent)) {
1.132     schwarze  470:                switch (n->parent->tok) {
1.146     schwarze  471:                case MAN_SH:
1.132     schwarze  472:                        /* FALLTHROUGH */
1.146     schwarze  473:                case MAN_SS:
1.132     schwarze  474:                        /* FALLTHROUGH */
1.146     schwarze  475:                case MAN_PP:
1.132     schwarze  476:                        /* FALLTHROUGH */
1.146     schwarze  477:                case MAN_LP:
1.132     schwarze  478:                        /* FALLTHROUGH */
1.146     schwarze  479:                case MAN_P:
1.132     schwarze  480:                        /* FALLTHROUGH */
1.112     kristaps  481:                        return(0);
1.132     schwarze  482:                default:
                    483:                        break;
                    484:                }
1.112     kristaps  485:        }
1.19      kristaps  486:
1.131     schwarze  487:        neg = 0;
1.82      kristaps  488:        switch (n->tok) {
1.146     schwarze  489:        case MAN_br:
1.82      kristaps  490:                len = 0;
                    491:                break;
                    492:        default:
1.131     schwarze  493:                if (NULL == n->child) {
                    494:                        len = 1;
                    495:                        break;
                    496:                }
                    497:                s = n->child->string;
                    498:                if ('-' == *s) {
                    499:                        neg = 1;
                    500:                        s++;
                    501:                }
                    502:                len = a2height(p, s);
1.82      kristaps  503:                break;
                    504:        }
1.38      kristaps  505:
1.19      kristaps  506:        if (0 == len)
                    507:                term_newln(p);
1.131     schwarze  508:        else if (neg)
                    509:                p->skipvsp += len;
                    510:        else
                    511:                for (i = 0; i < len; i++)
                    512:                        term_vspace(p);
1.19      kristaps  513:
1.15      kristaps  514:        return(0);
                    515: }
                    516:
                    517: static int
1.19      kristaps  518: pre_HP(DECL_ARGS)
                    519: {
1.117     schwarze  520:        size_t                   len, one;
1.24      kristaps  521:        int                      ival;
                    522:        const struct man_node   *nn;
1.19      kristaps  523:
1.20      kristaps  524:        switch (n->type) {
1.146     schwarze  525:        case MAN_BLOCK:
1.134     schwarze  526:                print_bvspace(p, n, mt->pardist);
1.24      kristaps  527:                return(1);
1.146     schwarze  528:        case MAN_BODY:
1.20      kristaps  529:                break;
                    530:        default:
                    531:                return(0);
                    532:        }
                    533:
1.130     schwarze  534:        if ( ! (MANT_LITERAL & mt->fl)) {
1.145     schwarze  535:                p->flags |= TERMP_NOBREAK | TERMP_BRIND;
1.139     schwarze  536:                p->trailspace = 2;
1.130     schwarze  537:        }
                    538:
1.116     schwarze  539:        len = mt->lmargin[mt->lmargincur];
1.24      kristaps  540:        ival = -1;
                    541:
                    542:        /* Calculate offset. */
                    543:
1.39      kristaps  544:        if (NULL != (nn = n->parent->head->child))
1.77      kristaps  545:                if ((ival = a2width(p, nn->string)) >= 0)
1.24      kristaps  546:                        len = (size_t)ival;
                    547:
1.117     schwarze  548:        one = term_len(p, 1);
1.121     schwarze  549:        if (len < one)
1.117     schwarze  550:                len = one;
1.24      kristaps  551:
1.26      kristaps  552:        p->offset = mt->offset;
                    553:        p->rmargin = mt->offset + len;
1.24      kristaps  554:
                    555:        if (ival >= 0)
1.116     schwarze  556:                mt->lmargin[mt->lmargincur] = (size_t)ival;
1.24      kristaps  557:
1.19      kristaps  558:        return(1);
                    559: }
                    560:
1.20      kristaps  561: static void
                    562: post_HP(DECL_ARGS)
                    563: {
                    564:
                    565:        switch (n->type) {
1.146     schwarze  566:        case MAN_BODY:
1.136     schwarze  567:                term_newln(p);
1.145     schwarze  568:                p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
1.139     schwarze  569:                p->trailspace = 0;
1.26      kristaps  570:                p->offset = mt->offset;
1.20      kristaps  571:                p->rmargin = p->maxrmargin;
                    572:                break;
                    573:        default:
                    574:                break;
                    575:        }
                    576: }
                    577:
1.19      kristaps  578: static int
1.1       kristaps  579: pre_PP(DECL_ARGS)
                    580: {
                    581:
1.19      kristaps  582:        switch (n->type) {
1.146     schwarze  583:        case MAN_BLOCK:
1.122     schwarze  584:                mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
1.134     schwarze  585:                print_bvspace(p, n, mt->pardist);
1.19      kristaps  586:                break;
                    587:        default:
1.26      kristaps  588:                p->offset = mt->offset;
1.19      kristaps  589:                break;
                    590:        }
                    591:
1.87      kristaps  592:        return(MAN_HEAD != n->type);
1.1       kristaps  593: }
                    594:
                    595: static int
1.4       kristaps  596: pre_IP(DECL_ARGS)
                    597: {
1.22      kristaps  598:        const struct man_node   *nn;
                    599:        size_t                   len;
1.94      schwarze  600:        int                      savelit, ival;
1.18      kristaps  601:
1.22      kristaps  602:        switch (n->type) {
1.146     schwarze  603:        case MAN_BODY:
1.22      kristaps  604:                p->flags |= TERMP_NOSPACE;
                    605:                break;
1.146     schwarze  606:        case MAN_HEAD:
1.22      kristaps  607:                p->flags |= TERMP_NOBREAK;
1.139     schwarze  608:                p->trailspace = 1;
1.22      kristaps  609:                break;
1.146     schwarze  610:        case MAN_BLOCK:
1.134     schwarze  611:                print_bvspace(p, n, mt->pardist);
1.23      kristaps  612:                /* FALLTHROUGH */
1.22      kristaps  613:        default:
                    614:                return(1);
                    615:        }
1.18      kristaps  616:
1.116     schwarze  617:        len = mt->lmargin[mt->lmargincur];
1.22      kristaps  618:        ival = -1;
1.4       kristaps  619:
1.94      schwarze  620:        /* Calculate the offset from the optional second argument. */
1.22      kristaps  621:        if (NULL != (nn = n->parent->head->child))
1.94      schwarze  622:                if (NULL != (nn = nn->next))
1.77      kristaps  623:                        if ((ival = a2width(p, nn->string)) >= 0)
1.22      kristaps  624:                                len = (size_t)ival;
1.4       kristaps  625:
1.22      kristaps  626:        switch (n->type) {
1.146     schwarze  627:        case MAN_HEAD:
1.23      kristaps  628:                /* Handle zero-width lengths. */
                    629:                if (0 == len)
1.77      kristaps  630:                        len = term_len(p, 1);
1.23      kristaps  631:
1.26      kristaps  632:                p->offset = mt->offset;
                    633:                p->rmargin = mt->offset + len;
1.22      kristaps  634:                if (ival < 0)
                    635:                        break;
1.18      kristaps  636:
1.24      kristaps  637:                /* Set the saved left-margin. */
1.116     schwarze  638:                mt->lmargin[mt->lmargincur] = (size_t)ival;
1.24      kristaps  639:
1.94      schwarze  640:                savelit = MANT_LITERAL & mt->fl;
                    641:                mt->fl &= ~MANT_LITERAL;
                    642:
                    643:                if (n->child)
1.135     schwarze  644:                        print_man_node(p, mt, n->child, meta);
1.94      schwarze  645:
                    646:                if (savelit)
                    647:                        mt->fl |= MANT_LITERAL;
                    648:
1.22      kristaps  649:                return(0);
1.146     schwarze  650:        case MAN_BODY:
1.26      kristaps  651:                p->offset = mt->offset + len;
1.156     schwarze  652:                p->rmargin = p->maxrmargin;
1.23      kristaps  653:                break;
1.22      kristaps  654:        default:
                    655:                break;
1.18      kristaps  656:        }
                    657:
1.22      kristaps  658:        return(1);
                    659: }
1.18      kristaps  660:
1.22      kristaps  661: static void
                    662: post_IP(DECL_ARGS)
                    663: {
1.4       kristaps  664:
1.22      kristaps  665:        switch (n->type) {
1.146     schwarze  666:        case MAN_HEAD:
1.22      kristaps  667:                term_flushln(p);
                    668:                p->flags &= ~TERMP_NOBREAK;
1.139     schwarze  669:                p->trailspace = 0;
1.22      kristaps  670:                p->rmargin = p->maxrmargin;
                    671:                break;
1.146     schwarze  672:        case MAN_BODY:
1.94      schwarze  673:                term_newln(p);
1.138     schwarze  674:                p->offset = mt->offset;
1.22      kristaps  675:                break;
                    676:        default:
                    677:                break;
                    678:        }
1.4       kristaps  679: }
                    680:
                    681: static int
1.1       kristaps  682: pre_TP(DECL_ARGS)
                    683: {
1.23      kristaps  684:        const struct man_node   *nn;
                    685:        size_t                   len;
1.94      schwarze  686:        int                      savelit, ival;
1.1       kristaps  687:
1.21      kristaps  688:        switch (n->type) {
1.146     schwarze  689:        case MAN_HEAD:
1.21      kristaps  690:                p->flags |= TERMP_NOBREAK;
1.139     schwarze  691:                p->trailspace = 1;
1.21      kristaps  692:                break;
1.146     schwarze  693:        case MAN_BODY:
1.21      kristaps  694:                p->flags |= TERMP_NOSPACE;
1.23      kristaps  695:                break;
1.146     schwarze  696:        case MAN_BLOCK:
1.134     schwarze  697:                print_bvspace(p, n, mt->pardist);
1.23      kristaps  698:                /* FALLTHROUGH */
                    699:        default:
                    700:                return(1);
                    701:        }
                    702:
1.116     schwarze  703:        len = (size_t)mt->lmargin[mt->lmargincur];
1.23      kristaps  704:        ival = -1;
                    705:
                    706:        /* Calculate offset. */
                    707:
1.116     schwarze  708:        if (NULL != (nn = n->parent->head->child))
1.141     schwarze  709:                if (nn->string && 0 == (MAN_LINE & nn->flags))
1.77      kristaps  710:                        if ((ival = a2width(p, nn->string)) >= 0)
1.23      kristaps  711:                                len = (size_t)ival;
                    712:
                    713:        switch (n->type) {
1.146     schwarze  714:        case MAN_HEAD:
1.23      kristaps  715:                /* Handle zero-length properly. */
                    716:                if (0 == len)
1.77      kristaps  717:                        len = term_len(p, 1);
1.23      kristaps  718:
1.26      kristaps  719:                p->offset = mt->offset;
                    720:                p->rmargin = mt->offset + len;
1.23      kristaps  721:
1.94      schwarze  722:                savelit = MANT_LITERAL & mt->fl;
                    723:                mt->fl &= ~MANT_LITERAL;
                    724:
1.23      kristaps  725:                /* Don't print same-line elements. */
1.141     schwarze  726:                nn = n->child;
                    727:                while (NULL != nn && 0 == (MAN_LINE & nn->flags))
                    728:                        nn = nn->next;
                    729:
                    730:                while (NULL != nn) {
                    731:                        print_man_node(p, mt, nn, meta);
                    732:                        nn = nn->next;
                    733:                }
1.24      kristaps  734:
1.94      schwarze  735:                if (savelit)
                    736:                        mt->fl |= MANT_LITERAL;
1.24      kristaps  737:                if (ival >= 0)
1.116     schwarze  738:                        mt->lmargin[mt->lmargincur] = (size_t)ival;
1.24      kristaps  739:
1.23      kristaps  740:                return(0);
1.146     schwarze  741:        case MAN_BODY:
1.26      kristaps  742:                p->offset = mt->offset + len;
1.156     schwarze  743:                p->rmargin = p->maxrmargin;
1.139     schwarze  744:                p->trailspace = 0;
1.130     schwarze  745:                p->flags &= ~TERMP_NOBREAK;
1.21      kristaps  746:                break;
                    747:        default:
                    748:                break;
                    749:        }
1.16      kristaps  750:
1.21      kristaps  751:        return(1);
                    752: }
1.1       kristaps  753:
1.21      kristaps  754: static void
                    755: post_TP(DECL_ARGS)
                    756: {
1.1       kristaps  757:
1.21      kristaps  758:        switch (n->type) {
1.146     schwarze  759:        case MAN_HEAD:
1.21      kristaps  760:                term_flushln(p);
                    761:                break;
1.146     schwarze  762:        case MAN_BODY:
1.94      schwarze  763:                term_newln(p);
1.138     schwarze  764:                p->offset = mt->offset;
1.21      kristaps  765:                break;
                    766:        default:
                    767:                break;
                    768:        }
1.1       kristaps  769: }
                    770:
                    771: static int
                    772: pre_SS(DECL_ARGS)
                    773: {
1.134     schwarze  774:        int      i;
1.1       kristaps  775:
1.19      kristaps  776:        switch (n->type) {
1.146     schwarze  777:        case MAN_BLOCK:
1.113     kristaps  778:                mt->fl &= ~MANT_LITERAL;
1.122     schwarze  779:                mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
                    780:                mt->offset = term_len(p, p->defindent);
1.24      kristaps  781:                /* If following a prior empty `SS', no vspace. */
                    782:                if (n->prev && MAN_SS == n->prev->tok)
                    783:                        if (NULL == n->prev->body->child)
                    784:                                break;
                    785:                if (NULL == n->prev)
                    786:                        break;
1.134     schwarze  787:                for (i = 0; i < mt->pardist; i++)
                    788:                        term_vspace(p);
1.19      kristaps  789:                break;
1.146     schwarze  790:        case MAN_HEAD:
1.52      kristaps  791:                term_fontrepl(p, TERMFONT_BOLD);
1.133     schwarze  792:                p->offset = term_len(p, 3);
1.19      kristaps  793:                break;
1.146     schwarze  794:        case MAN_BODY:
1.26      kristaps  795:                p->offset = mt->offset;
1.24      kristaps  796:                break;
1.19      kristaps  797:        default:
                    798:                break;
                    799:        }
                    800:
1.1       kristaps  801:        return(1);
                    802: }
                    803:
                    804: static void
                    805: post_SS(DECL_ARGS)
                    806: {
1.146     schwarze  807:
1.19      kristaps  808:        switch (n->type) {
1.146     schwarze  809:        case MAN_HEAD:
1.19      kristaps  810:                term_newln(p);
                    811:                break;
1.146     schwarze  812:        case MAN_BODY:
1.24      kristaps  813:                term_newln(p);
                    814:                break;
1.19      kristaps  815:        default:
                    816:                break;
                    817:        }
1.1       kristaps  818: }
                    819:
                    820: static int
                    821: pre_SH(DECL_ARGS)
                    822: {
1.134     schwarze  823:        int      i;
1.22      kristaps  824:
1.19      kristaps  825:        switch (n->type) {
1.146     schwarze  826:        case MAN_BLOCK:
1.113     kristaps  827:                mt->fl &= ~MANT_LITERAL;
1.122     schwarze  828:                mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
                    829:                mt->offset = term_len(p, p->defindent);
1.22      kristaps  830:                /* If following a prior empty `SH', no vspace. */
1.19      kristaps  831:                if (n->prev && MAN_SH == n->prev->tok)
                    832:                        if (NULL == n->prev->body->child)
                    833:                                break;
1.61      kristaps  834:                /* If the first macro, no vspae. */
                    835:                if (NULL == n->prev)
                    836:                        break;
1.134     schwarze  837:                for (i = 0; i < mt->pardist; i++)
                    838:                        term_vspace(p);
1.19      kristaps  839:                break;
1.146     schwarze  840:        case MAN_HEAD:
1.52      kristaps  841:                term_fontrepl(p, TERMFONT_BOLD);
1.19      kristaps  842:                p->offset = 0;
                    843:                break;
1.146     schwarze  844:        case MAN_BODY:
1.26      kristaps  845:                p->offset = mt->offset;
1.19      kristaps  846:                break;
                    847:        default:
                    848:                break;
                    849:        }
1.1       kristaps  850:
                    851:        return(1);
                    852: }
                    853:
                    854: static void
                    855: post_SH(DECL_ARGS)
                    856: {
1.146     schwarze  857:
1.19      kristaps  858:        switch (n->type) {
1.146     schwarze  859:        case MAN_HEAD:
1.19      kristaps  860:                term_newln(p);
                    861:                break;
1.146     schwarze  862:        case MAN_BODY:
1.19      kristaps  863:                term_newln(p);
                    864:                break;
                    865:        default:
                    866:                break;
                    867:        }
1.1       kristaps  868: }
                    869:
1.26      kristaps  870: static int
                    871: pre_RS(DECL_ARGS)
                    872: {
1.110     kristaps  873:        int              ival;
                    874:        size_t           sz;
1.26      kristaps  875:
                    876:        switch (n->type) {
1.146     schwarze  877:        case MAN_BLOCK:
1.26      kristaps  878:                term_newln(p);
                    879:                return(1);
1.146     schwarze  880:        case MAN_HEAD:
1.26      kristaps  881:                return(0);
                    882:        default:
                    883:                break;
                    884:        }
                    885:
1.122     schwarze  886:        sz = term_len(p, p->defindent);
1.26      kristaps  887:
1.110     kristaps  888:        if (NULL != (n = n->parent->head->child))
1.146     schwarze  889:                if ((ival = a2width(p, n->string)) >= 0)
1.110     kristaps  890:                        sz = (size_t)ival;
1.26      kristaps  891:
1.110     kristaps  892:        mt->offset += sz;
1.140     schwarze  893:        p->offset = mt->offset;
1.156     schwarze  894:        p->rmargin = p->maxrmargin;
1.26      kristaps  895:
1.116     schwarze  896:        if (++mt->lmarginsz < MAXMARGINS)
                    897:                mt->lmargincur = mt->lmarginsz;
                    898:
                    899:        mt->lmargin[mt->lmargincur] = mt->lmargin[mt->lmargincur - 1];
1.26      kristaps  900:        return(1);
                    901: }
                    902:
                    903: static void
                    904: post_RS(DECL_ARGS)
                    905: {
1.110     kristaps  906:        int              ival;
                    907:        size_t           sz;
1.26      kristaps  908:
                    909:        switch (n->type) {
1.146     schwarze  910:        case MAN_BLOCK:
1.110     kristaps  911:                return;
1.146     schwarze  912:        case MAN_HEAD:
1.110     kristaps  913:                return;
1.26      kristaps  914:        default:
                    915:                term_newln(p);
                    916:                break;
                    917:        }
1.110     kristaps  918:
1.122     schwarze  919:        sz = term_len(p, p->defindent);
1.110     kristaps  920:
1.146     schwarze  921:        if (NULL != (n = n->parent->head->child))
                    922:                if ((ival = a2width(p, n->string)) >= 0)
1.110     kristaps  923:                        sz = (size_t)ival;
                    924:
                    925:        mt->offset = mt->offset < sz ?  0 : mt->offset - sz;
                    926:        p->offset = mt->offset;
1.116     schwarze  927:
                    928:        if (--mt->lmarginsz < MAXMARGINS)
                    929:                mt->lmargincur = mt->lmarginsz;
1.137     schwarze  930: }
                    931:
                    932: static int
                    933: pre_UR(DECL_ARGS)
                    934: {
                    935:
                    936:        return (MAN_HEAD != n->type);
                    937: }
                    938:
                    939: static void
                    940: post_UR(DECL_ARGS)
                    941: {
                    942:
                    943:        if (MAN_BLOCK != n->type)
                    944:                return;
                    945:
                    946:        term_word(p, "<");
                    947:        p->flags |= TERMP_NOSPACE;
                    948:
                    949:        if (NULL != n->child->child)
                    950:                print_man_node(p, mt, n->child->child, meta);
                    951:
                    952:        p->flags |= TERMP_NOSPACE;
                    953:        term_word(p, ">");
1.26      kristaps  954: }
                    955:
1.1       kristaps  956: static void
1.45      kristaps  957: print_man_node(DECL_ARGS)
1.1       kristaps  958: {
1.65      joerg     959:        size_t           rm, rmax;
1.54      kristaps  960:        int              c;
1.1       kristaps  961:
                    962:        switch (n->type) {
1.146     schwarze  963:        case MAN_TEXT:
1.97      kristaps  964:                /*
                    965:                 * If we have a blank line, output a vertical space.
                    966:                 * If we have a space as the first character, break
                    967:                 * before printing the line's data.
                    968:                 */
1.96      kristaps  969:                if ('\0' == *n->string) {
1.4       kristaps  970:                        term_vspace(p);
1.98      schwarze  971:                        return;
1.97      kristaps  972:                } else if (' ' == *n->string && MAN_LINE & n->flags)
1.96      kristaps  973:                        term_newln(p);
1.54      kristaps  974:
1.4       kristaps  975:                term_word(p, n->string);
1.130     schwarze  976:                goto out;
1.52      kristaps  977:
1.146     schwarze  978:        case MAN_EQN:
1.152     schwarze  979:                if ( ! (n->flags & MAN_LINE))
                    980:                        p->flags |= TERMP_NOSPACE;
1.115     kristaps  981:                term_eqn(p, n->eqn);
1.154     schwarze  982:                if (n->next != NULL && ! (n->next->flags & MAN_LINE))
1.153     schwarze  983:                        p->flags |= TERMP_NOSPACE;
1.97      kristaps  984:                return;
1.146     schwarze  985:        case MAN_TBL:
1.97      kristaps  986:                /*
                    987:                 * Tables are preceded by a newline.  Then process a
                    988:                 * table line, which will cause line termination,
                    989:                 */
1.146     schwarze  990:                if (TBL_SPAN_FIRST & n->span->flags)
1.93      kristaps  991:                        term_newln(p);
1.92      kristaps  992:                term_tbl(p, n->span);
1.97      kristaps  993:                return;
1.1       kristaps  994:        default:
                    995:                break;
                    996:        }
                    997:
1.97      kristaps  998:        if ( ! (MAN_NOTEXT & termacts[n->tok].flags))
                    999:                term_fontrepl(p, TERMFONT_NONE);
                   1000:
                   1001:        c = 1;
                   1002:        if (termacts[n->tok].pre)
1.135     schwarze 1003:                c = (*termacts[n->tok].pre)(p, mt, n, meta);
1.97      kristaps 1004:
1.1       kristaps 1005:        if (c && n->child)
1.135     schwarze 1006:                print_man_nodelist(p, mt, n->child, meta);
1.1       kristaps 1007:
1.97      kristaps 1008:        if (termacts[n->tok].post)
1.135     schwarze 1009:                (*termacts[n->tok].post)(p, mt, n, meta);
1.97      kristaps 1010:        if ( ! (MAN_NOTEXT & termacts[n->tok].flags))
                   1011:                term_fontrepl(p, TERMFONT_NONE);
1.63      kristaps 1012:
1.130     schwarze 1013: out:
                   1014:        /*
                   1015:         * If we're in a literal context, make sure that words
                   1016:         * together on the same line stay together.  This is a
                   1017:         * POST-printing call, so we check the NEXT word.  Since
                   1018:         * -man doesn't have nested macros, we don't need to be
                   1019:         * more specific than this.
                   1020:         */
1.157   ! schwarze 1021:        if (mt->fl & MANT_LITERAL &&
        !          1022:            ! (p->flags & (TERMP_NOBREAK | TERMP_NONEWLINE)) &&
        !          1023:            (n->next == NULL || n->next->flags & MAN_LINE)) {
1.130     schwarze 1024:                rm = p->rmargin;
                   1025:                rmax = p->maxrmargin;
                   1026:                p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
                   1027:                p->flags |= TERMP_NOSPACE;
1.157   ! schwarze 1028:                if (n->string != NULL && *n->string != '\0')
1.130     schwarze 1029:                        term_flushln(p);
                   1030:                else
                   1031:                        term_newln(p);
                   1032:                if (rm < rmax && n->parent->tok == MAN_HP) {
                   1033:                        p->offset = rm;
                   1034:                        p->rmargin = rmax;
                   1035:                } else
                   1036:                        p->rmargin = rm;
                   1037:                p->maxrmargin = rmax;
                   1038:        }
1.63      kristaps 1039:        if (MAN_EOS & n->flags)
                   1040:                p->flags |= TERMP_SENTENCE;
1.1       kristaps 1041: }
                   1042:
                   1043:
                   1044: static void
1.52      kristaps 1045: print_man_nodelist(DECL_ARGS)
1.1       kristaps 1046: {
1.19      kristaps 1047:
1.135     schwarze 1048:        print_man_node(p, mt, n, meta);
1.1       kristaps 1049:        if ( ! n->next)
                   1050:                return;
1.135     schwarze 1051:        print_man_nodelist(p, mt, n->next, meta);
1.1       kristaps 1052: }
                   1053:
1.31      kristaps 1054: static void
1.73      kristaps 1055: print_man_foot(struct termp *p, const void *arg)
1.1       kristaps 1056: {
1.147     schwarze 1057:        const struct man_meta   *meta;
                   1058:        char                    *title;
1.156     schwarze 1059:        size_t                   datelen, titlen;
1.73      kristaps 1060:
                   1061:        meta = (const struct man_meta *)arg;
1.125     schwarze 1062:        assert(meta->title);
                   1063:        assert(meta->msec);
                   1064:        assert(meta->date);
1.1       kristaps 1065:
1.52      kristaps 1066:        term_fontrepl(p, TERMFONT_NONE);
1.50      kristaps 1067:
1.149     schwarze 1068:        if (meta->hasbody)
                   1069:                term_vspace(p);
1.126     schwarze 1070:
                   1071:        /*
                   1072:         * Temporary, undocumented option to imitate mdoc(7) output.
                   1073:         * In the bottom right corner, use the source instead of
                   1074:         * the title.
                   1075:         */
                   1076:
                   1077:        if ( ! p->mdocstyle) {
1.149     schwarze 1078:                if (meta->hasbody) {
                   1079:                        term_vspace(p);
                   1080:                        term_vspace(p);
                   1081:                }
1.147     schwarze 1082:                mandoc_asprintf(&title, "%s(%s)",
                   1083:                    meta->title, meta->msec);
1.126     schwarze 1084:        } else if (meta->source) {
1.147     schwarze 1085:                title = mandoc_strdup(meta->source);
1.126     schwarze 1086:        } else {
1.147     schwarze 1087:                title = mandoc_strdup("");
1.126     schwarze 1088:        }
1.125     schwarze 1089:        datelen = term_strlen(p, meta->date);
1.1       kristaps 1090:
1.126     schwarze 1091:        /* Bottom left corner: manual source. */
                   1092:
1.1       kristaps 1093:        p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
1.139     schwarze 1094:        p->trailspace = 1;
1.1       kristaps 1095:        p->offset = 0;
1.156     schwarze 1096:        p->rmargin = p->maxrmargin > datelen ?
                   1097:            (p->maxrmargin + term_len(p, 1) - datelen) / 2 : 0;
1.1       kristaps 1098:
                   1099:        if (meta->source)
                   1100:                term_word(p, meta->source);
                   1101:        term_flushln(p);
                   1102:
1.126     schwarze 1103:        /* At the bottom in the middle: manual date. */
                   1104:
1.156     schwarze 1105:        p->offset = p->rmargin;
                   1106:        titlen = term_strlen(p, title);
                   1107:        p->rmargin = p->maxrmargin > titlen ? p->maxrmargin - titlen : 0;
1.117     schwarze 1108:        p->flags |= TERMP_NOSPACE;
1.123     schwarze 1109:
1.125     schwarze 1110:        term_word(p, meta->date);
1.123     schwarze 1111:        term_flushln(p);
                   1112:
1.126     schwarze 1113:        /* Bottom right corner: manual title and section. */
                   1114:
1.123     schwarze 1115:        p->flags &= ~TERMP_NOBREAK;
                   1116:        p->flags |= TERMP_NOSPACE;
1.139     schwarze 1117:        p->trailspace = 0;
1.123     schwarze 1118:        p->offset = p->rmargin;
1.1       kristaps 1119:        p->rmargin = p->maxrmargin;
                   1120:
1.123     schwarze 1121:        term_word(p, title);
1.1       kristaps 1122:        term_flushln(p);
1.147     schwarze 1123:        free(title);
1.1       kristaps 1124: }
                   1125:
1.31      kristaps 1126: static void
1.73      kristaps 1127: print_man_head(struct termp *p, const void *arg)
1.1       kristaps 1128: {
1.147     schwarze 1129:        const struct man_meta   *meta;
1.148     schwarze 1130:        const char              *volume;
1.147     schwarze 1131:        char                    *title;
1.148     schwarze 1132:        size_t                   vollen, titlen;
1.73      kristaps 1133:
1.135     schwarze 1134:        meta = (const struct man_meta *)arg;
                   1135:        assert(meta->title);
                   1136:        assert(meta->msec);
1.1       kristaps 1137:
1.148     schwarze 1138:        volume = NULL == meta->vol ? "" : meta->vol;
                   1139:        vollen = term_strlen(p, volume);
1.1       kristaps 1140:
1.126     schwarze 1141:        /* Top left corner: manual title and section. */
                   1142:
1.147     schwarze 1143:        mandoc_asprintf(&title, "%s(%s)", meta->title, meta->msec);
1.77      kristaps 1144:        titlen = term_strlen(p, title);
1.1       kristaps 1145:
1.118     schwarze 1146:        p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
1.139     schwarze 1147:        p->trailspace = 1;
1.1       kristaps 1148:        p->offset = 0;
1.148     schwarze 1149:        p->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ?
                   1150:            (p->maxrmargin - vollen + term_len(p, 1)) / 2 :
1.156     schwarze 1151:            vollen < p->maxrmargin ? p->maxrmargin - vollen : 0;
1.1       kristaps 1152:
                   1153:        term_word(p, title);
                   1154:        term_flushln(p);
                   1155:
1.126     schwarze 1156:        /* At the top in the middle: manual volume. */
                   1157:
1.117     schwarze 1158:        p->flags |= TERMP_NOSPACE;
1.1       kristaps 1159:        p->offset = p->rmargin;
1.148     schwarze 1160:        p->rmargin = p->offset + vollen + titlen < p->maxrmargin ?
1.57      kristaps 1161:            p->maxrmargin - titlen : p->maxrmargin;
1.1       kristaps 1162:
1.148     schwarze 1163:        term_word(p, volume);
1.1       kristaps 1164:        term_flushln(p);
                   1165:
1.126     schwarze 1166:        /* Top right corner: title and section, again. */
                   1167:
1.1       kristaps 1168:        p->flags &= ~TERMP_NOBREAK;
1.139     schwarze 1169:        p->trailspace = 0;
1.57      kristaps 1170:        if (p->rmargin + titlen <= p->maxrmargin) {
1.117     schwarze 1171:                p->flags |= TERMP_NOSPACE;
1.57      kristaps 1172:                p->offset = p->rmargin;
                   1173:                p->rmargin = p->maxrmargin;
                   1174:                term_word(p, title);
                   1175:                term_flushln(p);
                   1176:        }
1.1       kristaps 1177:
1.118     schwarze 1178:        p->flags &= ~TERMP_NOSPACE;
                   1179:        p->offset = 0;
1.1       kristaps 1180:        p->rmargin = p->maxrmargin;
1.61      kristaps 1181:
1.146     schwarze 1182:        /*
1.126     schwarze 1183:         * Groff prints three blank lines before the content.
                   1184:         * Do the same, except in the temporary, undocumented
                   1185:         * mode imitating mdoc(7) output.
1.62      kristaps 1186:         */
                   1187:
1.61      kristaps 1188:        term_vspace(p);
1.126     schwarze 1189:        if ( ! p->mdocstyle) {
                   1190:                term_vspace(p);
                   1191:                term_vspace(p);
                   1192:        }
1.147     schwarze 1193:        free(title);
1.1       kristaps 1194: }

CVSweb