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

Annotation of mandoc/mdoc_man.c, Revision 1.112

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

CVSweb