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

Annotation of mandoc/mdoc_man.c, Revision 1.29

1.29    ! schwarze    1: /*     $Id: mdoc_man.c,v 1.28 2012/07/09 22:36:34 schwarze Exp $ */
1.1       schwarze    2: /*
1.11      schwarze    3:  * Copyright (c) 2011, 2012 Ingo Schwarze <schwarze@openbsd.org>
1.1       schwarze    4:  *
                      5:  * Permission to use, copy, modify, and distribute this software for any
                      6:  * purpose with or without fee is hereby granted, provided that the above
                      7:  * copyright notice and this permission notice appear in all copies.
                      8:  *
                      9:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     10:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     11:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     12:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     13:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     14:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
                     15:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     16:  */
1.7       kristaps   17: #ifdef HAVE_CONFIG_H
                     18: #include "config.h"
                     19: #endif
                     20:
1.12      schwarze   21: #include <assert.h>
1.1       schwarze   22: #include <stdio.h>
                     23: #include <string.h>
                     24:
                     25: #include "mandoc.h"
1.11      schwarze   26: #include "out.h"
1.4       kristaps   27: #include "man.h"
1.1       schwarze   28: #include "mdoc.h"
                     29: #include "main.h"
                     30:
1.5       kristaps   31: #define        DECL_ARGS const struct mdoc_meta *m, \
1.20      schwarze   32:                  const struct mdoc_node *n
1.1       schwarze   33:
                     34: struct manact {
1.5       kristaps   35:        int             (*cond)(DECL_ARGS); /* DON'T run actions */
                     36:        int             (*pre)(DECL_ARGS); /* pre-node action */
                     37:        void            (*post)(DECL_ARGS); /* post-node action */
                     38:        const char       *prefix; /* pre-node string constant */
                     39:        const char       *suffix; /* post-node string constant */
1.1       schwarze   40: };
                     41:
1.5       kristaps   42: static int       cond_body(DECL_ARGS);
1.1       schwarze   43: static int       cond_head(DECL_ARGS);
1.26      schwarze   44: static  void     font_push(char);
                     45: static void      font_pop(void);
1.5       kristaps   46: static void      post_bd(DECL_ARGS);
1.27      schwarze   47: static void      post_bf(DECL_ARGS);
1.13      schwarze   48: static void      post_bk(DECL_ARGS);
1.5       kristaps   49: static void      post_dl(DECL_ARGS);
1.1       schwarze   50: static void      post_enc(DECL_ARGS);
1.28      schwarze   51: static void      post_eo(DECL_ARGS);
1.17      schwarze   52: static void      post_fa(DECL_ARGS);
1.29    ! schwarze   53: static void      post_fd(DECL_ARGS);
1.26      schwarze   54: static void      post_fl(DECL_ARGS);
1.16      schwarze   55: static void      post_fn(DECL_ARGS);
1.17      schwarze   56: static void      post_fo(DECL_ARGS);
1.26      schwarze   57: static void      post_font(DECL_ARGS);
1.15      schwarze   58: static void      post_in(DECL_ARGS);
1.14      schwarze   59: static void      post_lb(DECL_ARGS);
1.5       kristaps   60: static void      post_nm(DECL_ARGS);
1.1       schwarze   61: static void      post_percent(DECL_ARGS);
1.5       kristaps   62: static void      post_pf(DECL_ARGS);
1.3       schwarze   63: static void      post_sect(DECL_ARGS);
1.5       kristaps   64: static void      post_sp(DECL_ARGS);
1.18      schwarze   65: static void      post_vt(DECL_ARGS);
1.22      schwarze   66: static int       pre_an(DECL_ARGS);
1.3       schwarze   67: static int       pre_ap(DECL_ARGS);
                     68: static int       pre_bd(DECL_ARGS);
1.27      schwarze   69: static int       pre_bf(DECL_ARGS);
1.13      schwarze   70: static int       pre_bk(DECL_ARGS);
1.3       schwarze   71: static int       pre_br(DECL_ARGS);
1.8       schwarze   72: static int       pre_bx(DECL_ARGS);
1.1       schwarze   73: static int       pre_dl(DECL_ARGS);
1.5       kristaps   74: static int       pre_enc(DECL_ARGS);
1.26      schwarze   75: static int       pre_em(DECL_ARGS);
1.17      schwarze   76: static int       pre_fa(DECL_ARGS);
1.29    ! schwarze   77: static int       pre_fd(DECL_ARGS);
1.26      schwarze   78: static int       pre_fl(DECL_ARGS);
1.16      schwarze   79: static int       pre_fn(DECL_ARGS);
1.17      schwarze   80: static int       pre_fo(DECL_ARGS);
1.23      schwarze   81: static int       pre_ft(DECL_ARGS);
1.15      schwarze   82: static int       pre_in(DECL_ARGS);
1.1       schwarze   83: static int       pre_it(DECL_ARGS);
1.24      schwarze   84: static int       pre_lk(DECL_ARGS);
1.26      schwarze   85: static int       pre_li(DECL_ARGS);
1.1       schwarze   86: static int       pre_nm(DECL_ARGS);
1.25      schwarze   87: static int       pre_no(DECL_ARGS);
1.1       schwarze   88: static int       pre_ns(DECL_ARGS);
                     89: static int       pre_pp(DECL_ARGS);
1.12      schwarze   90: static int       pre_sm(DECL_ARGS);
1.3       schwarze   91: static int       pre_sp(DECL_ARGS);
1.5       kristaps   92: static int       pre_sect(DECL_ARGS);
1.26      schwarze   93: static int       pre_sy(DECL_ARGS);
1.23      schwarze   94: static void      pre_syn(const struct mdoc_node *);
1.18      schwarze   95: static int       pre_vt(DECL_ARGS);
1.8       schwarze   96: static int       pre_ux(DECL_ARGS);
1.1       schwarze   97: static int       pre_xr(DECL_ARGS);
1.20      schwarze   98: static void      print_word(const char *);
                     99: static void      print_offs(const char *);
