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

Annotation of mandoc/mdoc_man.c, Revision 1.32

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

CVSweb