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

Annotation of mandoc/mdoc_man.c, Revision 1.51

1.51    ! schwarze    1: /*     $Id: mdoc_man.c,v 1.50 2013/05/29 15:40:22 schwarze Exp $ */
1.1       schwarze    2: /*
1.49      schwarze    3:  * Copyright (c) 2011, 2012, 2013 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.42      schwarze   31: #define        DECL_ARGS const struct mdoc_meta *meta, \
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.47      schwarze   46: static void      mid_it(void);
1.34      schwarze   47: static void      post__t(DECL_ARGS);
1.5       kristaps   48: static void      post_bd(DECL_ARGS);
1.27      schwarze   49: static void      post_bf(DECL_ARGS);
1.13      schwarze   50: static void      post_bk(DECL_ARGS);
1.30      schwarze   51: static void      post_bl(DECL_ARGS);
1.5       kristaps   52: static void      post_dl(DECL_ARGS);
1.1       schwarze   53: static void      post_enc(DECL_ARGS);
1.28      schwarze   54: static void      post_eo(DECL_ARGS);
1.17      schwarze   55: static void      post_fa(DECL_ARGS);
1.29      schwarze   56: static void      post_fd(DECL_ARGS);
1.26      schwarze   57: static void      post_fl(DECL_ARGS);
1.16      schwarze   58: static void      post_fn(DECL_ARGS);
1.17      schwarze   59: static void      post_fo(DECL_ARGS);
1.26      schwarze   60: static void      post_font(DECL_ARGS);
1.15      schwarze   61: static void      post_in(DECL_ARGS);
1.30      schwarze   62: static void      post_it(DECL_ARGS);
1.14      schwarze   63: static void      post_lb(DECL_ARGS);
1.5       kristaps   64: static void      post_nm(DECL_ARGS);
1.1       schwarze   65: static void      post_percent(DECL_ARGS);
1.5       kristaps   66: static void      post_pf(DECL_ARGS);
1.3       schwarze   67: static void      post_sect(DECL_ARGS);
1.5       kristaps   68: static void      post_sp(DECL_ARGS);
1.18      schwarze   69: static void      post_vt(DECL_ARGS);
1.34      schwarze   70: static int       pre__t(DECL_ARGS);
1.22      schwarze   71: static int       pre_an(DECL_ARGS);
1.3       schwarze   72: static int       pre_ap(DECL_ARGS);
                     73: static int       pre_bd(DECL_ARGS);
1.27      schwarze   74: static int       pre_bf(DECL_ARGS);
1.13      schwarze   75: static int       pre_bk(DECL_ARGS);
1.30      schwarze   76: static int       pre_bl(DECL_ARGS);
1.3       schwarze   77: static int       pre_br(DECL_ARGS);
1.8       schwarze   78: static int       pre_bx(DECL_ARGS);
1.1       schwarze   79: static int       pre_dl(DECL_ARGS);
1.5       kristaps   80: static int       pre_enc(DECL_ARGS);
1.26      schwarze   81: static int       pre_em(DECL_ARGS);
1.17      schwarze   82: static int       pre_fa(DECL_ARGS);
1.29      schwarze   83: static int       pre_fd(DECL_ARGS);
1.26      schwarze   84: static int       pre_fl(DECL_ARGS);
1.16      schwarze   85: static int       pre_fn(DECL_ARGS);
1.17      schwarze   86: static int       pre_fo(DECL_ARGS);
1.23      schwarze   87: static int       pre_ft(DECL_ARGS);
1.15      schwarze   88: static int       pre_in(DECL_ARGS);
1.1       schwarze   89: static int       pre_it(DECL_ARGS);
1.24      schwarze   90: static int       pre_lk(DECL_ARGS);
1.26      schwarze   91: static int       pre_li(DECL_ARGS);
1.1       schwarze   92: static int       pre_nm(DECL_ARGS);
1.25      schwarze   93: static int       pre_no(DECL_ARGS);
1.1       schwarze   94: static int       pre_ns(DECL_ARGS);
                     95: static int       pre_pp(DECL_ARGS);
1.34      schwarze   96: static int       pre_rs(DECL_ARGS);
1.12      schwarze   97: static int       pre_sm(DECL_ARGS);
1.3       schwarze   98: static int       pre_sp(DECL_ARGS);
1.5       kristaps   99: static int       pre_sect(DECL_ARGS);
1.26      schwarze  100: static int       pre_sy(DECL_ARGS);
1.23      schwarze  101: static void      pre_syn(const struct mdoc_node *);
1.18      schwarze  102: static int       pre_vt(DECL_ARGS);
1.8       schwarze  103: static int       pre_ux(DECL_ARGS);
1.1       schwarze  104: static int       pre_xr(DECL_ARGS);
1.20      schwarze  105: static void      print_word(const char *);
1.36      schwarze  106: static void      print_line(const char *, int);
                    107: static void      print_block(const char *, int);
1.20      schwarze  108: static void      print_offs(const char *);
1.35      schwarze  109: static void      print_width(const char *,
                    110:                                const struct mdoc_node *, size_t);
1.30      schwarze  111: static void      print_count(int *);
1.5       kristaps  112: static void      print_node(DECL_ARGS);
1.1       schwarze  113:
1.3       schwarze  114: static const struct manact manacts[MDOC_MAX + 1] = {
                    115:        { NULL, pre_ap, NULL, NULL, NULL }, /* Ap */
                    116:        { NULL, NULL, NULL, NULL, NULL }, /* Dd */
                    117:        { NULL, NULL, NULL, NULL, NULL }, /* Dt */
1.8       schwarze  118:        { NULL, NULL, NULL, NULL, NULL }, /* Os */
1.3       schwarze  119:        { NULL, pre_sect, post_sect, ".SH", NULL }, /* Sh */
                    120:        { NULL, pre_sect, post_sect, ".SS", NULL }, /* Ss */
1.1       schwarze  121:        { NULL, pre_pp, NULL, NULL, NULL }, /* Pp */
1.3       schwarze  122:        { cond_body, pre_dl, post_dl, NULL, NULL }, /* D1 */
1.1       schwarze  123:        { cond_body, pre_dl, post_dl, NULL, NULL }, /* Dl */
1.3       schwarze  124:        { cond_body, pre_bd, post_bd, NULL, NULL }, /* Bd */
                    125:        { NULL, NULL, NULL, NULL, NULL }, /* Ed */
1.30      schwarze  126:        { cond_body, pre_bl, post_bl, NULL, NULL }, /* Bl */
1.3       schwarze  127:        { NULL, NULL, NULL, NULL, NULL }, /* El */
1.30      schwarze  128:        { NULL, pre_it, post_it, NULL, NULL }, /* It */
1.26      schwarze  129:        { NULL, pre_em, post_font, NULL, NULL }, /* Ad */
1.22      schwarze  130:        { NULL, pre_an, NULL, NULL, NULL }, /* An */
1.26      schwarze  131:        { NULL, pre_em, post_font, NULL, NULL }, /* Ar */
                    132:        { NULL, pre_sy, post_font, NULL, NULL }, /* Cd */
                    133:        { NULL, pre_sy, post_font, NULL, NULL }, /* Cm */
                    134:        { NULL, pre_li, post_font, NULL, NULL }, /* Dv */
                    135:        { NULL, pre_li, post_font, NULL, NULL }, /* Er */
                    136:        { NULL, pre_li, post_font, NULL, NULL }, /* Ev */
1.1       schwarze  137:        { NULL, pre_enc, post_enc, "The \\fB",
                    138:            "\\fP\nutility exits 0 on success, and >0 if an error occurs."
                    139:            }, /* Ex */
1.17      schwarze  140:        { NULL, pre_fa, post_fa, NULL, NULL }, /* Fa */
1.29      schwarze  141:        { NULL, pre_fd, post_fd, NULL, NULL }, /* Fd */
1.26      schwarze  142:        { NULL, pre_fl, post_fl, NULL, NULL }, /* Fl */
1.16      schwarze  143:        { NULL, pre_fn, post_fn, NULL, NULL }, /* Fn */
1.26      schwarze  144:        { NULL, pre_ft, post_font, NULL, NULL }, /* Ft */
                    145:        { NULL, pre_sy, post_font, NULL, NULL }, /* Ic */
1.15      schwarze  146:        { NULL, pre_in, post_in, NULL, NULL }, /* In */
1.26      schwarze  147:        { NULL, pre_li, post_font, NULL, NULL }, /* Li */
1.1       schwarze  148:        { cond_head, pre_enc, NULL, "\\- ", NULL }, /* Nd */
                    149:        { NULL, pre_nm, post_nm, NULL, NULL }, /* Nm */
                    150:        { cond_body, pre_enc, post_enc, "[", "]" }, /* Op */
