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

Annotation of mandoc/mdoc_man.c, Revision 1.73

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

CVSweb