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

Annotation of mandoc/man_term.c, Revision 1.134

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

CVSweb