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

Annotation of mandoc/mdoc_man.c, Revision 1.62

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

CVSweb