1.5       kristaps  100: static void      print_node(DECL_ARGS);
1.1       schwarze  101:
1.3       schwarze  102: static const struct manact manacts[MDOC_MAX + 1] = {
                    103:        { NULL, pre_ap, NULL, NULL, NULL }, /* Ap */
                    104:        { NULL, NULL, NULL, NULL, NULL }, /* Dd */
                    105:        { NULL, NULL, NULL, NULL, NULL }, /* Dt */
1.8       schwarze  106:        { NULL, NULL, NULL, NULL, NULL }, /* Os */
1.3       schwarze  107:        { NULL, pre_sect, post_sect, ".SH", NULL }, /* Sh */
                    108:        { NULL, pre_sect, post_sect, ".SS", NULL }, /* Ss */
1.1       schwarze  109:        { NULL, pre_pp, NULL, NULL, NULL }, /* Pp */
1.3       schwarze  110:        { cond_body, pre_dl, post_dl, NULL, NULL }, /* D1 */
1.1       schwarze  111:        { cond_body, pre_dl, post_dl, NULL, NULL }, /* Dl */
1.3       schwarze  112:        { cond_body, pre_bd, post_bd, NULL, NULL }, /* Bd */
                    113:        { NULL, NULL, NULL, NULL, NULL }, /* Ed */
                    114:        { NULL, NULL, NULL, NULL, NULL }, /* Bl */
                    115:        { NULL, NULL, NULL, NULL, NULL }, /* El */
1.1       schwarze  116:        { NULL, pre_it, NULL, NULL, NULL }, /* _It */
1.26      schwarze  117:        { NULL, pre_em, post_font, NULL, NULL }, /* Ad */
1.22      schwarze  118:        { NULL, pre_an, NULL, NULL, NULL }, /* An */
1.26      schwarze  119:        { NULL, pre_em, post_font, NULL, NULL }, /* Ar */
                    120:        { NULL, pre_sy, post_font, NULL, NULL }, /* Cd */
                    121:        { NULL, pre_sy, post_font, NULL, NULL }, /* Cm */
                    122:        { NULL, pre_li, post_font, NULL, NULL }, /* Dv */
                    123:        { NULL, pre_li, post_font, NULL, NULL }, /* Er */
                    124:        { NULL, pre_li, post_font, NULL, NULL }, /* Ev */
1.1       schwarze  125:        { NULL, pre_enc, post_enc, "The \\fB",
                    126:            "\\fP\nutility exits 0 on success, and >0 if an error occurs."
                    127:            }, /* Ex */
1.17      schwarze  128:        { NULL, pre_fa, post_fa, NULL, NULL }, /* Fa */
1.29    ! schwarze  129:        { NULL, pre_fd, post_fd, NULL, NULL }, /* Fd */
1.26      schwarze  130:        { NULL, pre_fl, post_fl, NULL, NULL }, /* Fl */
1.16      schwarze  131:        { NULL, pre_fn, post_fn, NULL, NULL }, /* Fn */
1.26      schwarze  132:        { NULL, pre_ft, post_font, NULL, NULL }, /* Ft */
                    133:        { NULL, pre_sy, post_font, NULL, NULL }, /* Ic */
1.15      schwarze  134:        { NULL, pre_in, post_in, NULL, NULL }, /* In */
1.26      schwarze  135:        { NULL, pre_li, post_font, NULL, NULL }, /* Li */
1.1       schwarze  136:        { cond_head, pre_enc, NULL, "\\- ", NULL }, /* Nd */
                    137:        { NULL, pre_nm, post_nm, NULL, NULL }, /* Nm */
                    138:        { cond_body, pre_enc, post_enc, "[", "]" }, /* Op */
1.8       schwarze  139:        { NULL, NULL, NULL, NULL, NULL }, /* Ot */
1.26      schwarze  140:        { NULL, pre_em, post_font, NULL, NULL }, /* Pa */
1.6       kristaps  141:        { NULL, pre_enc, post_enc, "The \\fB",
                    142:                "\\fP\nfunction returns the value 0 if successful;\n"
                    143:                "otherwise the value -1 is returned and the global\n"
                    144:                "variable \\fIerrno\\fP is set to indicate the error."
                    145:                }, /* Rv */
1.8       schwarze  146:        { NULL, NULL, NULL, NULL, NULL }, /* St */
1.26      schwarze  147:        { NULL, pre_em, post_font, NULL, NULL }, /* Va */
1.18      schwarze  148:        { NULL, pre_vt, post_vt, NULL, NULL }, /* Vt */
1.8       schwarze  149:        { NULL, pre_xr, NULL, NULL, NULL }, /* Xr */
1.1       schwarze  150:        { NULL, NULL, post_percent, NULL, NULL }, /* _%A */
                    151:        { NULL, NULL, NULL, NULL, NULL }, /* _%B */
                    152:        { NULL, NULL, post_percent, NULL, NULL }, /* _%D */
                    153:        { NULL, NULL, NULL, NULL, NULL }, /* _%I */
                    154:        { NULL, pre_enc, post_percent, "\\fI", "\\fP" }, /* %J */
                    155:        { NULL, NULL, NULL, NULL, NULL }, /* _%N */
                    156:        { NULL, NULL, NULL, NULL, NULL }, /* _%O */
                    157:        { NULL, NULL, NULL, NULL, NULL }, /* _%P */
                    158:        { NULL, NULL, NULL, NULL, NULL }, /* _%R */
                    159:        { NULL, pre_enc, post_percent, "\"", "\"" }, /* %T */
                    160:        { NULL, NULL, NULL, NULL, NULL }, /* _%V */
1.9       schwarze  161:        { NULL, NULL, NULL, NULL, NULL }, /* Ac */
                    162:        { cond_body, pre_enc, post_enc, "<", ">" }, /* Ao */
1.1       schwarze  163:        { cond_body, pre_enc, post_enc, "<", ">" }, /* Aq */
1.8       schwarze  164:        { NULL, NULL, NULL, NULL, NULL }, /* At */
1.3       schwarze  165:        { NULL, NULL, NULL, NULL, NULL }, /* Bc */
1.27      schwarze  166:        { NULL, pre_bf, post_bf, NULL, NULL }, /* Bf */
1.3       schwarze  167:        { cond_body, pre_enc, post_enc, "[", "]" }, /* Bo */
                    168:        { cond_body, pre_enc, post_enc, "[", "]" }, /* Bq */
1.8       schwarze  169:        { NULL, pre_ux, NULL, "BSD/OS", NULL }, /* Bsx */
                    170:        { NULL, pre_bx, NULL, NULL, NULL }, /* Bx */
                    171:        { NULL, NULL, NULL, NULL, NULL }, /* Db */
1.9       schwarze  172:        { NULL, NULL, NULL, NULL, NULL }, /* Dc */
                    173:        { cond_body, pre_enc, post_enc, "``", "''" }, /* Do */
1.1       schwarze  174:        { cond_body, pre_enc, post_enc, "``", "''" }, /* Dq */
1.28      schwarze  175:        { NULL, NULL, NULL, NULL, NULL }, /* Ec */
                    176:        { NULL, NULL, NULL, NULL, NULL }, /* Ef */
1.26      schwarze  177:        { NULL, pre_em, post_font, NULL, NULL }, /* Em */
1.28      schwarze  178:        { NULL, NULL, post_eo, NULL, NULL }, /* Eo */
1.8       schwarze  179:        { NULL, pre_ux, NULL, "FreeBSD", NULL }, /* Fx */
1.26      schwarze  180:        { NULL, pre_sy, post_font, NULL, NULL }, /* Ms */
1.25      schwarze  181:        { NULL, pre_no, NULL, NULL, NULL }, /* No */
1.1       schwarze  182:        { NULL, pre_ns, NULL, NULL, NULL }, /* Ns */
1.8       schwarze  183:        { NULL, pre_ux, NULL, "NetBSD", NULL }, /* Nx */
                    184:        { NULL, pre_ux, NULL, "OpenBSD", NULL }, /* Ox */
1.3       schwarze  185:        { NULL, NULL, NULL, NULL, NULL }, /* Pc */
                    186:        { NULL, NULL, post_pf, NULL, NULL }, /* Pf */
                    187:        { cond_body, pre_enc, post_enc, "(", ")" }, /* Po */
                    188:        { cond_body, pre_enc, post_enc, "(", ")" }, /* Pq */
1.9       schwarze  189:        { NULL, NULL, NULL, NULL, NULL }, /* Qc */
1.1       schwarze  190:        { cond_body, pre_enc, post_enc, "`", "'" }, /* Ql */
1.9       schwarze  191:        { cond_body, pre_enc, post_enc, "\"", "\"" }, /* Qo */
                    192:        { cond_body, pre_enc, post_enc, "\"", "\"" }, /* Qq */
                    193:        { NULL, NULL, NULL, NULL, NULL }, /* Re */
1.1       schwarze  194:        { cond_body, pre_pp, NULL, NULL, NULL }, /* Rs */
1.9       schwarze  195:        { NULL, NULL, NULL, NULL, NULL }, /* Sc */
                    196:        { cond_body, pre_enc, post_enc, "`", "'" }, /* So */
1.1       schwarze  197:        { cond_body, pre_enc, post_enc, "`", "'" }, /* Sq */
1.12      schwarze  198:        { NULL, pre_sm, NULL, NULL, NULL }, /* Sm */
1.26      schwarze  199:        { NULL, pre_em, post_font, NULL, NULL }, /* Sx */
                    200:        { NULL, pre_sy, post_font, NULL, NULL }, /* Sy */
                    201:        { NULL, pre_li, post_font, NULL, NULL }, /* Tn */
1.8       schwarze  202:        { NULL, pre_ux, NULL, "UNIX", NULL }, /* Ux */
1.1       schwarze  203:        { NULL, NULL, NULL, NULL, NULL }, /* _Xc */
                    204:        { NULL, NULL, NULL, NULL, NULL }, /* _Xo */
1.17      schwarze  205:        { NULL, pre_fo, post_fo, NULL, NULL }, /* Fo */
                    206:        { NULL, NULL, NULL, NULL, NULL }, /* Fc */
1.3       schwarze  207:        { cond_body, pre_enc, post_enc, "[", "]" }, /* Oo */
1.9       schwarze  208:        { NULL, NULL, NULL, NULL, NULL }, /* Oc */
1.13      schwarze  209:        { NULL, pre_bk, post_bk, NULL, NULL }, /* Bk */
                    210:        { NULL, NULL, NULL, NULL, NULL }, /* Ek */
1.8       schwarze  211:        { NULL, pre_ux, NULL, "is currently in beta test.", NULL }, /* Bt */
                    212:        { NULL, NULL, NULL, NULL, NULL }, /* Hf */
                    213:        { NULL, NULL, NULL, NULL, NULL }, /* Fr */
                    214:        { NULL, pre_ux, NULL, "currently under development.", NULL }, /* Ud */
1.14      schwarze  215:        { NULL, NULL, post_lb, NULL, NULL }, /* Lb */
1.3       schwarze  216:        { NULL, pre_pp, NULL, NULL, NULL }, /* Lp */
1.24      schwarze  217:        { NULL, pre_lk, NULL, NULL, NULL }, /* Lk */
1.26      schwarze  218:        { NULL, pre_em, post_font, NULL, NULL }, /* Mt */
1.9       schwarze  219:        { cond_body, pre_enc, post_enc, "{", "}" }, /* Brq */
                    220:        { cond_body, pre_enc, post_enc, "{", "}" }, /* Bro */
                    221:        { NULL, NULL, NULL, NULL, NULL }, /* Brc */
1.1       schwarze  222:        { NULL, NULL, NULL, NULL, NULL }, /* _%C */
1.29    ! schwarze  223:        { NULL, NULL, NULL, NULL, NULL }, /* Es */
        !           224:        { NULL, NULL, NULL, NULL, NULL }, /* En */
1.8       schwarze  225:        { NULL, pre_ux, NULL, "DragonFly", NULL }, /* Dx */
1.1       schwarze  226:        { NULL, NULL, NULL, NULL, NULL }, /* _%Q */
1.3       schwarze  227:        { NULL, pre_br, NULL, NULL, NULL }, /* br */
                    228:        { NULL, pre_sp, post_sp, NULL, NULL }, /* sp */
1.1       schwarze  229:        { NULL, NULL, NULL, NULL, NULL }, /* _%U */
                    230:        { NULL, NULL, NULL, NULL, NULL }, /* _Ta */
1.3       schwarze  231:        { NULL, NULL, NULL, NULL, NULL }, /* ROOT */
1.1       schwarze  232: };
                    233:
