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

Annotation of mandoc/man_term.c, Revision 1.137

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

CVSweb