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

Annotation of mandoc/mdoc_man.c, Revision 1.88

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

CVSweb