1.20      schwarze  234: static int             outflags;
                    235: #define        MMAN_spc        (1 << 0)
1.25      schwarze  236: #define        MMAN_spc_force  (1 << 1)
                    237: #define        MMAN_nl         (1 << 2)
                    238: #define        MMAN_br         (1 << 3)
                    239: #define        MMAN_sp         (1 << 4)
                    240: #define        MMAN_Sm         (1 << 5)
                    241: #define        MMAN_Bk         (1 << 6)
                    242: #define        MMAN_An_split   (1 << 7)
                    243: #define        MMAN_An_nosplit (1 << 8)
1.20      schwarze  244:
1.26      schwarze  245: static struct {
                    246:        char    *head;
                    247:        char    *tail;
                    248:        size_t   size;
                    249: }      fontqueue;
                    250:
                    251: static void
                    252: font_push(char newfont)
                    253: {
                    254:
                    255:        if (fontqueue.head + fontqueue.size <= ++fontqueue.tail) {
                    256:                fontqueue.size += 8;
                    257:                fontqueue.head = mandoc_realloc(fontqueue.head,
                    258:                                fontqueue.size);
                    259:        }
                    260:        *fontqueue.tail = newfont;
                    261:        print_word("\\f");
                    262:        putchar(newfont);
                    263:        outflags &= ~MMAN_spc;
                    264: }
                    265:
                    266: static void
                    267: font_pop(void)
                    268: {
                    269:
                    270:        if (fontqueue.tail > fontqueue.head)
                    271:                fontqueue.tail--;
                    272:        outflags &= ~MMAN_spc;
                    273:        print_word("\\f");
                    274:        putchar(*fontqueue.tail);
                    275: }
                    276:
