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

Annotation of mandoc/man_term.c, Revision 1.133

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

CVSweb