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

Annotation of mandoc/man_term.c, Revision 1.194

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

CVSweb