1.1       schwarze  277: static void
1.20      schwarze  278: print_word(const char *s)
1.1       schwarze  279: {
1.5       kristaps  280:
1.21      schwarze  281:        if ((MMAN_sp | MMAN_br | MMAN_nl) & outflags) {
1.5       kristaps  282:                /*
                    283:                 * If we need a newline, print it now and start afresh.
                    284:                 */
1.21      schwarze  285:                if (MMAN_sp & outflags)
                    286:                        printf("\n.sp\n");
                    287:                else if (MMAN_br & outflags)
                    288:                        printf("\n.br\n");
                    289:                else if (MMAN_nl & outflags)
                    290:                        putchar('\n');
                    291:                outflags &= ~(MMAN_sp|MMAN_br|MMAN_nl|MMAN_spc);
1.20      schwarze  292:        } else if (MMAN_spc & outflags && '\0' != s[0])
1.5       kristaps  293:                /*
1.25      schwarze  294:                 * If we need a space, only print it if
                    295:                 * (1) it is forced by `No' or
                    296:                 * (2) what follows is not terminating punctuation or
                    297:                 * (3) what follows is longer than one character.
1.5       kristaps  298:                 */
1.25      schwarze  299:                if (MMAN_spc_force & outflags ||
                    300:                    NULL == strchr(".,:;)]?!", s[0]) || '\0' != s[1]) {
1.20      schwarze  301:                        if (MMAN_Bk & outflags) {
1.13      schwarze  302:                                putchar('\\');
                    303:                                putchar('~');
                    304:                        } else
                    305:                                putchar(' ');
                    306:                }
1.5       kristaps  307:
                    308:        /*
                    309:         * Reassign needing space if we're not following opening
                    310:         * punctuation.
                    311:         */
1.20      schwarze  312:        if (MMAN_Sm & outflags &&
                    313:            (('(' != s[0] && '[' != s[0]) || '\0' != s[1]))
                    314:                outflags |= MMAN_spc;
                    315:        else
                    316:                outflags &= ~MMAN_spc;
1.25      schwarze  317:        outflags &= ~MMAN_spc_force;
1.5       kristaps  318:
1.1       schwarze  319:        for ( ; *s; s++) {
                    320:                switch (*s) {
                    321:                case (ASCII_NBRSP):
                    322:                        printf("\\~");
                    323:                        break;
                    324:                case (ASCII_HYPH):
                    325:                        putchar('-');
                    326:                        break;
                    327:                default:
1.5       kristaps  328:                        putchar((unsigned char)*s);
1.1       schwarze  329:                        break;
                    330:                }
                    331:        }
1.4       kristaps  332: }
                    333:
1.11      schwarze  334: static void
1.20      schwarze  335: print_offs(const char *v)
1.11      schwarze  336: {
                    337:        char              buf[24];
                    338:        struct roffsu     su;
                    339:        size_t            sz;
                    340:
                    341:        if (NULL == v || '\0' == *v || 0 == strcmp(v, "left"))
                    342:                sz = 0;
                    343:        else if (0 == strcmp(v, "indent"))
                    344:                sz = 6;
                    345:        else if (0 == strcmp(v, "indent-two"))
                    346:                sz = 12;
                    347:        else if (a2roffsu(v, &su, SCALE_MAX)) {
1.20      schwarze  348:                print_word(v);
1.11      schwarze  349:                return;
                    350:        } else
                    351:                sz = strlen(v);
                    352:
                    353:        snprintf(buf, sizeof(buf), "%ldn", sz);
1.20      schwarze  354:        print_word(buf);
1.11      schwarze  355: }
                    356:
