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

Annotation of mandoc/man_term.c, Revision 1.184

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

CVSweb