1.8       schwarze  151:        { NULL, NULL, NULL, NULL, NULL }, /* Ot */
1.26      schwarze  152:        { NULL, pre_em, post_font, NULL, NULL }, /* Pa */
1.6       kristaps  153:        { NULL, pre_enc, post_enc, "The \\fB",
                    154:                "\\fP\nfunction returns the value 0 if successful;\n"
                    155:                "otherwise the value -1 is returned and the global\n"
                    156:                "variable \\fIerrno\\fP is set to indicate the error."
                    157:                }, /* Rv */
1.8       schwarze  158:        { NULL, NULL, NULL, NULL, NULL }, /* St */
1.26      schwarze  159:        { NULL, pre_em, post_font, NULL, NULL }, /* Va */
1.18      schwarze  160:        { NULL, pre_vt, post_vt, NULL, NULL }, /* Vt */
1.8       schwarze  161:        { NULL, pre_xr, NULL, NULL, NULL }, /* Xr */
1.34      schwarze  162:        { NULL, NULL, post_percent, NULL, NULL }, /* %A */
                    163:        { NULL, pre_em, post_percent, NULL, NULL }, /* %B */
                    164:        { NULL, NULL, post_percent, NULL, NULL }, /* %D */
                    165:        { NULL, pre_em, post_percent, NULL, NULL }, /* %I */
                    166:        { NULL, pre_em, post_percent, NULL, NULL }, /* %J */
                    167:        { NULL, NULL, post_percent, NULL, NULL }, /* %N */
                    168:        { NULL, NULL, post_percent, NULL, NULL }, /* %O */
                    169:        { NULL, NULL, post_percent, NULL, NULL }, /* %P */
                    170:        { NULL, NULL, post_percent, NULL, NULL }, /* %R */
                    171:        { NULL, pre__t, post__t, NULL, NULL }, /* %T */
                    172:        { NULL, NULL, post_percent, NULL, NULL }, /* %V */
1.9       schwarze  173:        { NULL, NULL, NULL, NULL, NULL }, /* Ac */
                    174:        { cond_body, pre_enc, post_enc, "<", ">" }, /* Ao */
1.1       schwarze  175:        { cond_body, pre_enc, post_enc, "<", ">" }, /* Aq */
1.8       schwarze  176:        { NULL, NULL, NULL, NULL, NULL }, /* At */
1.3       schwarze  177:        { NULL, NULL, NULL, NULL, NULL }, /* Bc */
1.27      schwarze  178:        { NULL, pre_bf, post_bf, NULL, NULL }, /* Bf */
1.3       schwarze  179:        { cond_body, pre_enc, post_enc, "[", "]" }, /* Bo */
                    180:        { cond_body, pre_enc, post_enc, "[", "]" }, /* Bq */
1.8       schwarze  181:        { NULL, pre_ux, NULL, "BSD/OS", NULL }, /* Bsx */
                    182:        { NULL, pre_bx, NULL, NULL, NULL }, /* Bx */
                    183:        { NULL, NULL, NULL, NULL, NULL }, /* Db */
1.9       schwarze  184:        { NULL, NULL, NULL, NULL, NULL }, /* Dc */
1.51    ! schwarze  185:        { cond_body, pre_enc, post_enc, "\\(lq", "\\(rq" }, /* Do */
        !           186:        { cond_body, pre_enc, post_enc, "\\(lq", "\\(rq" }, /* Dq */
1.28      schwarze  187:        { NULL, NULL, NULL, NULL, NULL }, /* Ec */
                    188:        { NULL, NULL, NULL, NULL, NULL }, /* Ef */
1.26      schwarze  189:        { NULL, pre_em, post_font, NULL, NULL }, /* Em */
1.28      schwarze  190:        { NULL, NULL, post_eo, NULL, NULL }, /* Eo */
1.8       schwarze  191:        { NULL, pre_ux, NULL, "FreeBSD", NULL }, /* Fx */
1.26      schwarze  192:        { NULL, pre_sy, post_font, NULL, NULL }, /* Ms */
1.25      schwarze  193:        { NULL, pre_no, NULL, NULL, NULL }, /* No */
1.1       schwarze  194:        { NULL, pre_ns, NULL, NULL, NULL }, /* Ns */
1.8       schwarze  195:        { NULL, pre_ux, NULL, "NetBSD", NULL }, /* Nx */
                    196:        { NULL, pre_ux, NULL, "OpenBSD", NULL }, /* Ox */
1.3       schwarze  197:        { NULL, NULL, NULL, NULL, NULL }, /* Pc */
                    198:        { NULL, NULL, post_pf, NULL, NULL }, /* Pf */
                    199:        { cond_body, pre_enc, post_enc, "(", ")" }, /* Po */
                    200:        { cond_body, pre_enc, post_enc, "(", ")" }, /* Pq */