1.4       kristaps  357: void
                    358: man_man(void *arg, const struct man *man)
                    359: {
                    360:
1.5       kristaps  361:        /*
                    362:         * Dump the keep buffer.
                    363:         * We're guaranteed by now that this exists (is non-NULL).
                    364:         * Flush stdout afterward, just in case.
                    365:         */
1.4       kristaps  366:        fputs(mparse_getkeep(man_mparse(man)), stdout);
1.5       kristaps  367:        fflush(stdout);
1.1       schwarze  368: }
                    369:
                    370: void
                    371: man_mdoc(void *arg, const struct mdoc *mdoc)
                    372: {
                    373:        const struct mdoc_meta *m;
                    374:        const struct mdoc_node *n;
                    375:
                    376:        m = mdoc_meta(mdoc);
                    377:        n = mdoc_node(mdoc);
                    378:
1.3       schwarze  379:        printf(".TH \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
1.5       kristaps  380:                        m->title, m->msec, m->date, m->os, m->vol);
1.1       schwarze  381:
1.20      schwarze  382:        outflags = MMAN_nl | MMAN_Sm;
1.26      schwarze  383:        if (0 == fontqueue.size) {
                    384:                fontqueue.size = 8;
                    385:                fontqueue.head = fontqueue.tail = mandoc_malloc(8);
                    386:                *fontqueue.tail = 'R';
                    387:        }
1.20      schwarze  388:        print_node(m, n);
1.3       schwarze  389:        putchar('\n');
1.1       schwarze  390: }
                    391:
                    392: static void
                    393: print_node(DECL_ARGS)
                    394: {
                    395:        const struct mdoc_node  *prev, *sub;
1.5       kristaps  396:        const struct manact     *act;
1.1       schwarze  397:        int                      cond, do_sub;
1.5       kristaps  398:
                    399:        /*
                    400:         * Break the line if we were parsed subsequent the current node.
                    401:         * This makes the page structure be more consistent.
                    402:         */
1.1       schwarze  403:        prev = n->prev ? n->prev : n->parent;
1.27      schwarze  404:        if (MMAN_spc & outflags && prev && prev->line < n->line)
1.20      schwarze  405:                outflags |= MMAN_nl;
1.1       schwarze  406:
1.5       kristaps  407:        act = NULL;
1.1       schwarze  408:        cond = 0;
                    409:        do_sub = 1;
1.5       kristaps  410:
1.1       schwarze  411:        if (MDOC_TEXT == n->type) {
1.5       kristaps  412:                /*
                    413:                 * Make sure that we don't happen to start with a
                    414:                 * control character at the start of a line.
                    415:                 */
1.20      schwarze  416:                if (MMAN_nl & outflags && ('.' == *n->string ||
1.5       kristaps  417:                                        '\'' == *n->string)) {
1.20      schwarze  418:                        print_word("\\&");
                    419:                        outflags &= ~MMAN_spc;
1.3       schwarze  420:                }
1.20      schwarze  421:                print_word(n->string);
1.1       schwarze  422:        } else {
1.5       kristaps  423:                /*
                    424:                 * Conditionally run the pre-node action handler for a
                    425:                 * node.
                    426:                 */
1.1       schwarze  427:                act = manacts + n->tok;
1.20      schwarze  428:                cond = NULL == act->cond || (*act->cond)(m, n);
1.1       schwarze  429:                if (cond && act->pre)
1.20      schwarze  430:                        do_sub = (*act->pre)(m, n);
1.1       schwarze  431:        }
                    432:
1.5       kristaps  433:        /*
                    434:         * Conditionally run all child nodes.
                    435:         * Note that this iterates over children instead of using
                    436:         * recursion.  This prevents unnecessary depth in the stack.
                    437:         */
1.1       schwarze  438:        if (do_sub)
                    439:                for (sub = n->child; sub; sub = sub->next)
1.20      schwarze  440:                        print_node(m, sub);
1.1       schwarze  441:
1.5       kristaps  442:        /*
                    443:         * Lastly, conditionally run the post-node handler.
                    444:         */
1.1       schwarze  445:        if (cond && act->post)
1.20      schwarze  446:                (*act->post)(m, n);
1.1       schwarze  447: }
                    448:
                    449: static int
                    450: cond_head(DECL_ARGS)
                    451: {
1.5       kristaps  452:
1.1       schwarze  453:        return(MDOC_HEAD == n->type);
                    454: }
                    455:
                    456: static int
                    457: cond_body(DECL_ARGS)
                    458: {
1.5       kristaps  459:
1.1       schwarze  460:        return(MDOC_BODY == n->type);
                    461: }
                    462:
                    463: static int
                    464: pre_enc(DECL_ARGS)
                    465: {
1.5       kristaps  466:        const char      *prefix;
1.1       schwarze  467:
                    468:        prefix = manacts[n->tok].prefix;
                    469:        if (NULL == prefix)
                    470:                return(1);
1.20      schwarze  471:        print_word(prefix);
                    472:        outflags &= ~MMAN_spc;
1.1       schwarze  473:        return(1);
                    474: }
                    475:
                    476: static void
                    477: post_enc(DECL_ARGS)
                    478: {
                    479:        const char *suffix;
                    480:
                    481:        suffix = manacts[n->tok].suffix;
                    482:        if (NULL == suffix)
                    483:                return;
1.20      schwarze  484:        outflags &= ~MMAN_spc;
                    485:        print_word(suffix);
1.26      schwarze  486: }
                    487:
                    488: static void
                    489: post_font(DECL_ARGS)
                    490: {
                    491:
                    492:        font_pop();
1.1       schwarze  493: }
                    494:
1.5       kristaps  495: /*
                    496:  * Used in listings (percent = %A, e.g.).
                    497:  * FIXME: this is incomplete.
                    498:  * It doesn't print a nice ", and" for lists.
                    499:  */
1.1       schwarze  500: static void
                    501: post_percent(DECL_ARGS)
                    502: {
                    503:
1.20      schwarze  504:        post_enc(m, n);
1.1       schwarze  505:        if (n->next)
1.20      schwarze  506:                print_word(",");
1.1       schwarze  507:        else {
1.20      schwarze  508:                print_word(".");
                    509:                outflags |= MMAN_nl;
1.1       schwarze  510:        }
                    511: }
                    512:
1.5       kristaps  513: /*
                    514:  * Print before a section header.
                    515:  */
1.1       schwarze  516: static int
1.3       schwarze  517: pre_sect(DECL_ARGS)
                    518: {
                    519:
                    520:        if (MDOC_HEAD != n->type)
                    521:                return(1);
1.20      schwarze  522:        outflags |= MMAN_nl;
                    523:        print_word(manacts[n->tok].prefix);
                    524:        print_word("\"");
                    525:        outflags &= ~MMAN_spc;
1.3       schwarze  526:        return(1);
                    527: }
                    528:
1.5       kristaps  529: /*
                    530:  * Print subsequent a section header.
                    531:  */
1.3       schwarze  532: static void
                    533: post_sect(DECL_ARGS)
                    534: {
                    535:
                    536:        if (MDOC_HEAD != n->type)
                    537:                return;
1.20      schwarze  538:        outflags &= ~MMAN_spc;
                    539:        print_word("\"");
                    540:        outflags |= MMAN_nl;
1.22      schwarze  541:        if (MDOC_Sh == n->tok && SEC_AUTHORS == n->sec)
                    542:                outflags &= ~(MMAN_An_split | MMAN_An_nosplit);
                    543: }
                    544:
1.23      schwarze  545: /* See mdoc_term.c, synopsis_pre() for comments. */
                    546: static void
                    547: pre_syn(const struct mdoc_node *n)
                    548: {
                    549:
                    550:        if (NULL == n->prev || ! (MDOC_SYNPRETTY & n->flags))
                    551:                return;
                    552:
                    553:        if (n->prev->tok == n->tok &&
                    554:                        MDOC_Ft != n->tok &&
                    555:                        MDOC_Fo != n->tok &&
                    556:                        MDOC_Fn != n->tok) {
                    557:                outflags |= MMAN_br;
                    558:                return;
                    559:        }
                    560:
                    561:        switch (n->prev->tok) {
                    562:        case (MDOC_Fd):
                    563:                /* FALLTHROUGH */
                    564:        case (MDOC_Fn):
                    565:                /* FALLTHROUGH */
                    566:        case (MDOC_Fo):
                    567:                /* FALLTHROUGH */
                    568:        case (MDOC_In):
                    569:                /* FALLTHROUGH */
                    570:        case (MDOC_Vt):
                    571:                outflags |= MMAN_sp;
                    572:                break;
                    573:        case (MDOC_Ft):
                    574:                if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
                    575:                        outflags |= MMAN_sp;
                    576:                        break;
                    577:                }
                    578:                /* FALLTHROUGH */
                    579:        default:
                    580:                outflags |= MMAN_br;
                    581:                break;
                    582:        }
                    583: }
                    584:
