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

Annotation of mandoc/mdoc_man.c, Revision 1.39

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

CVSweb