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

Annotation of mandoc/man_term.c, Revision 1.143

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

CVSweb