1.22      schwarze  585: static int
                    586: pre_an(DECL_ARGS)
                    587: {
                    588:
                    589:        switch (n->norm->An.auth) {
                    590:        case (AUTH_split):
                    591:                outflags &= ~MMAN_An_nosplit;
                    592:                outflags |= MMAN_An_split;
                    593:                return(0);
                    594:        case (AUTH_nosplit):
                    595:                outflags &= ~MMAN_An_split;
                    596:                outflags |= MMAN_An_nosplit;
                    597:                return(0);
                    598:        default:
                    599:                if (MMAN_An_split & outflags)
                    600:                        outflags |= MMAN_br;
                    601:                else if (SEC_AUTHORS == n->sec &&
                    602:                    ! (MMAN_An_nosplit & outflags))
                    603:                        outflags |= MMAN_An_split;
                    604:                return(1);
                    605:        }
1.3       schwarze  606: }
                    607:
                    608: static int
                    609: pre_ap(DECL_ARGS)
                    610: {
                    611:
1.20      schwarze  612:        outflags &= ~MMAN_spc;
                    613:        print_word("'");
                    614:        outflags &= ~MMAN_spc;
1.3       schwarze  615:        return(0);
                    616: }
                    617:
                    618: static int
                    619: pre_bd(DECL_ARGS)
                    620: {
                    621:
1.21      schwarze  622:        if (0 == n->norm->Bd.comp)
                    623:                outflags |= MMAN_sp;
1.3       schwarze  624:        if (DISP_unfilled == n->norm->Bd.type ||
                    625:            DISP_literal  == n->norm->Bd.type) {
1.20      schwarze  626:                outflags |= MMAN_nl;
                    627:                print_word(".nf");
1.3       schwarze  628:        }
1.20      schwarze  629:        outflags |= MMAN_nl;
                    630:        print_word(".RS");
                    631:        print_offs(n->norm->Bd.offs);
                    632:        outflags |= MMAN_nl;
1.3       schwarze  633:        return(1);
                    634: }
                    635:
                    636: static void
                    637: post_bd(DECL_ARGS)
                    638: {
                    639:
1.20      schwarze  640:        outflags |= MMAN_nl;
                    641:        print_word(".RE");
1.3       schwarze  642:        if (DISP_unfilled == n->norm->Bd.type ||
                    643:            DISP_literal  == n->norm->Bd.type) {
1.20      schwarze  644:                outflags |= MMAN_nl;
                    645:                print_word(".fi");
1.3       schwarze  646:        }
1.20      schwarze  647:        outflags |= MMAN_nl;
1.13      schwarze  648: }
                    649:
                    650: static int
1.27      schwarze  651: pre_bf(DECL_ARGS)
                    652: {
                    653:
                    654:        switch (n->type) {
                    655:        case (MDOC_BLOCK):
                    656:                return(1);
                    657:        case (MDOC_BODY):
                    658:                break;
                    659:        default:
                    660:                return(0);
                    661:        }
                    662:        switch (n->norm->Bf.font) {
                    663:        case (FONT_Em):
                    664:                font_push('I');
                    665:                break;
                    666:        case (FONT_Sy):
                    667:                font_push('B');
                    668:                break;
                    669:        default:
                    670:                font_push('R');
                    671:                break;
                    672:        }
                    673:        return(1);
                    674: }
                    675:
                    676: static void
                    677: post_bf(DECL_ARGS)
                    678: {
                    679:
                    680:        if (MDOC_BODY == n->type)
                    681:                font_pop();
                    682: }
                    683:
                    684: static int
1.13      schwarze  685: pre_bk(DECL_ARGS)
                    686: {
                    687:
                    688:        switch (n->type) {
                    689:        case (MDOC_BLOCK):
                    690:                return(1);
                    691:        case (MDOC_BODY):
1.20      schwarze  692:                outflags |= MMAN_Bk;
1.13      schwarze  693:                return(1);
                    694:        default:
                    695:                return(0);
                    696:        }
                    697: }
                    698:
                    699: static void
                    700: post_bk(DECL_ARGS)
                    701: {
                    702:
                    703:        if (MDOC_BODY == n->type)
1.20      schwarze  704:                outflags &= ~MMAN_Bk;
1.3       schwarze  705: }
                    706:
                    707: static int
                    708: pre_br(DECL_ARGS)
                    709: {
                    710:
1.21      schwarze  711:        outflags |= MMAN_br;
1.3       schwarze  712:        return(0);
                    713: }
                    714:
                    715: static int
1.8       schwarze  716: pre_bx(DECL_ARGS)
                    717: {
                    718:
                    719:        n = n->child;
                    720:        if (n) {
1.20      schwarze  721:                print_word(n->string);
                    722:                outflags &= ~MMAN_spc;
1.8       schwarze  723:                n = n->next;
                    724:        }
1.20      schwarze  725:        print_word("BSD");
1.8       schwarze  726:        if (NULL == n)
                    727:                return(0);
1.20      schwarze  728:        outflags &= ~MMAN_spc;
                    729:        print_word("-");
                    730:        outflags &= ~MMAN_spc;
                    731:        print_word(n->string);
1.8       schwarze  732:        return(0);
                    733: }
                    734:
                    735: static int
1.1       schwarze  736: pre_dl(DECL_ARGS)
                    737: {
                    738:
1.20      schwarze  739:        outflags |= MMAN_nl;
                    740:        print_word(".RS 6n");
                    741:        outflags |= MMAN_nl;
1.1       schwarze  742:        return(1);
                    743: }
                    744:
                    745: static void
                    746: post_dl(DECL_ARGS)
                    747: {
                    748:
1.20      schwarze  749:        outflags |= MMAN_nl;
                    750:        print_word(".RE");
                    751:        outflags |= MMAN_nl;
1.16      schwarze  752: }
                    753:
                    754: static int
1.26      schwarze  755: pre_em(DECL_ARGS)
                    756: {
                    757:
                    758:        font_push('I');
                    759:        return(1);
1.28      schwarze  760: }
                    761:
                    762: static void
                    763: post_eo(DECL_ARGS)
                    764: {
                    765:
                    766:        if (MDOC_HEAD == n->type || MDOC_BODY == n->type)
                    767:                outflags &= ~MMAN_spc;
1.26      schwarze  768: }
                    769:
                    770: static int