1.9       schwarze  201:        { NULL, NULL, NULL, NULL, NULL }, /* Qc */
1.51    ! schwarze  202:        { cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* Ql */
1.9       schwarze  203:        { cond_body, pre_enc, post_enc, "\"", "\"" }, /* Qo */
                    204:        { cond_body, pre_enc, post_enc, "\"", "\"" }, /* Qq */
                    205:        { NULL, NULL, NULL, NULL, NULL }, /* Re */
1.34      schwarze  206:        { cond_body, pre_rs, NULL, NULL, NULL }, /* Rs */
1.9       schwarze  207:        { NULL, NULL, NULL, NULL, NULL }, /* Sc */
1.51    ! schwarze  208:        { cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* So */
        !           209:        { cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* Sq */
1.12      schwarze  210:        { NULL, pre_sm, NULL, NULL, NULL }, /* Sm */
1.26      schwarze  211:        { NULL, pre_em, post_font, NULL, NULL }, /* Sx */
                    212:        { NULL, pre_sy, post_font, NULL, NULL }, /* Sy */
                    213:        { NULL, pre_li, post_font, NULL, NULL }, /* Tn */
1.8       schwarze  214:        { NULL, pre_ux, NULL, "UNIX", NULL }, /* Ux */
1.34      schwarze  215:        { NULL, NULL, NULL, NULL, NULL }, /* Xc */
                    216:        { NULL, NULL, NULL, NULL, NULL }, /* Xo */
1.17      schwarze  217:        { NULL, pre_fo, post_fo, NULL, NULL }, /* Fo */
                    218:        { NULL, NULL, NULL, NULL, NULL }, /* Fc */
1.3       schwarze  219:        { cond_body, pre_enc, post_enc, "[", "]" }, /* Oo */
1.9       schwarze  220:        { NULL, NULL, NULL, NULL, NULL }, /* Oc */
1.13      schwarze  221:        { NULL, pre_bk, post_bk, NULL, NULL }, /* Bk */
                    222:        { NULL, NULL, NULL, NULL, NULL }, /* Ek */
1.8       schwarze  223:        { NULL, pre_ux, NULL, "is currently in beta test.", NULL }, /* Bt */
                    224:        { NULL, NULL, NULL, NULL, NULL }, /* Hf */
                    225:        { NULL, NULL, NULL, NULL, NULL }, /* Fr */
                    226:        { NULL, pre_ux, NULL, "currently under development.", NULL }, /* Ud */
1.14      schwarze  227:        { NULL, NULL, post_lb, NULL, NULL }, /* Lb */
1.3       schwarze  228:        { NULL, pre_pp, NULL, NULL, NULL }, /* Lp */
1.24      schwarze  229:        { NULL, pre_lk, NULL, NULL, NULL }, /* Lk */
1.26      schwarze  230:        { NULL, pre_em, post_font, NULL, NULL }, /* Mt */
1.9       schwarze  231:        { cond_body, pre_enc, post_enc, "{", "}" }, /* Brq */
                    232:        { cond_body, pre_enc, post_enc, "{", "}" }, /* Bro */
                    233:        { NULL, NULL, NULL, NULL, NULL }, /* Brc */
1.34      schwarze  234:        { NULL, NULL, post_percent, NULL, NULL }, /* %C */
1.29      schwarze  235:        { NULL, NULL, NULL, NULL, NULL }, /* Es */
                    236:        { NULL, NULL, NULL, NULL, NULL }, /* En */
1.8       schwarze  237:        { NULL, pre_ux, NULL, "DragonFly", NULL }, /* Dx */
1.34      schwarze  238:        { NULL, NULL, post_percent, NULL, NULL }, /* %Q */
1.3       schwarze  239:        { NULL, pre_br, NULL, NULL, NULL }, /* br */
                    240:        { NULL, pre_sp, post_sp, NULL, NULL }, /* sp */
1.34      schwarze  241:        { NULL, NULL, post_percent, NULL, NULL }, /* %U */
                    242:        { NULL, NULL, NULL, NULL, NULL }, /* Ta */
1.3       schwarze  243:        { NULL, NULL, NULL, NULL, NULL }, /* ROOT */
1.1       schwarze  244: };
                    245:
1.20      schwarze  246: static int             outflags;
1.36      schwarze  247: #define        MMAN_spc        (1 << 0)  /* blank character before next word */
                    248: #define        MMAN_spc_force  (1 << 1)  /* even before trailing punctuation */
                    249: #define        MMAN_nl         (1 << 2)  /* break man(7) code line */
                    250: #define        MMAN_br         (1 << 3)  /* break output line */
                    251: #define        MMAN_sp         (1 << 4)  /* insert a blank output line */
                    252: #define        MMAN_PP         (1 << 5)  /* reset indentation etc. */
                    253: #define        MMAN_Sm         (1 << 6)  /* horizontal spacing mode */
                    254: #define        MMAN_Bk         (1 << 7)  /* word keep mode */
1.46      schwarze  255: #define        MMAN_Bk_susp    (1 << 8)  /* suspend this (after a macro) */
                    256: #define        MMAN_An_split   (1 << 9)  /* author mode is "split" */
                    257: #define        MMAN_An_nosplit (1 << 10) /* author mode is "nosplit" */
                    258: #define        MMAN_PD         (1 << 11) /* inter-paragraph spacing disabled */
1.20      schwarze  259:
1.43      schwarze  260: #define        BL_STACK_MAX    32
                    261:
                    262: static size_t          Bl_stack[BL_STACK_MAX];  /* offsets [chars] */
                    263: static int             Bl_stack_post[BL_STACK_MAX];  /* add final .RE */
                    264: static int             Bl_stack_len;  /* number of nested Bl blocks */
1.37      schwarze  265: static int             TPremain;  /* characters before tag is full */
                    266:
1.26      schwarze  267: static struct {
                    268:        char    *head;
                    269:        char    *tail;
                    270:        size_t   size;
                    271: }      fontqueue;
                    272:
                    273: static void
                    274: font_push(char newfont)
                    275: {
                    276:
                    277:        if (fontqueue.head + fontqueue.size <= ++fontqueue.tail) {
                    278:                fontqueue.size += 8;
                    279:                fontqueue.head = mandoc_realloc(fontqueue.head,
                    280:                                fontqueue.size);
                    281:        }
                    282:        *fontqueue.tail = newfont;
1.37      schwarze  283:        print_word("");
                    284:        printf("\\f");
1.26      schwarze  285:        putchar(newfont);
                    286:        outflags &= ~MMAN_spc;
                    287: }
                    288:
                    289: static void
                    290: font_pop(void)
                    291: {
                    292:
                    293:        if (fontqueue.tail > fontqueue.head)
                    294:                fontqueue.tail--;
                    295:        outflags &= ~MMAN_spc;
1.37      schwarze  296:        print_word("");
                    297:        printf("\\f");
1.26      schwarze  298:        putchar(*fontqueue.tail);
                    299: }
                    300:
1.1       schwarze  301: static void
1.20      schwarze  302: print_word(const char *s)
1.1       schwarze  303: {
1.5       kristaps  304:
1.36      schwarze  305:        if ((MMAN_PP | MMAN_sp | MMAN_br | MMAN_nl) & outflags) {
1.5       kristaps  306:                /*
                    307:                 * If we need a newline, print it now and start afresh.
                    308:                 */
1.36      schwarze  309:                if (MMAN_PP & outflags) {
1.44      schwarze  310:                        if (MMAN_sp & outflags) {
                    311:                                if (MMAN_PD & outflags) {
                    312:                                        printf("\n.PD");
                    313:                                        outflags &= ~MMAN_PD;
                    314:                                }
                    315:                        } else if ( ! (MMAN_PD & outflags)) {
                    316:                                printf("\n.PD 0");
                    317:                                outflags |= MMAN_PD;
                    318:                        }
1.36      schwarze  319:                        printf("\n.PP\n");
                    320:                } else if (MMAN_sp & outflags)
1.21      schwarze  321:                        printf("\n.sp\n");
                    322:                else if (MMAN_br & outflags)
                    323:                        printf("\n.br\n");
                    324:                else if (MMAN_nl & outflags)
                    325:                        putchar('\n');
1.36      schwarze  326:                outflags &= ~(MMAN_PP|MMAN_sp|MMAN_br|MMAN_nl|MMAN_spc);
1.37      schwarze  327:                if (1 == TPremain)
                    328:                        printf(".br\n");
                    329:                TPremain = 0;
                    330:        } else if (MMAN_spc & outflags) {
1.5       kristaps  331:                /*
1.25      schwarze  332:                 * If we need a space, only print it if
                    333:                 * (1) it is forced by `No' or
                    334:                 * (2) what follows is not terminating punctuation or
                    335:                 * (3) what follows is longer than one character.
1.5       kristaps  336:                 */
1.37      schwarze  337:                if (MMAN_spc_force & outflags || '\0' == s[0] ||
1.25      schwarze  338:                    NULL == strchr(".,:;)]?!", s[0]) || '\0' != s[1]) {
1.46      schwarze  339:                        if (MMAN_Bk & outflags &&
                    340:                            ! (MMAN_Bk_susp & outflags))
1.13      schwarze  341:                                putchar('\\');
1.45      schwarze  342:                        putchar(' ');
1.37      schwarze  343:                        if (TPremain)
                    344:                                TPremain--;
1.13      schwarze  345:                }
1.37      schwarze  346:        }
1.5       kristaps  347:
                    348:        /*
                    349:         * Reassign needing space if we're not following opening
                    350:         * punctuation.
                    351:         */
1.37      schwarze  352:        if (MMAN_Sm & outflags && ('\0' == s[0] ||
                    353:            (('(' != s[0] && '[' != s[0]) || '\0' != s[1])))
1.20      schwarze  354:                outflags |= MMAN_spc;
                    355:        else
                    356:                outflags &= ~MMAN_spc;
1.46      schwarze  357:        outflags &= ~(MMAN_spc_force | MMAN_Bk_susp);
1.5       kristaps  358:
1.1       schwarze  359:        for ( ; *s; s++) {
                    360:                switch (*s) {
                    361:                case (ASCII_NBRSP):
1.45      schwarze  362:                        printf("\\ ");
1.1       schwarze  363:                        break;
                    364:                case (ASCII_HYPH):
                    365:                        putchar('-');
                    366:                        break;
                    367:                default:
1.5       kristaps  368:                        putchar((unsigned char)*s);
1.1       schwarze  369:                        break;
                    370:                }
1.37      schwarze  371:                if (TPremain)
                    372:                        TPremain--;
1.1       schwarze  373:        }
1.4       kristaps  374: }
                    375:
1.11      schwarze  376: static void
1.36      schwarze  377: print_line(const char *s, int newflags)
                    378: {
                    379:
                    380:        outflags &= ~MMAN_br;
                    381:        outflags |= MMAN_nl;
                    382:        print_word(s);
                    383:        outflags |= newflags;
                    384: }
                    385:
                    386: static void
                    387: print_block(const char *s, int newflags)
                    388: {
                    389:
                    390:        outflags &= ~MMAN_PP;
1.44      schwarze  391:        if (MMAN_sp & outflags) {
1.36      schwarze  392:                outflags &= ~(MMAN_sp | MMAN_br);
1.44      schwarze  393:                if (MMAN_PD & outflags) {
                    394:                        print_line(".PD", 0);
                    395:                        outflags &= ~MMAN_PD;
                    396:                }
1.46      schwarze  397:        } else if (! (MMAN_PD & outflags))
                    398:                print_line(".PD 0", MMAN_PD);
1.36      schwarze  399:        outflags |= MMAN_nl;
                    400:        print_word(s);
1.46      schwarze  401:        outflags |= MMAN_Bk_susp | newflags;
1.36      schwarze  402: }
                    403:
                    404: static void
1.20      schwarze  405: print_offs(const char *v)
1.11      schwarze  406: {
                    407:        char              buf[24];
                    408:        struct roffsu     su;
                    409:        size_t            sz;
                    410:
1.48      schwarze  411:        print_line(".RS", MMAN_Bk_susp);
                    412:
1.43      schwarze  413:        /* Convert v into a number (of characters). */
1.11      schwarze  414:        if (NULL == v || '\0' == *v || 0 == strcmp(v, "left"))
                    415:                sz = 0;
                    416:        else if (0 == strcmp(v, "indent"))
                    417:                sz = 6;
                    418:        else if (0 == strcmp(v, "indent-two"))
                    419:                sz = 12;
                    420:        else if (a2roffsu(v, &su, SCALE_MAX)) {
1.43      schwarze  421:                if (SCALE_EN == su.unit)
                    422:                        sz = su.scale;
                    423:                else {
                    424:                        /*
                    425:                         * XXX
                    426:                         * If we are inside an enclosing list,
                    427:                         * there is no easy way to add the two
                    428:                         * indentations because they are provided
                    429:                         * in terms of different units.
                    430:                         */
                    431:                        print_word(v);
1.48      schwarze  432:                        outflags |= MMAN_nl;
1.43      schwarze  433:                        return;
                    434:                }
1.11      schwarze  435:        } else
                    436:                sz = strlen(v);
                    437:
1.43      schwarze  438:        /*
                    439:         * We are inside an enclosing list.
                    440:         * Add the two indentations.
                    441:         */
                    442:        if (Bl_stack_len)
                    443:                sz += Bl_stack[Bl_stack_len - 1];
                    444:
1.11      schwarze  445:        snprintf(buf, sizeof(buf), "%ldn", sz);
1.20      schwarze  446:        print_word(buf);
1.48      schwarze  447:        outflags |= MMAN_nl;
1.11      schwarze  448: }
                    449:
1.47      schwarze  450: /*
                    451:  * Set up the indentation for a list item; used from pre_it().
                    452:  */
1.4       kristaps  453: void
1.35      schwarze  454: print_width(const char *v, const struct mdoc_node *child, size_t defsz)
1.30      schwarze  455: {
                    456:        char              buf[24];
                    457:        struct roffsu     su;
1.31      schwarze  458:        size_t            sz, chsz;
1.37      schwarze  459:        int               numeric, remain;
1.31      schwarze  460:
1.37      schwarze  461:        numeric = 1;
                    462:        remain = 0;
1.43      schwarze  463:
                    464:        /* Convert v into a number (of characters). */
1.35      schwarze  465:        if (NULL == v)
                    466:                sz = defsz;
                    467:        else if (a2roffsu(v, &su, SCALE_MAX)) {
1.30      schwarze  468:                if (SCALE_EN == su.unit)
                    469:                        sz = su.scale;
                    470:                else {
1.37      schwarze  471:                        sz = 0;
                    472:                        numeric = 0;
1.30      schwarze  473:                }
                    474:        } else
                    475:                sz = strlen(v);
                    476:
1.37      schwarze  477:        /* XXX Rough estimation, might have multiple parts. */
                    478:        chsz = (NULL != child && MDOC_TEXT == child->type) ?
                    479:                        strlen(child->string) : 0;
                    480:
1.47      schwarze  481:        /* Maybe we are inside an enclosing list? */
                    482:        mid_it();
1.43      schwarze  483:
                    484:        /*
                    485:         * Save our own indentation,
                    486:         * such that child lists can use it.
                    487:         */
                    488:        Bl_stack[Bl_stack_len++] = sz + 2;
                    489:
                    490:        /* Set up the current list. */
1.37      schwarze  491:        if (defsz && chsz > sz)
1.36      schwarze  492:                print_block(".HP", 0);
1.37      schwarze  493:        else {
1.36      schwarze  494:                print_block(".TP", 0);
1.37      schwarze  495:                remain = sz + 2;
                    496:        }
                    497:        if (numeric) {
                    498:                snprintf(buf, sizeof(buf), "%ldn", sz + 2);
                    499:                print_word(buf);
                    500:        } else
                    501:                print_word(v);
                    502:        TPremain = remain;
1.30      schwarze  503: }
                    504:
                    505: void
                    506: print_count(int *count)
                    507: {
                    508:        char              buf[12];
                    509:
                    510:        snprintf(buf, sizeof(buf), "%d.", ++*count);
                    511:        print_word(buf);
                    512: }
                    513:
                    514: void
1.4       kristaps  515: man_man(void *arg, const struct man *man)
                    516: {
                    517:
1.5       kristaps  518:        /*
                    519:         * Dump the keep buffer.
                    520:         * We're guaranteed by now that this exists (is non-NULL).
                    521:         * Flush stdout afterward, just in case.
                    522:         */
1.4       kristaps  523:        fputs(mparse_getkeep(man_mparse(man)), stdout);
1.5       kristaps  524:        fflush(stdout);
1.1       schwarze  525: }
                    526:
                    527: void
                    528: man_mdoc(void *arg, const struct mdoc *mdoc)
                    529: {
1.42      schwarze  530:        const struct mdoc_meta *meta;
1.1       schwarze  531:        const struct mdoc_node *n;
                    532:
1.42      schwarze  533:        meta = mdoc_meta(mdoc);
1.1       schwarze  534:        n = mdoc_node(mdoc);
                    535:
1.45      schwarze  536:        printf(".TH \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n",
1.42      schwarze  537:                        meta->title, meta->msec, meta->date,
                    538:                        meta->os, meta->vol);
1.1       schwarze  539:
1.45      schwarze  540:        /* Disable hyphenation and if nroff, disable justification. */
                    541:        printf(".nh\n.if n .ad l");
                    542:
1.20      schwarze  543:        outflags = MMAN_nl | MMAN_Sm;
1.26      schwarze  544:        if (0 == fontqueue.size) {
                    545:                fontqueue.size = 8;
                    546:                fontqueue.head = fontqueue.tail = mandoc_malloc(8);
                    547:                *fontqueue.tail = 'R';
                    548:        }
1.42      schwarze  549:        print_node(meta, n);
1.3       schwarze  550:        putchar('\n');
1.1       schwarze  551: }
                    552:
                    553: static void
                    554: print_node(DECL_ARGS)
                    555: {
                    556:        const struct mdoc_node  *prev, *sub;
1.5       kristaps  557:        const struct manact     *act;
1.1       schwarze  558:        int                      cond, do_sub;
1.46      schwarze  559:
1.5       kristaps  560:        /*
                    561:         * Break the line if we were parsed subsequent the current node.
                    562:         * This makes the page structure be more consistent.
                    563:         */
1.1       schwarze  564:        prev = n->prev ? n->prev : n->parent;
1.27      schwarze  565:        if (MMAN_spc & outflags && prev && prev->line < n->line)
1.20      schwarze  566:                outflags |= MMAN_nl;
1.1       schwarze  567:
1.5       kristaps  568:        act = NULL;
1.1       schwarze  569:        cond = 0;
                    570:        do_sub = 1;
1.5       kristaps  571:
1.1       schwarze  572:        if (MDOC_TEXT == n->type) {
1.5       kristaps  573:                /*
                    574:                 * Make sure that we don't happen to start with a
                    575:                 * control character at the start of a line.
                    576:                 */
1.20      schwarze  577:                if (MMAN_nl & outflags && ('.' == *n->string ||
1.5       kristaps  578:                                        '\'' == *n->string)) {
1.37      schwarze  579:                        print_word("");
                    580:                        printf("\\&");
1.20      schwarze  581:                        outflags &= ~MMAN_spc;
1.3       schwarze  582:                }
1.20      schwarze  583:                print_word(n->string);
1.1       schwarze  584:        } else {
1.5       kristaps  585:                /*
                    586:                 * Conditionally run the pre-node action handler for a
                    587:                 * node.
                    588:                 */
1.1       schwarze  589:                act = manacts + n->tok;
1.42      schwarze  590:                cond = NULL == act->cond || (*act->cond)(meta, n);
1.1       schwarze  591:                if (cond && act->pre)
1.42      schwarze  592:                        do_sub = (*act->pre)(meta, n);
1.1       schwarze  593:        }
                    594:
1.5       kristaps  595:        /*
                    596:         * Conditionally run all child nodes.
                    597:         * Note that this iterates over children instead of using
                    598:         * recursion.  This prevents unnecessary depth in the stack.
                    599:         */
1.1       schwarze  600:        if (do_sub)
                    601:                for (sub = n->child; sub; sub = sub->next)
1.42      schwarze  602:                        print_node(meta, sub);
1.1       schwarze  603:
1.5       kristaps  604:        /*
                    605:         * Lastly, conditionally run the post-node handler.
                    606:         */
1.1       schwarze  607:        if (cond && act->post)
1.42      schwarze  608:                (*act->post)(meta, n);
1.1       schwarze  609: }
                    610:
                    611: static int
                    612: cond_head(DECL_ARGS)
                    613: {
1.5       kristaps  614:
1.1       schwarze  615:        return(MDOC_HEAD == n->type);
                    616: }
                    617:
                    618: static int
                    619: cond_body(DECL_ARGS)
                    620: {
1.5       kristaps  621:
1.1       schwarze  622:        return(MDOC_BODY == n->type);
                    623: }
                    624:
                    625: static int
                    626: pre_enc(DECL_ARGS)
                    627: {
1.5       kristaps  628:        const char      *prefix;
1.1       schwarze  629:
                    630:        prefix = manacts[n->tok].prefix;
                    631:        if (NULL == prefix)
                    632:                return(1);
1.20      schwarze  633:        print_word(prefix);
                    634:        outflags &= ~MMAN_spc;
1.1       schwarze  635:        return(1);
                    636: }
                    637:
                    638: static void
                    639: post_enc(DECL_ARGS)
                    640: {
                    641:        const char *suffix;
                    642:
                    643:        suffix = manacts[n->tok].suffix;
                    644:        if (NULL == suffix)
                    645:                return;
1.20      schwarze  646:        outflags &= ~MMAN_spc;
                    647:        print_word(suffix);
1.26      schwarze  648: }
                    649:
                    650: static void
                    651: post_font(DECL_ARGS)
                    652: {
                    653:
                    654:        font_pop();
1.1       schwarze  655: }
                    656:
                    657: static void
                    658: post_percent(DECL_ARGS)
                    659: {
                    660:
1.34      schwarze  661:        if (pre_em == manacts[n->tok].pre)
                    662:                font_pop();
                    663:        if (n->next) {
1.20      schwarze  664:                print_word(",");
1.34      schwarze  665:                if (n->prev &&  n->prev->tok == n->tok &&
                    666:                                n->next->tok == n->tok)
                    667:                        print_word("and");
                    668:        } else {
1.20      schwarze  669:                print_word(".");
                    670:                outflags |= MMAN_nl;
1.1       schwarze  671:        }
                    672: }
                    673:
1.34      schwarze  674: static int
                    675: pre__t(DECL_ARGS)
                    676: {
                    677:
                    678:         if (n->parent && MDOC_Rs == n->parent->tok &&
                    679:                         n->parent->norm->Rs.quote_T) {
1.37      schwarze  680:                print_word("");
                    681:                putchar('\"');
1.34      schwarze  682:                outflags &= ~MMAN_spc;
                    683:        } else
                    684:                font_push('I');
                    685:        return(1);
                    686: }
                    687:
                    688: static void
                    689: post__t(DECL_ARGS)
                    690: {
                    691:
                    692:         if (n->parent && MDOC_Rs == n->parent->tok &&
                    693:                         n->parent->norm->Rs.quote_T) {
                    694:                outflags &= ~MMAN_spc;
1.37      schwarze  695:                print_word("");
                    696:                putchar('\"');
1.34      schwarze  697:        } else
                    698:                font_pop();
1.42      schwarze  699:        post_percent(meta, n);
1.34      schwarze  700: }
                    701:
1.5       kristaps  702: /*
                    703:  * Print before a section header.
                    704:  */
1.1       schwarze  705: static int
1.3       schwarze  706: pre_sect(DECL_ARGS)
                    707: {
                    708:
1.46      schwarze  709:        switch (n->type) {
                    710:        case (MDOC_HEAD):
                    711:                outflags |= MMAN_sp;
                    712:                print_block(manacts[n->tok].prefix, 0);
                    713:                print_word("");
                    714:                putchar('\"');
                    715:                outflags &= ~MMAN_spc;
                    716:                break;
                    717:        case (MDOC_BODY):
                    718:                if (MDOC_Sh == n->tok) {
                    719:                        if (MDOC_SYNPRETTY & n->flags)
                    720:                                outflags |= MMAN_Bk;
                    721:                        else
                    722:                                outflags &= ~MMAN_Bk;
                    723:                }
                    724:                break;
                    725:        default:
                    726:                break;
                    727:        }
1.3       schwarze  728:        return(1);
                    729: }
                    730:
1.5       kristaps  731: /*
                    732:  * Print subsequent a section header.
                    733:  */
1.3       schwarze  734: static void
                    735: post_sect(DECL_ARGS)
                    736: {
                    737:
                    738:        if (MDOC_HEAD != n->type)
                    739:                return;
1.20      schwarze  740:        outflags &= ~MMAN_spc;
1.37      schwarze  741:        print_word("");
                    742:        putchar('\"');
1.20      schwarze  743:        outflags |= MMAN_nl;
1.22      schwarze  744:        if (MDOC_Sh == n->tok && SEC_AUTHORS == n->sec)
                    745:                outflags &= ~(MMAN_An_split | MMAN_An_nosplit);
                    746: }
                    747:
1.23      schwarze  748: /* See mdoc_term.c, synopsis_pre() for comments. */
                    749: static void
                    750: pre_syn(const struct mdoc_node *n)
                    751: {
                    752:
                    753:        if (NULL == n->prev || ! (MDOC_SYNPRETTY & n->flags))
                    754:                return;
                    755:
                    756:        if (n->prev->tok == n->tok &&
                    757:                        MDOC_Ft != n->tok &&
                    758:                        MDOC_Fo != n->tok &&
                    759:                        MDOC_Fn != n->tok) {
                    760:                outflags |= MMAN_br;
                    761:                return;
                    762:        }
                    763:
                    764:        switch (n->prev->tok) {
                    765:        case (MDOC_Fd):
                    766:                /* FALLTHROUGH */
                    767:        case (MDOC_Fn):
                    768:                /* FALLTHROUGH */
                    769:        case (MDOC_Fo):
                    770:                /* FALLTHROUGH */
                    771:        case (MDOC_In):
                    772:                /* FALLTHROUGH */
                    773:        case (MDOC_Vt):
                    774:                outflags |= MMAN_sp;
                    775:                break;
                    776:        case (MDOC_Ft):
                    777:                if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
                    778:                        outflags |= MMAN_sp;
                    779:                        break;
                    780:                }
                    781:                /* FALLTHROUGH */
                    782:        default:
                    783:                outflags |= MMAN_br;
                    784:                break;
                    785:        }
                    786: }
                    787:
1.22      schwarze  788: static int
                    789: pre_an(DECL_ARGS)
                    790: {
                    791:
                    792:        switch (n->norm->An.auth) {
                    793:        case (AUTH_split):
                    794:                outflags &= ~MMAN_An_nosplit;
                    795:                outflags |= MMAN_An_split;
                    796:                return(0);
                    797:        case (AUTH_nosplit):
                    798:                outflags &= ~MMAN_An_split;
                    799:                outflags |= MMAN_An_nosplit;
                    800:                return(0);
                    801:        default:
                    802:                if (MMAN_An_split & outflags)
                    803:                        outflags |= MMAN_br;
                    804:                else if (SEC_AUTHORS == n->sec &&
                    805:                    ! (MMAN_An_nosplit & outflags))
                    806:                        outflags |= MMAN_An_split;
                    807:                return(1);
                    808:        }
1.3       schwarze  809: }
                    810:
                    811: static int
                    812: pre_ap(DECL_ARGS)
                    813: {
                    814:
1.20      schwarze  815:        outflags &= ~MMAN_spc;
                    816:        print_word("'");
                    817:        outflags &= ~MMAN_spc;
1.3       schwarze  818:        return(0);
                    819: }
                    820:
                    821: static int
                    822: pre_bd(DECL_ARGS)
                    823: {
                    824:
1.36      schwarze  825:        outflags &= ~(MMAN_PP | MMAN_sp | MMAN_br);
                    826:
                    827:        if (DISP_unfilled == n->norm->Bd.type ||
                    828:            DISP_literal  == n->norm->Bd.type)
                    829:                print_line(".nf", 0);
                    830:        if (0 == n->norm->Bd.comp && NULL != n->parent->prev)
1.21      schwarze  831:                outflags |= MMAN_sp;
1.20      schwarze  832:        print_offs(n->norm->Bd.offs);
1.3       schwarze  833:        return(1);
                    834: }
                    835:
                    836: static void
                    837: post_bd(DECL_ARGS)
                    838: {
                    839:
1.43      schwarze  840:        /* Close out this display. */
1.36      schwarze  841:        print_line(".RE", MMAN_nl);
1.3       schwarze  842:        if (DISP_unfilled == n->norm->Bd.type ||
1.36      schwarze  843:            DISP_literal  == n->norm->Bd.type)
                    844:                print_line(".fi", MMAN_nl);
1.43      schwarze  845:
1.47      schwarze  846:        /* Maybe we are inside an enclosing list? */
                    847:        if (NULL != n->parent->next)
                    848:                mid_it();
1.13      schwarze  849: }
                    850:
                    851: static int
1.27      schwarze  852: pre_bf(DECL_ARGS)
                    853: {
                    854:
                    855:        switch (n->type) {
                    856:        case (MDOC_BLOCK):
                    857:                return(1);
                    858:        case (MDOC_BODY):
                    859:                break;
                    860:        default:
                    861:                return(0);
                    862:        }
                    863:        switch (n->norm->Bf.font) {
                    864:        case (FONT_Em):
                    865:                font_push('I');
                    866:                break;
                    867:        case (FONT_Sy):
                    868:                font_push('B');
                    869:                break;
                    870:        default:
                    871:                font_push('R');
                    872:                break;
                    873:        }
                    874:        return(1);
                    875: }
                    876:
                    877: static void
                    878: post_bf(DECL_ARGS)
                    879: {
                    880:
                    881:        if (MDOC_BODY == n->type)
                    882:                font_pop();
                    883: }
                    884:
                    885: static int
1.13      schwarze  886: pre_bk(DECL_ARGS)
                    887: {
                    888:
                    889:        switch (n->type) {
                    890:        case (MDOC_BLOCK):
                    891:                return(1);
                    892:        case (MDOC_BODY):
1.20      schwarze  893:                outflags |= MMAN_Bk;
1.13      schwarze  894:                return(1);
                    895:        default:
                    896:                return(0);
                    897:        }
                    898: }
                    899:
                    900: static void
                    901: post_bk(DECL_ARGS)
                    902: {
                    903:
1.50      schwarze  904:        if (MDOC_BODY == n->type && ! (MDOC_SYNPRETTY & n->flags))
1.20      schwarze  905:                outflags &= ~MMAN_Bk;
1.3       schwarze  906: }
                    907:
                    908: static int
1.30      schwarze  909: pre_bl(DECL_ARGS)
                    910: {
1.33      schwarze  911:        size_t           icol;
1.30      schwarze  912:
1.49      schwarze  913:        /*
                    914:         * print_offs() will increase the -offset to account for
                    915:         * a possible enclosing .It, but any enclosed .It blocks
                    916:         * just nest and do not add up their indentation.
                    917:         */
                    918:        if (n->norm->Bl.offs) {
                    919:                print_offs(n->norm->Bl.offs);
                    920:                Bl_stack[Bl_stack_len++] = 0;
                    921:        }
                    922:
1.33      schwarze  923:        switch (n->norm->Bl.type) {
                    924:        case (LIST_enum):
1.30      schwarze  925:                n->norm->Bl.count = 0;
1.33      schwarze  926:                return(1);
                    927:        case (LIST_column):
                    928:                break;
                    929:        default:
                    930:                return(1);
                    931:        }
                    932:
1.36      schwarze  933:        print_line(".TS", MMAN_nl);
1.33      schwarze  934:        for (icol = 0; icol < n->norm->Bl.ncols; icol++)
                    935:                print_word("l");
                    936:        print_word(".");
1.36      schwarze  937:        outflags |= MMAN_nl;
1.30      schwarze  938:        return(1);
                    939: }
                    940:
                    941: static void
                    942: post_bl(DECL_ARGS)
                    943: {
                    944:
1.33      schwarze  945:        switch (n->norm->Bl.type) {
1.36      schwarze  946:        case (LIST_column):
                    947:                print_line(".TE", 0);
                    948:                break;
1.33      schwarze  949:        case (LIST_enum):
                    950:                n->norm->Bl.count = 0;
                    951:                break;
                    952:        default:
                    953:                break;
                    954:        }
1.49      schwarze  955:
                    956:        if (n->norm->Bl.offs) {
                    957:                print_line(".RE", MMAN_nl);
                    958:                assert(Bl_stack_len);
                    959:                Bl_stack_len--;
                    960:                assert(0 == Bl_stack[Bl_stack_len]);
                    961:        } else {
                    962:                outflags |= MMAN_PP | MMAN_nl;
                    963:                outflags &= ~(MMAN_sp | MMAN_br);
                    964:        }
1.47      schwarze  965:
                    966:        /* Maybe we are inside an enclosing list? */
                    967:        if (NULL != n->parent->next)
                    968:                mid_it();
                    969:
1.30      schwarze  970: }
                    971:
                    972: static int
1.3       schwarze  973: pre_br(DECL_ARGS)
                    974: {
                    975:
1.21      schwarze  976:        outflags |= MMAN_br;
1.3       schwarze  977:        return(0);
                    978: }
                    979:
                    980: static int
1.8       schwarze  981: pre_bx(DECL_ARGS)
                    982: {
                    983:
                    984:        n = n->child;
                    985:        if (n) {
1.20      schwarze  986:                print_word(n->string);
                    987:                outflags &= ~MMAN_spc;
1.8       schwarze  988:                n = n->next;
                    989:        }
1.20      schwarze  990:        print_word("BSD");
1.8       schwarze  991:        if (NULL == n)
                    992:                return(0);
1.20      schwarze  993:        outflags &= ~MMAN_spc;
                    994:        print_word("-");
                    995:        outflags &= ~MMAN_spc;
                    996:        print_word(n->string);
1.8       schwarze  997:        return(0);
                    998: }
                    999:
                   1000: static int
1.1       schwarze 1001: pre_dl(DECL_ARGS)
                   1002: {
                   1003:
1.47      schwarze 1004:        print_offs("6n");
1.1       schwarze 1005:        return(1);
                   1006: }
                   1007:
                   1008: static void
                   1009: post_dl(DECL_ARGS)
                   1010: {
                   1011:
1.36      schwarze 1012:        print_line(".RE", MMAN_nl);
1.47      schwarze 1013:
                   1014:        /* Maybe we are inside an enclosing list? */
                   1015:        if (NULL != n->parent->next)
                   1016:                mid_it();
1.16      schwarze 1017: }
                   1018:
                   1019: static int
1.26      schwarze 1020: pre_em(DECL_ARGS)
                   1021: {
                   1022:
                   1023:        font_push('I');
                   1024:        return(1);
1.28      schwarze 1025: }
                   1026:
                   1027: static void
                   1028: post_eo(DECL_ARGS)
                   1029: {
                   1030:
                   1031:        if (MDOC_HEAD == n->type || MDOC_BODY == n->type)
                   1032:                outflags &= ~MMAN_spc;
1.26      schwarze 1033: }
                   1034:
                   1035: static int
1.17      schwarze 1036: pre_fa(DECL_ARGS)
                   1037: {
                   1038:
                   1039:        if (MDOC_Fa == n->tok)
                   1040:                n = n->child;
                   1041:
                   1042:        while (NULL != n) {
1.26      schwarze 1043:                font_push('I');
1.42      schwarze 1044:                print_node(meta, n);
1.26      schwarze 1045:                font_pop();
1.17      schwarze 1046:                if (NULL != (n = n->next))
1.20      schwarze 1047:                        print_word(",");
1.17      schwarze 1048:        }
                   1049:        return(0);
                   1050: }
                   1051:
                   1052: static void
                   1053: post_fa(DECL_ARGS)
                   1054: {
                   1055:
                   1056:        if (NULL != n->next && MDOC_Fa == n->next->tok)
1.20      schwarze 1057:                print_word(",");
1.29      schwarze 1058: }
                   1059:
                   1060: static int
                   1061: pre_fd(DECL_ARGS)
                   1062: {
                   1063:
                   1064:        pre_syn(n);
                   1065:        font_push('B');
                   1066:        return(1);
                   1067: }
                   1068:
                   1069: static void
                   1070: post_fd(DECL_ARGS)
                   1071: {
                   1072:
                   1073:        font_pop();
                   1074:        outflags |= MMAN_br;
1.17      schwarze 1075: }
                   1076:
                   1077: static int
1.26      schwarze 1078: pre_fl(DECL_ARGS)
                   1079: {
                   1080:
                   1081:        font_push('B');
1.45      schwarze 1082:        print_word("\\-");
1.26      schwarze 1083:        outflags &= ~MMAN_spc;
                   1084:        return(1);
                   1085: }
                   1086:
                   1087: static void
                   1088: post_fl(DECL_ARGS)
                   1089: {
                   1090:
                   1091:        font_pop();
1.27      schwarze 1092:        if (0 == n->nchild && NULL != n->next &&
                   1093:                        n->next->line == n->line)
1.26      schwarze 1094:                outflags &= ~MMAN_spc;
                   1095: }
                   1096:
                   1097: static int
1.16      schwarze 1098: pre_fn(DECL_ARGS)
                   1099: {
                   1100:
1.23      schwarze 1101:        pre_syn(n);
                   1102:
1.16      schwarze 1103:        n = n->child;
                   1104:        if (NULL == n)
                   1105:                return(0);
                   1106:
1.26      schwarze 1107:        font_push('B');
1.42      schwarze 1108:        print_node(meta, n);
1.26      schwarze 1109:        font_pop();
1.20      schwarze 1110:        outflags &= ~MMAN_spc;
1.26      schwarze 1111:        print_word("(");
1.20      schwarze 1112:        outflags &= ~MMAN_spc;
1.35      schwarze 1113:
                   1114:        n = n->next;
                   1115:        if (NULL != n)
1.42      schwarze 1116:                pre_fa(meta, n);
1.35      schwarze 1117:        return(0);
1.16      schwarze 1118: }
                   1119:
                   1120: static void
                   1121: post_fn(DECL_ARGS)
                   1122: {
                   1123:
1.20      schwarze 1124:        print_word(")");
1.16      schwarze 1125:        if (MDOC_SYNPRETTY & n->flags) {
1.20      schwarze 1126:                print_word(";");
1.21      schwarze 1127:                outflags |= MMAN_br;
1.17      schwarze 1128:        }
                   1129: }
                   1130:
                   1131: static int
                   1132: pre_fo(DECL_ARGS)
                   1133: {
                   1134:
                   1135:        switch (n->type) {
1.23      schwarze 1136:        case (MDOC_BLOCK):
                   1137:                pre_syn(n);
                   1138:                break;
1.17      schwarze 1139:        case (MDOC_HEAD):
1.26      schwarze 1140:                font_push('B');
1.17      schwarze 1141:                break;
                   1142:        case (MDOC_BODY):
1.20      schwarze 1143:                outflags &= ~MMAN_spc;
                   1144:                print_word("(");
                   1145:                outflags &= ~MMAN_spc;
1.17      schwarze 1146:                break;
                   1147:        default:
                   1148:                break;
                   1149:        }
                   1150:        return(1);
                   1151: }
                   1152:
                   1153: static void
                   1154: post_fo(DECL_ARGS)
                   1155: {
                   1156:
                   1157:        switch (n->type) {
                   1158:        case (MDOC_HEAD):
1.26      schwarze 1159:                font_pop();
1.17      schwarze 1160:                break;
                   1161:        case (MDOC_BODY):
1.42      schwarze 1162:                post_fn(meta, n);
1.17      schwarze 1163:                break;
                   1164:        default:
                   1165:                break;
1.16      schwarze 1166:        }
1.15      schwarze 1167: }
                   1168:
                   1169: static int
1.23      schwarze 1170: pre_ft(DECL_ARGS)
                   1171: {
                   1172:
                   1173:        pre_syn(n);
1.26      schwarze 1174:        font_push('I');
1.23      schwarze 1175:        return(1);
                   1176: }
                   1177:
                   1178: static int
1.15      schwarze 1179: pre_in(DECL_ARGS)
                   1180: {
                   1181:
                   1182:        if (MDOC_SYNPRETTY & n->flags) {
1.23      schwarze 1183:                pre_syn(n);
1.26      schwarze 1184:                font_push('B');
                   1185:                print_word("#include <");
                   1186:                outflags &= ~MMAN_spc;
                   1187:        } else {
                   1188:                print_word("<");
                   1189:                outflags &= ~MMAN_spc;
                   1190:                font_push('I');
                   1191:        }
1.15      schwarze 1192:        return(1);
                   1193: }
                   1194:
                   1195: static void
                   1196: post_in(DECL_ARGS)
                   1197: {
                   1198:
                   1199:        if (MDOC_SYNPRETTY & n->flags) {
1.26      schwarze 1200:                outflags &= ~MMAN_spc;
                   1201:                print_word(">");
                   1202:                font_pop();
1.21      schwarze 1203:                outflags |= MMAN_br;
1.26      schwarze 1204:        } else {
                   1205:                font_pop();
                   1206:                outflags &= ~MMAN_spc;
                   1207:                print_word(">");
                   1208:        }
1.1       schwarze 1209: }
                   1210:
                   1211: static int
                   1212: pre_it(DECL_ARGS)
                   1213: {
                   1214:        const struct mdoc_node *bln;
                   1215:
1.30      schwarze 1216:        switch (n->type) {
                   1217:        case (MDOC_HEAD):
1.36      schwarze 1218:                outflags |= MMAN_PP | MMAN_nl;
1.30      schwarze 1219:                bln = n->parent->parent;
1.36      schwarze 1220:                if (0 == bln->norm->Bl.comp ||
1.39      schwarze 1221:                    (NULL == n->parent->prev &&
                   1222:                     NULL == bln->parent->prev))
1.36      schwarze 1223:                        outflags |= MMAN_sp;
                   1224:                outflags &= ~MMAN_br;
1.3       schwarze 1225:                switch (bln->norm->Bl.type) {
1.30      schwarze 1226:                case (LIST_item):
                   1227:                        return(0);
                   1228:                case (LIST_inset):
                   1229:                        /* FALLTHROUGH */
                   1230:                case (LIST_diag):
                   1231:                        /* FALLTHROUGH */
                   1232:                case (LIST_ohang):
                   1233:                        if (bln->norm->Bl.type == LIST_diag)
1.36      schwarze 1234:                                print_line(".B \"", 0);
1.30      schwarze 1235:                        else
1.36      schwarze 1236:                                print_line(".R \"", 0);
1.30      schwarze 1237:                        outflags &= ~MMAN_spc;
                   1238:                        return(1);
1.3       schwarze 1239:                case (LIST_bullet):
1.30      schwarze 1240:                        /* FALLTHROUGH */
                   1241:                case (LIST_dash):
                   1242:                        /* FALLTHROUGH */
                   1243:                case (LIST_hyphen):
1.35      schwarze 1244:                        print_width(bln->norm->Bl.width, NULL, 0);
1.37      schwarze 1245:                        TPremain = 0;
1.30      schwarze 1246:                        outflags |= MMAN_nl;
                   1247:                        font_push('B');
                   1248:                        if (LIST_bullet == bln->norm->Bl.type)
                   1249:                                print_word("o");
                   1250:                        else
                   1251:                                print_word("-");
                   1252:                        font_pop();
                   1253:                        break;
                   1254:                case (LIST_enum):
1.35      schwarze 1255:                        print_width(bln->norm->Bl.width, NULL, 0);
1.37      schwarze 1256:                        TPremain = 0;
1.30      schwarze 1257:                        outflags |= MMAN_nl;
                   1258:                        print_count(&bln->norm->Bl.count);
1.3       schwarze 1259:                        break;
1.31      schwarze 1260:                case (LIST_hang):
1.35      schwarze 1261:                        print_width(bln->norm->Bl.width, n->child, 6);
1.37      schwarze 1262:                        TPremain = 0;
1.32      schwarze 1263:                        break;
                   1264:                case (LIST_tag):
1.37      schwarze 1265:                        print_width(bln->norm->Bl.width, n->child, 0);
                   1266:                        putchar('\n');
                   1267:                        outflags &= ~MMAN_spc;
                   1268:                        return(1);
1.3       schwarze 1269:                default:
1.32      schwarze 1270:                        return(1);
1.3       schwarze 1271:                }
1.20      schwarze 1272:                outflags |= MMAN_nl;
1.30      schwarze 1273:        default:
                   1274:                break;
1.1       schwarze 1275:        }
                   1276:        return(1);
1.30      schwarze 1277: }
                   1278:
1.47      schwarze 1279: /*
                   1280:  * This function is called after closing out an indented block.
                   1281:  * If we are inside an enclosing list, restore its indentation.
                   1282:  */
                   1283: static void
                   1284: mid_it(void)
                   1285: {
                   1286:        char             buf[24];
                   1287:
                   1288:        /* Nothing to do outside a list. */
                   1289:        if (0 == Bl_stack_len || 0 == Bl_stack[Bl_stack_len - 1])
                   1290:                return;
                   1291:
                   1292:        /* The indentation has already been set up. */
                   1293:        if (Bl_stack_post[Bl_stack_len - 1])
                   1294:                return;
                   1295:
                   1296:        /* Restore the indentation of the enclosing list. */
                   1297:        print_line(".RS", MMAN_Bk_susp);
                   1298:        snprintf(buf, sizeof(buf), "%ldn", Bl_stack[Bl_stack_len - 1]);
                   1299:        print_word(buf);
                   1300:
                   1301:        /* Remeber to close out this .RS block later. */
                   1302:        Bl_stack_post[Bl_stack_len - 1] = 1;
                   1303: }
                   1304:
1.30      schwarze 1305: static void
                   1306: post_it(DECL_ARGS)
                   1307: {
                   1308:        const struct mdoc_node *bln;
                   1309:
1.33      schwarze 1310:        bln = n->parent->parent;
                   1311:
                   1312:        switch (n->type) {
                   1313:        case (MDOC_HEAD):
1.30      schwarze 1314:                switch (bln->norm->Bl.type) {
                   1315:                case (LIST_diag):
                   1316:                        outflags &= ~MMAN_spc;
                   1317:                        print_word("\\ ");
                   1318:                        break;
                   1319:                case (LIST_ohang):
                   1320:                        outflags |= MMAN_br;
                   1321:                        break;
                   1322:                default:
                   1323:                        break;
                   1324:                }
1.33      schwarze 1325:                break;
                   1326:        case (MDOC_BODY):
1.43      schwarze 1327:                switch (bln->norm->Bl.type) {
                   1328:                case (LIST_bullet):
                   1329:                        /* FALLTHROUGH */
                   1330:                case (LIST_dash):
                   1331:                        /* FALLTHROUGH */
                   1332:                case (LIST_hyphen):
                   1333:                        /* FALLTHROUGH */
                   1334:                case (LIST_enum):
                   1335:                        /* FALLTHROUGH */
                   1336:                case (LIST_hang):
                   1337:                        /* FALLTHROUGH */
                   1338:                case (LIST_tag):
                   1339:                        assert(Bl_stack_len);
                   1340:                        Bl_stack[--Bl_stack_len] = 0;
                   1341:
                   1342:                        /*
                   1343:                         * Our indentation had to be restored
1.47      schwarze 1344:                         * after a child display or child list.
1.43      schwarze 1345:                         * Close out that indentation block now.
                   1346:                         */
                   1347:                        if (Bl_stack_post[Bl_stack_len]) {
                   1348:                                print_line(".RE", MMAN_nl);
                   1349:                                Bl_stack_post[Bl_stack_len] = 0;
                   1350:                        }
                   1351:                        break;
                   1352:                case (LIST_column):
                   1353:                        if (NULL != n->next) {
                   1354:                                putchar('\t');
                   1355:                                outflags &= ~MMAN_spc;
                   1356:                        }
                   1357:                        break;
                   1358:                default:
                   1359:                        break;
1.33      schwarze 1360:                }
                   1361:                break;
                   1362:        default:
                   1363:                break;
1.30      schwarze 1364:        }
1.14      schwarze 1365: }
                   1366:
                   1367: static void
                   1368: post_lb(DECL_ARGS)
                   1369: {
                   1370:
1.21      schwarze 1371:        if (SEC_LIBRARY == n->sec)
                   1372:                outflags |= MMAN_br;
1.24      schwarze 1373: }
                   1374:
                   1375: static int
                   1376: pre_lk(DECL_ARGS)
                   1377: {
                   1378:        const struct mdoc_node *link, *descr;
                   1379:
                   1380:        if (NULL == (link = n->child))
                   1381:                return(0);
                   1382:
                   1383:        if (NULL != (descr = link->next)) {
1.26      schwarze 1384:                font_push('I');
1.24      schwarze 1385:                while (NULL != descr) {
                   1386:                        print_word(descr->string);
                   1387:                        descr = descr->next;
                   1388:                }
                   1389:                print_word(":");
1.26      schwarze 1390:                font_pop();
1.24      schwarze 1391:        }
                   1392:
1.26      schwarze 1393:        font_push('B');
1.24      schwarze 1394:        print_word(link->string);
1.26      schwarze 1395:        font_pop();
1.24      schwarze 1396:        return(0);
1.1       schwarze 1397: }
                   1398:
                   1399: static int
1.26      schwarze 1400: pre_li(DECL_ARGS)
                   1401: {
                   1402:
                   1403:        font_push('R');
                   1404:        return(1);
                   1405: }
                   1406:
                   1407: static int
1.1       schwarze 1408: pre_nm(DECL_ARGS)
                   1409: {
1.38      schwarze 1410:        char    *name;
1.1       schwarze 1411:
1.23      schwarze 1412:        if (MDOC_BLOCK == n->type)
                   1413:                pre_syn(n);
1.1       schwarze 1414:        if (MDOC_ELEM != n->type && MDOC_HEAD != n->type)
                   1415:                return(1);
1.42      schwarze 1416:        name = n->child ? n->child->string : meta->name;
1.38      schwarze 1417:        if (NULL == name)
1.23      schwarze 1418:                return(0);
1.38      schwarze 1419:        if (MDOC_HEAD == n->type) {
                   1420:                if (NULL == n->parent->prev)
                   1421:                        outflags |= MMAN_sp;
                   1422:                print_block(".HP", 0);
                   1423:                printf(" %ldn", strlen(name) + 1);
                   1424:                outflags |= MMAN_nl;
                   1425:        }
1.26      schwarze 1426:        font_push('B');
1.1       schwarze 1427:        if (NULL == n->child)
1.42      schwarze 1428:                print_word(meta->name);
1.1       schwarze 1429:        return(1);
                   1430: }
                   1431:
                   1432: static void
                   1433: post_nm(DECL_ARGS)
                   1434: {
                   1435:
                   1436:        if (MDOC_ELEM != n->type && MDOC_HEAD != n->type)
                   1437:                return;
1.26      schwarze 1438:        font_pop();
1.25      schwarze 1439: }
                   1440:
                   1441: static int
                   1442: pre_no(DECL_ARGS)
                   1443: {
                   1444:
                   1445:        outflags |= MMAN_spc_force;
                   1446:        return(1);
1.1       schwarze 1447: }
                   1448:
                   1449: static int
                   1450: pre_ns(DECL_ARGS)
                   1451: {
                   1452:
1.20      schwarze 1453:        outflags &= ~MMAN_spc;
1.1       schwarze 1454:        return(0);
                   1455: }
                   1456:
1.3       schwarze 1457: static void
                   1458: post_pf(DECL_ARGS)
                   1459: {
                   1460:
1.20      schwarze 1461:        outflags &= ~MMAN_spc;
1.3       schwarze 1462: }
                   1463:
1.1       schwarze 1464: static int
                   1465: pre_pp(DECL_ARGS)
                   1466: {
                   1467:
1.36      schwarze 1468:        if (MDOC_It != n->parent->tok)
                   1469:                outflags |= MMAN_PP;
                   1470:        outflags |= MMAN_sp | MMAN_nl;
                   1471:        outflags &= ~MMAN_br;
1.34      schwarze 1472:        return(0);
                   1473: }
                   1474:
                   1475: static int
                   1476: pre_rs(DECL_ARGS)
                   1477: {
                   1478:
                   1479:        if (SEC_SEE_ALSO == n->sec) {
1.36      schwarze 1480:                outflags |= MMAN_PP | MMAN_sp | MMAN_nl;
                   1481:                outflags &= ~MMAN_br;
1.34      schwarze 1482:        }
                   1483:        return(1);
1.12      schwarze 1484: }
                   1485:
                   1486: static int
                   1487: pre_sm(DECL_ARGS)
                   1488: {
                   1489:
                   1490:        assert(n->child && MDOC_TEXT == n->child->type);
                   1491:        if (0 == strcmp("on", n->child->string))
1.27      schwarze 1492:                outflags |= MMAN_Sm | MMAN_spc;
1.12      schwarze 1493:        else
1.20      schwarze 1494:                outflags &= ~MMAN_Sm;
1.12      schwarze 1495:        return(0);
1.1       schwarze 1496: }
                   1497:
                   1498: static int
1.3       schwarze 1499: pre_sp(DECL_ARGS)
1.1       schwarze 1500: {
                   1501:
1.41      schwarze 1502:        if (MMAN_PP & outflags) {
                   1503:                outflags &= ~MMAN_PP;
1.40      schwarze 1504:                print_line(".PP", 0);
1.41      schwarze 1505:        } else
1.40      schwarze 1506:                print_line(".sp", 0);
1.1       schwarze 1507:        return(1);
                   1508: }
                   1509:
                   1510: static void
1.3       schwarze 1511: post_sp(DECL_ARGS)
1.1       schwarze 1512: {
                   1513:
1.20      schwarze 1514:        outflags |= MMAN_nl;
1.18      schwarze 1515: }
                   1516:
                   1517: static int
1.26      schwarze 1518: pre_sy(DECL_ARGS)
                   1519: {
                   1520:
                   1521:        font_push('B');
                   1522:        return(1);
                   1523: }
                   1524:
                   1525: static int
1.18      schwarze 1526: pre_vt(DECL_ARGS)
                   1527: {
                   1528:
                   1529:        if (MDOC_SYNPRETTY & n->flags) {
                   1530:                switch (n->type) {
                   1531:                case (MDOC_BLOCK):
1.23      schwarze 1532:                        pre_syn(n);
1.18      schwarze 1533:                        return(1);
                   1534:                case (MDOC_BODY):
                   1535:                        break;
                   1536:                default:
                   1537:                        return(0);
                   1538:                }
                   1539:        }
1.26      schwarze 1540:        font_push('I');
1.18      schwarze 1541:        return(1);
                   1542: }
                   1543:
                   1544: static void
                   1545: post_vt(DECL_ARGS)
                   1546: {
                   1547:
1.19      schwarze 1548:        if (MDOC_SYNPRETTY & n->flags && MDOC_BODY != n->type)
1.18      schwarze 1549:                return;
1.26      schwarze 1550:        font_pop();
1.1       schwarze 1551: }
                   1552:
                   1553: static int
                   1554: pre_xr(DECL_ARGS)
                   1555: {
                   1556:
                   1557:        n = n->child;
                   1558:        if (NULL == n)
                   1559:                return(0);
1.42      schwarze 1560:        print_node(meta, n);
1.1       schwarze 1561:        n = n->next;
                   1562:        if (NULL == n)
                   1563:                return(0);
1.20      schwarze 1564:        outflags &= ~MMAN_spc;
                   1565:        print_word("(");
1.42      schwarze 1566:        print_node(meta, n);
1.20      schwarze 1567:        print_word(")");
1.1       schwarze 1568:        return(0);
1.8       schwarze 1569: }
                   1570:
                   1571: static int
                   1572: pre_ux(DECL_ARGS)
                   1573: {
                   1574:
1.20      schwarze 1575:        print_word(manacts[n->tok].prefix);
1.8       schwarze 1576:        if (NULL == n->child)
                   1577:                return(0);
1.20      schwarze 1578:        outflags &= ~MMAN_spc;
1.45      schwarze 1579:        print_word("\\ ");
1.20      schwarze 1580:        outflags &= ~MMAN_spc;
1.8       schwarze 1581:        return(1);
1.1       schwarze 1582: }

CVSweb