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

Annotation of mandoc/mdoc_man.c, Revision 1.136

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

CVSweb