1.17      schwarze  771: pre_fa(DECL_ARGS)
                    772: {
                    773:
                    774:        if (MDOC_Fa == n->tok)
                    775:                n = n->child;
                    776:
                    777:        while (NULL != n) {
1.26      schwarze  778:                font_push('I');
1.20      schwarze  779:                print_node(m, n);
1.26      schwarze  780:                font_pop();
1.17      schwarze  781:                if (NULL != (n = n->next))
1.20      schwarze  782:                        print_word(",");
1.17      schwarze  783:        }
                    784:        return(0);
                    785: }
                    786:
                    787: static void
                    788: post_fa(DECL_ARGS)
                    789: {
                    790:
                    791:        if (NULL != n->next && MDOC_Fa == n->next->tok)
1.20      schwarze  792:                print_word(",");
1.29    ! schwarze  793: }
        !           794:
        !           795: static int
        !           796: pre_fd(DECL_ARGS)
        !           797: {
        !           798:
        !           799:        pre_syn(n);
        !           800:        font_push('B');
        !           801:        return(1);
        !           802: }
        !           803:
        !           804: static void
        !           805: post_fd(DECL_ARGS)
        !           806: {
        !           807:
        !           808:        font_pop();
        !           809:        outflags |= MMAN_br;
1.17      schwarze  810: }
                    811:
                    812: static int
1.26      schwarze  813: pre_fl(DECL_ARGS)
                    814: {
                    815:
                    816:        font_push('B');
                    817:        print_word("-");
                    818:        outflags &= ~MMAN_spc;
                    819:        return(1);
                    820: }
                    821:
                    822: static void
                    823: post_fl(DECL_ARGS)
                    824: {
                    825:
                    826:        font_pop();
1.27      schwarze  827:        if (0 == n->nchild && NULL != n->next &&
                    828:                        n->next->line == n->line)
1.26      schwarze  829:                outflags &= ~MMAN_spc;
                    830: }
                    831:
                    832: static int
1.16      schwarze  833: pre_fn(DECL_ARGS)
                    834: {
                    835:
1.23      schwarze  836:        pre_syn(n);
                    837:
1.16      schwarze  838:        n = n->child;
                    839:        if (NULL == n)
                    840:                return(0);
                    841:
1.26      schwarze  842:        font_push('B');
1.20      schwarze  843:        print_node(m, n);
1.26      schwarze  844:        font_pop();
1.20      schwarze  845:        outflags &= ~MMAN_spc;
1.26      schwarze  846:        print_word("(");
1.20      schwarze  847:        outflags &= ~MMAN_spc;
                    848:        return(pre_fa(m, n->next));
1.16      schwarze  849: }
                    850:
                    851: static void
                    852: post_fn(DECL_ARGS)
                    853: {
                    854:
1.20      schwarze  855:        print_word(")");
1.16      schwarze  856:        if (MDOC_SYNPRETTY & n->flags) {
1.20      schwarze  857:                print_word(";");
1.21      schwarze  858:                outflags |= MMAN_br;
1.17      schwarze  859:        }
                    860: }
                    861:
                    862: static int
                    863: pre_fo(DECL_ARGS)
                    864: {
                    865:
                    866:        switch (n->type) {
1.23      schwarze  867:        case (MDOC_BLOCK):
                    868:                pre_syn(n);
                    869:                break;
1.17      schwarze  870:        case (MDOC_HEAD):
1.26      schwarze  871:                font_push('B');
1.17      schwarze  872:                break;
                    873:        case (MDOC_BODY):
1.20      schwarze  874:                outflags &= ~MMAN_spc;
                    875:                print_word("(");
                    876:                outflags &= ~MMAN_spc;
1.17      schwarze  877:                break;
                    878:        default:
                    879:                break;
                    880:        }
                    881:        return(1);
                    882: }
                    883:
                    884: static void
                    885: post_fo(DECL_ARGS)
                    886: {
                    887:
                    888:        switch (n->type) {
                    889:        case (MDOC_HEAD):
1.26      schwarze  890:                font_pop();
1.17      schwarze  891:                break;
                    892:        case (MDOC_BODY):
1.20      schwarze  893:                post_fn(m, n);
1.17      schwarze  894:                break;
                    895:        default:
                    896:                break;
1.16      schwarze  897:        }
1.15      schwarze  898: }
                    899:
                    900: static int
1.23      schwarze  901: pre_ft(DECL_ARGS)
                    902: {
                    903:
                    904:        pre_syn(n);
1.26      schwarze  905:        font_push('I');
1.23      schwarze  906:        return(1);
                    907: }
                    908:
                    909: static int
1.15      schwarze  910: pre_in(DECL_ARGS)
                    911: {
                    912:
                    913:        if (MDOC_SYNPRETTY & n->flags) {
1.23      schwarze  914:                pre_syn(n);
1.26      schwarze  915:                font_push('B');
                    916:                print_word("#include <");
                    917:                outflags &= ~MMAN_spc;
                    918:        } else {
                    919:                print_word("<");
                    920:                outflags &= ~MMAN_spc;
                    921:                font_push('I');
                    922:        }
1.15      schwarze  923:        return(1);
                    924: }
                    925:
                    926: static void
                    927: post_in(DECL_ARGS)
                    928: {
                    929:
                    930:        if (MDOC_SYNPRETTY & n->flags) {
1.26      schwarze  931:                outflags &= ~MMAN_spc;
                    932:                print_word(">");
                    933:                font_pop();
1.21      schwarze  934:                outflags |= MMAN_br;
1.26      schwarze  935:        } else {
                    936:                font_pop();
                    937:                outflags &= ~MMAN_spc;
                    938:                print_word(">");
                    939:        }
1.1       schwarze  940: }
                    941:
                    942: static int
                    943: pre_it(DECL_ARGS)
                    944: {
                    945:        const struct mdoc_node *bln;
                    946:
                    947:        if (MDOC_HEAD == n->type) {
1.20      schwarze  948:                outflags |= MMAN_nl;
                    949:                print_word(".TP");
1.1       schwarze  950:                bln = n->parent->parent->prev;
1.3       schwarze  951:                switch (bln->norm->Bl.type) {
                    952:                case (LIST_bullet):
1.20      schwarze  953:                        print_word("4n");
                    954:                        outflags |= MMAN_nl;
                    955:                        print_word("\\fBo\\fP");
1.3       schwarze  956:                        break;
                    957:                default:
                    958:                        if (bln->norm->Bl.width)
1.20      schwarze  959:                                print_word(bln->norm->Bl.width);
1.3       schwarze  960:                        break;
                    961:                }
1.20      schwarze  962:                outflags |= MMAN_nl;
1.1       schwarze  963:        }
                    964:        return(1);
1.14      schwarze  965: }
                    966:
                    967: static void
                    968: post_lb(DECL_ARGS)
                    969: {
                    970:
1.21      schwarze  971:        if (SEC_LIBRARY == n->sec)
                    972:                outflags |= MMAN_br;
1.24      schwarze  973: }
                    974:
                    975: static int
                    976: pre_lk(DECL_ARGS)
                    977: {
                    978:        const struct mdoc_node *link, *descr;
                    979:
                    980:        if (NULL == (link = n->child))
                    981:                return(0);
                    982:
                    983:        if (NULL != (descr = link->next)) {
1.26      schwarze  984:                font_push('I');
1.24      schwarze  985:                while (NULL != descr) {
                    986:                        print_word(descr->string);
                    987:                        descr = descr->next;
                    988:                }
                    989:                print_word(":");
1.26      schwarze  990:                font_pop();
1.24      schwarze  991:        }
                    992:
1.26      schwarze  993:        font_push('B');
1.24      schwarze  994:        print_word(link->string);
1.26      schwarze  995:        font_pop();
1.24      schwarze  996:        return(0);
1.1       schwarze  997: }
                    998:
                    999: static int
