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

Annotation of mandoc/mdoc_man.c, Revision 1.66

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

CVSweb