1.26      schwarze 1000: pre_li(DECL_ARGS)
                   1001: {
                   1002:
                   1003:        font_push('R');
                   1004:        return(1);
                   1005: }
                   1006:
                   1007: static int
1.1       schwarze 1008: pre_nm(DECL_ARGS)
                   1009: {
                   1010:
1.23      schwarze 1011:        if (MDOC_BLOCK == n->type)
                   1012:                pre_syn(n);
1.1       schwarze 1013:        if (MDOC_ELEM != n->type && MDOC_HEAD != n->type)
                   1014:                return(1);
1.23      schwarze 1015:        if (NULL == n->child && NULL == m->name)
                   1016:                return(0);
1.26      schwarze 1017:        font_push('B');
1.1       schwarze 1018:        if (NULL == n->child)
1.20      schwarze 1019:                print_word(m->name);
1.1       schwarze 1020:        return(1);
                   1021: }
                   1022:
                   1023: static void
                   1024: post_nm(DECL_ARGS)
                   1025: {
                   1026:
                   1027:        if (MDOC_ELEM != n->type && MDOC_HEAD != n->type)
                   1028:                return;
1.26      schwarze 1029:        font_pop();
1.25      schwarze 1030: }
                   1031:
                   1032: static int
                   1033: pre_no(DECL_ARGS)
                   1034: {
                   1035:
                   1036:        outflags |= MMAN_spc_force;
                   1037:        return(1);
1.1       schwarze 1038: }
                   1039:
                   1040: static int
                   1041: pre_ns(DECL_ARGS)
                   1042: {
                   1043:
1.20      schwarze 1044:        outflags &= ~MMAN_spc;
1.1       schwarze 1045:        return(0);
                   1046: }
                   1047:
1.3       schwarze 1048: static void
                   1049: post_pf(DECL_ARGS)
                   1050: {
                   1051:
1.20      schwarze 1052:        outflags &= ~MMAN_spc;
1.3       schwarze 1053: }
                   1054:
1.1       schwarze 1055: static int
                   1056: pre_pp(DECL_ARGS)
                   1057: {
                   1058:
1.20      schwarze 1059:        outflags |= MMAN_nl;
1.1       schwarze 1060:        if (MDOC_It == n->parent->tok)
1.20      schwarze 1061:                print_word(".sp");
1.1       schwarze 1062:        else
1.20      schwarze 1063:                print_word(".PP");
                   1064:        outflags |= MMAN_nl;
1.10      schwarze 1065:        return(MDOC_Rs == n->tok);
1.12      schwarze 1066: }
                   1067:
                   1068: static int
                   1069: pre_sm(DECL_ARGS)
                   1070: {
                   1071:
                   1072:        assert(n->child && MDOC_TEXT == n->child->type);
                   1073:        if (0 == strcmp("on", n->child->string))
1.27      schwarze 1074:                outflags |= MMAN_Sm | MMAN_spc;
1.12      schwarze 1075:        else
1.20      schwarze 1076:                outflags &= ~MMAN_Sm;
1.12      schwarze 1077:        return(0);
1.1       schwarze 1078: }
                   1079:
                   1080: static int
1.3       schwarze 1081: pre_sp(DECL_ARGS)
1.1       schwarze 1082: {
                   1083:
1.20      schwarze 1084:        outflags |= MMAN_nl;
                   1085:        print_word(".sp");
1.1       schwarze 1086:        return(1);
                   1087: }
                   1088:
                   1089: static void
1.3       schwarze 1090: post_sp(DECL_ARGS)
1.1       schwarze 1091: {
                   1092:
1.20      schwarze 1093:        outflags |= MMAN_nl;
1.18      schwarze 1094: }
                   1095:
                   1096: static int
1.26      schwarze 1097: pre_sy(DECL_ARGS)
                   1098: {
                   1099:
                   1100:        font_push('B');
                   1101:        return(1);
                   1102: }
                   1103:
                   1104: static int
1.18      schwarze 1105: pre_vt(DECL_ARGS)
                   1106: {
                   1107:
                   1108:        if (MDOC_SYNPRETTY & n->flags) {
                   1109:                switch (n->type) {
                   1110:                case (MDOC_BLOCK):
1.23      schwarze 1111:                        pre_syn(n);
1.18      schwarze 1112:                        return(1);
                   1113:                case (MDOC_BODY):
                   1114:                        break;
                   1115:                default:
                   1116:                        return(0);
                   1117:                }
                   1118:        }
1.26      schwarze 1119:        font_push('I');
1.18      schwarze 1120:        return(1);
                   1121: }
                   1122:
                   1123: static void
                   1124: post_vt(DECL_ARGS)
                   1125: {
                   1126:
1.19      schwarze 1127:        if (MDOC_SYNPRETTY & n->flags && MDOC_BODY != n->type)
1.18      schwarze 1128:                return;
1.26      schwarze 1129:        font_pop();
1.1       schwarze 1130: }
                   1131:
                   1132: static int
                   1133: pre_xr(DECL_ARGS)
                   1134: {
                   1135:
                   1136:        n = n->child;
                   1137:        if (NULL == n)
                   1138:                return(0);
1.20      schwarze 1139:        print_node(m, n);
1.1       schwarze 1140:        n = n->next;
                   1141:        if (NULL == n)
                   1142:                return(0);
1.20      schwarze 1143:        outflags &= ~MMAN_spc;
                   1144:        print_word("(");
                   1145:        print_node(m, n);
                   1146:        print_word(")");
1.1       schwarze 1147:        return(0);
1.8       schwarze 1148: }
                   1149:
                   1150: static int
                   1151: pre_ux(DECL_ARGS)
                   1152: {
                   1153:
1.20      schwarze 1154:        print_word(manacts[n->tok].prefix);
1.8       schwarze 1155:        if (NULL == n->child)
                   1156:                return(0);
1.20      schwarze 1157:        outflags &= ~MMAN_spc;
                   1158:        print_word("\\~");
                   1159:        outflags &= ~MMAN_spc;
1.8       schwarze 1160:        return(1);
1.1       schwarze 1161: }

CVSweb