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

Annotation of mandoc/mdoc_markdown.c, Revision 1.22

1.22    ! schwarze    1: /*     $Id: mdoc_markdown.c,v 1.21 2017/05/05 15:17:32 schwarze Exp $ */
1.1       schwarze    2: /*
                      3:  * Copyright (c) 2017 Ingo Schwarze <schwarze@openbsd.org>
                      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 AUTHORS DISCLAIM ALL WARRANTIES
                     10:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     11:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS 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:  */
                     17: #include <sys/types.h>
                     18:
                     19: #include <assert.h>
                     20: #include <ctype.h>
                     21: #include <stdio.h>
                     22: #include <string.h>
                     23:
                     24: #include "mandoc_aux.h"
                     25: #include "mandoc.h"
                     26: #include "roff.h"
                     27: #include "mdoc.h"
                     28: #include "main.h"
                     29:
                     30: struct md_act {
                     31:        int             (*cond)(struct roff_node *n);
                     32:        int             (*pre)(struct roff_node *n);
                     33:        void            (*post)(struct roff_node *n);
                     34:        const char       *prefix; /* pre-node string constant */
                     35:        const char       *suffix; /* post-node string constant */
                     36: };
                     37:
                     38: static void     md_nodelist(struct roff_node *);
                     39: static void     md_node(struct roff_node *);
                     40: static const char *md_stack(char c);
                     41: static void     md_preword(void);
                     42: static void     md_rawword(const char *);
                     43: static void     md_word(const char *);
                     44: static void     md_named(const char *);
                     45: static void     md_char(unsigned char);
1.15      schwarze   46: static void     md_uri(const char *);
1.1       schwarze   47:
                     48: static int      md_cond_head(struct roff_node *);
                     49: static int      md_cond_body(struct roff_node *);
                     50:
                     51: static int      md_pre_raw(struct roff_node *);
                     52: static int      md_pre_word(struct roff_node *);
                     53: static int      md_pre_skip(struct roff_node *);
                     54: static void     md_pre_syn(struct roff_node *);
1.5       schwarze   55: static int      md_pre_An(struct roff_node *);
1.1       schwarze   56: static int      md_pre_Ap(struct roff_node *);
                     57: static int      md_pre_Bd(struct roff_node *);
                     58: static int      md_pre_Bk(struct roff_node *);
                     59: static int      md_pre_Bl(struct roff_node *);
                     60: static int      md_pre_D1(struct roff_node *);
                     61: static int      md_pre_Dl(struct roff_node *);
                     62: static int      md_pre_En(struct roff_node *);
                     63: static int      md_pre_Eo(struct roff_node *);
                     64: static int      md_pre_Fa(struct roff_node *);
                     65: static int      md_pre_Fd(struct roff_node *);
                     66: static int      md_pre_Fn(struct roff_node *);
                     67: static int      md_pre_Fo(struct roff_node *);
                     68: static int      md_pre_In(struct roff_node *);
                     69: static int      md_pre_It(struct roff_node *);
                     70: static int      md_pre_Lk(struct roff_node *);
1.15      schwarze   71: static int      md_pre_Mt(struct roff_node *);
1.1       schwarze   72: static int      md_pre_Nd(struct roff_node *);
                     73: static int      md_pre_Nm(struct roff_node *);
                     74: static int      md_pre_No(struct roff_node *);
                     75: static int      md_pre_Ns(struct roff_node *);
                     76: static int      md_pre_Pp(struct roff_node *);
                     77: static int      md_pre_Rs(struct roff_node *);
                     78: static int      md_pre_Sh(struct roff_node *);
                     79: static int      md_pre_Sm(struct roff_node *);
                     80: static int      md_pre_Vt(struct roff_node *);
                     81: static int      md_pre_Xr(struct roff_node *);
                     82: static int      md_pre__T(struct roff_node *);
                     83: static int      md_pre_br(struct roff_node *);
                     84:
                     85: static void     md_post_raw(struct roff_node *);
                     86: static void     md_post_word(struct roff_node *);
                     87: static void     md_post_pc(struct roff_node *);
                     88: static void     md_post_Bk(struct roff_node *);
                     89: static void     md_post_Bl(struct roff_node *);
                     90: static void     md_post_D1(struct roff_node *);
                     91: static void     md_post_En(struct roff_node *);
                     92: static void     md_post_Eo(struct roff_node *);
                     93: static void     md_post_Fa(struct roff_node *);
                     94: static void     md_post_Fd(struct roff_node *);
1.6       schwarze   95: static void     md_post_Fl(struct roff_node *);
1.1       schwarze   96: static void     md_post_Fn(struct roff_node *);
                     97: static void     md_post_Fo(struct roff_node *);
                     98: static void     md_post_In(struct roff_node *);
                     99: static void     md_post_It(struct roff_node *);
                    100: static void     md_post_Lb(struct roff_node *);
                    101: static void     md_post_Nm(struct roff_node *);
                    102: static void     md_post_Pf(struct roff_node *);
                    103: static void     md_post_Vt(struct roff_node *);
                    104: static void     md_post__T(struct roff_node *);
                    105:
1.17      schwarze  106: static const struct md_act __md_acts[MDOC_MAX - MDOC_Dd] = {
1.1       schwarze  107:        { NULL, NULL, NULL, NULL, NULL }, /* Dd */
                    108:        { NULL, NULL, NULL, NULL, NULL }, /* Dt */
                    109:        { NULL, NULL, NULL, NULL, NULL }, /* Os */
                    110:        { NULL, md_pre_Sh, NULL, NULL, NULL }, /* Sh */
                    111:        { NULL, md_pre_Sh, NULL, NULL, NULL }, /* Ss */
                    112:        { NULL, md_pre_Pp, NULL, NULL, NULL }, /* Pp */
                    113:        { md_cond_body, md_pre_D1, md_post_D1, NULL, NULL }, /* D1 */
                    114:        { md_cond_body, md_pre_Dl, md_post_D1, NULL, NULL }, /* Dl */
                    115:        { md_cond_body, md_pre_Bd, md_post_D1, NULL, NULL }, /* Bd */
                    116:        { NULL, NULL, NULL, NULL, NULL }, /* Ed */
                    117:        { md_cond_body, md_pre_Bl, md_post_Bl, NULL, NULL }, /* Bl */
                    118:        { NULL, NULL, NULL, NULL, NULL }, /* El */
                    119:        { NULL, md_pre_It, md_post_It, NULL, NULL }, /* It */
                    120:        { NULL, md_pre_raw, md_post_raw, "*", "*" }, /* Ad */
1.5       schwarze  121:        { NULL, md_pre_An, NULL, NULL, NULL }, /* An */
1.17      schwarze  122:        { NULL, md_pre_Ap, NULL, NULL, NULL }, /* Ap */
1.1       schwarze  123:        { NULL, md_pre_raw, md_post_raw, "*", "*" }, /* Ar */
                    124:        { NULL, md_pre_raw, md_post_raw, "**", "**" }, /* Cd */
                    125:        { NULL, md_pre_raw, md_post_raw, "**", "**" }, /* Cm */
                    126:        { NULL, md_pre_raw, md_post_raw, "`", "`" }, /* Dv */
                    127:        { NULL, md_pre_raw, md_post_raw, "`", "`" }, /* Er */
                    128:        { NULL, md_pre_raw, md_post_raw, "`", "`" }, /* Ev */
                    129:        { NULL, NULL, NULL, NULL, NULL }, /* Ex */
                    130:        { NULL, md_pre_Fa, md_post_Fa, NULL, NULL }, /* Fa */
                    131:        { NULL, md_pre_Fd, md_post_Fd, "**", "**" }, /* Fd */
1.6       schwarze  132:        { NULL, md_pre_raw, md_post_Fl, "**-", "**" }, /* Fl */
1.1       schwarze  133:        { NULL, md_pre_Fn, md_post_Fn, NULL, NULL }, /* Fn */
                    134:        { NULL, md_pre_Fd, md_post_raw, "*", "*" }, /* Ft */
                    135:        { NULL, md_pre_raw, md_post_raw, "**", "**" }, /* Ic */
1.4       schwarze  136:        { NULL, md_pre_In, md_post_In, NULL, NULL }, /* In */
1.1       schwarze  137:        { NULL, md_pre_raw, md_post_raw, "`", "`" }, /* Li */
                    138:        { md_cond_head, md_pre_Nd, NULL, NULL, NULL }, /* Nd */
                    139:        { NULL, md_pre_Nm, md_post_Nm, "**", "**" }, /* Nm */
                    140:        { md_cond_body, md_pre_word, md_post_word, "[", "]" }, /* Op */
                    141:        { NULL, md_pre_Fd, md_post_raw, "*", "*" }, /* Ot */
                    142:        { NULL, md_pre_raw, md_post_raw, "*", "*" }, /* Pa */
                    143:        { NULL, NULL, NULL, NULL, NULL }, /* Rv */
                    144:        { NULL, NULL, NULL, NULL, NULL }, /* St */
                    145:        { NULL, md_pre_raw, md_post_raw, "*", "*" }, /* Va */
                    146:        { NULL, md_pre_Vt, md_post_Vt, "*", "*" }, /* Vt */
                    147:        { NULL, md_pre_Xr, NULL, NULL, NULL }, /* Xr */
                    148:        { NULL, NULL, md_post_pc, NULL, NULL }, /* %A */
                    149:        { NULL, md_pre_raw, md_post_pc, "*", "*" }, /* %B */
                    150:        { NULL, NULL, md_post_pc, NULL, NULL }, /* %D */
                    151:        { NULL, md_pre_raw, md_post_pc, "*", "*" }, /* %I */
                    152:        { NULL, md_pre_raw, md_post_pc, "*", "*" }, /* %J */
                    153:        { NULL, NULL, md_post_pc, NULL, NULL }, /* %N */
                    154:        { NULL, NULL, md_post_pc, NULL, NULL }, /* %O */
                    155:        { NULL, NULL, md_post_pc, NULL, NULL }, /* %P */
                    156:        { NULL, NULL, md_post_pc, NULL, NULL }, /* %R */
                    157:        { NULL, md_pre__T, md_post__T, NULL, NULL }, /* %T */
                    158:        { NULL, NULL, md_post_pc, NULL, NULL }, /* %V */
                    159:        { NULL, NULL, NULL, NULL, NULL }, /* Ac */
                    160:        { md_cond_body, md_pre_word, md_post_word, "<", ">" }, /* Ao */
                    161:        { md_cond_body, md_pre_word, md_post_word, "<", ">" }, /* Aq */
                    162:        { NULL, NULL, NULL, NULL, NULL }, /* At */
                    163:        { NULL, NULL, NULL, NULL, NULL }, /* Bc */
                    164:        { NULL, NULL, NULL, NULL, NULL }, /* Bf XXX not implemented */
                    165:        { md_cond_body, md_pre_word, md_post_word, "[", "]" }, /* Bo */
                    166:        { md_cond_body, md_pre_word, md_post_word, "[", "]" }, /* Bq */
                    167:        { NULL, NULL, NULL, NULL, NULL }, /* Bsx */
                    168:        { NULL, NULL, NULL, NULL, NULL }, /* Bx */
                    169:        { NULL, NULL, NULL, NULL, NULL }, /* Db */
                    170:        { NULL, NULL, NULL, NULL, NULL }, /* Dc */
                    171:        { md_cond_body, md_pre_word, md_post_word, "\"", "\"" }, /* Do */
                    172:        { md_cond_body, md_pre_word, md_post_word, "\"", "\"" }, /* Dq */
                    173:        { NULL, NULL, NULL, NULL, NULL }, /* Ec */
                    174:        { NULL, NULL, NULL, NULL, NULL }, /* Ef */
                    175:        { NULL, md_pre_raw, md_post_raw, "*", "*" }, /* Em */
                    176:        { md_cond_body, md_pre_Eo, md_post_Eo, NULL, NULL }, /* Eo */
                    177:        { NULL, NULL, NULL, NULL, NULL }, /* Fx */
                    178:        { NULL, md_pre_raw, md_post_raw, "**", "**" }, /* Ms */
                    179:        { NULL, md_pre_No, NULL, NULL, NULL }, /* No */
                    180:        { NULL, md_pre_Ns, NULL, NULL, NULL }, /* Ns */
                    181:        { NULL, NULL, NULL, NULL, NULL }, /* Nx */
                    182:        { NULL, NULL, NULL, NULL, NULL }, /* Ox */
                    183:        { NULL, NULL, NULL, NULL, NULL }, /* Pc */
                    184:        { NULL, NULL, md_post_Pf, NULL, NULL }, /* Pf */
                    185:        { md_cond_body, md_pre_word, md_post_word, "(", ")" }, /* Po */
                    186:        { md_cond_body, md_pre_word, md_post_word, "(", ")" }, /* Pq */
                    187:        { NULL, NULL, NULL, NULL, NULL }, /* Qc */
                    188:        { md_cond_body, md_pre_raw, md_post_raw, "'`", "`'" }, /* Ql */
                    189:        { md_cond_body, md_pre_word, md_post_word, "\"", "\"" }, /* Qo */
                    190:        { md_cond_body, md_pre_word, md_post_word, "\"", "\"" }, /* Qq */
                    191:        { NULL, NULL, NULL, NULL, NULL }, /* Re */
                    192:        { md_cond_body, md_pre_Rs, NULL, NULL, NULL }, /* Rs */
                    193:        { NULL, NULL, NULL, NULL, NULL }, /* Sc */
                    194:        { md_cond_body, md_pre_word, md_post_word, "'", "'" }, /* So */
                    195:        { md_cond_body, md_pre_word, md_post_word, "'", "'" }, /* Sq */
                    196:        { NULL, md_pre_Sm, NULL, NULL, NULL }, /* Sm */
                    197:        { NULL, md_pre_raw, md_post_raw, "*", "*" }, /* Sx */
                    198:        { NULL, md_pre_raw, md_post_raw, "**", "**" }, /* Sy */
                    199:        { NULL, md_pre_raw, md_post_raw, "`", "`" }, /* Tn */
                    200:        { NULL, NULL, NULL, NULL, NULL }, /* Ux */
                    201:        { NULL, NULL, NULL, NULL, NULL }, /* Xc */
                    202:        { NULL, NULL, NULL, NULL, NULL }, /* Xo */
                    203:        { NULL, md_pre_Fo, md_post_Fo, "**", "**" }, /* Fo */
                    204:        { NULL, NULL, NULL, NULL, NULL }, /* Fc */
                    205:        { md_cond_body, md_pre_word, md_post_word, "[", "]" }, /* Oo */
                    206:        { NULL, NULL, NULL, NULL, NULL }, /* Oc */
                    207:        { NULL, md_pre_Bk, md_post_Bk, NULL, NULL }, /* Bk */
                    208:        { NULL, NULL, NULL, NULL, NULL }, /* Ek */
                    209:        { NULL, NULL, NULL, NULL, NULL }, /* Bt */
                    210:        { NULL, NULL, NULL, NULL, NULL }, /* Hf */
                    211:        { NULL, md_pre_raw, md_post_raw, "*", "*" }, /* Fr */
                    212:        { NULL, NULL, NULL, NULL, NULL }, /* Ud */
                    213:        { NULL, NULL, md_post_Lb, NULL, NULL }, /* Lb */
                    214:        { NULL, md_pre_Pp, NULL, NULL, NULL }, /* Lp */
                    215:        { NULL, md_pre_Lk, NULL, NULL, NULL }, /* Lk */
1.15      schwarze  216:        { NULL, md_pre_Mt, NULL, NULL, NULL }, /* Mt */
1.1       schwarze  217:        { md_cond_body, md_pre_word, md_post_word, "{", "}" }, /* Brq */
                    218:        { md_cond_body, md_pre_word, md_post_word, "{", "}" }, /* Bro */
                    219:        { NULL, NULL, NULL, NULL, NULL }, /* Brc */
                    220:        { NULL, NULL, md_post_pc, NULL, NULL }, /* %C */
                    221:        { NULL, md_pre_skip, NULL, NULL, NULL }, /* Es */
                    222:        { md_cond_body, md_pre_En, md_post_En, NULL, NULL }, /* En */
                    223:        { NULL, NULL, NULL, NULL, NULL }, /* Dx */
                    224:        { NULL, NULL, md_post_pc, NULL, NULL }, /* %Q */
1.3       schwarze  225:        { NULL, md_pre_Lk, md_post_pc, NULL, NULL }, /* %U */
1.1       schwarze  226:        { NULL, NULL, NULL, NULL, NULL }, /* Ta */
                    227: };
1.17      schwarze  228: static const struct md_act *const md_acts = __md_acts - MDOC_Dd;
1.1       schwarze  229:
                    230: static int      outflags;
                    231: #define        MD_spc           (1 << 0)  /* Blank character before next word. */
                    232: #define        MD_spc_force     (1 << 1)  /* Even before trailing punctuation. */
                    233: #define        MD_nonl          (1 << 2)  /* Prevent linebreak in markdown code. */
                    234: #define        MD_nl            (1 << 3)  /* Break markdown code line. */
                    235: #define        MD_br            (1 << 4)  /* Insert an output line break. */
                    236: #define        MD_sp            (1 << 5)  /* Insert a paragraph break. */
                    237: #define        MD_Sm            (1 << 6)  /* Horizontal spacing mode. */
                    238: #define        MD_Bk            (1 << 7)  /* Word keep mode. */
1.5       schwarze  239: #define        MD_An_split      (1 << 8)  /* Author mode is "split". */
                    240: #define        MD_An_nosplit    (1 << 9)  /* Author mode is "nosplit". */
1.1       schwarze  241:
                    242: static int      escflags; /* Escape in generated markdown code: */
                    243: #define        ESC_BOL  (1 << 0)  /* "#*+-" near the beginning of a line. */
                    244: #define        ESC_NUM  (1 << 1)  /* "." after a leading number. */
                    245: #define        ESC_HYP  (1 << 2)  /* "(" immediately after "]". */
                    246: #define        ESC_SQU  (1 << 4)  /* "]" when "[" is open. */
                    247: #define        ESC_FON  (1 << 5)  /* "*" immediately after unrelated "*". */
1.8       schwarze  248: #define        ESC_EOL  (1 << 6)  /* " " at the and of a line. */
1.1       schwarze  249:
                    250: static int      code_blocks, quote_blocks, list_blocks;
                    251: static int      outcount;
                    252:
                    253: void
                    254: markdown_mdoc(void *arg, const struct roff_man *mdoc)
                    255: {
                    256:        outflags = MD_Sm;
                    257:        md_word(mdoc->meta.title);
                    258:        if (mdoc->meta.msec != NULL) {
                    259:                outflags &= ~MD_spc;
                    260:                md_word("(");
                    261:                md_word(mdoc->meta.msec);
                    262:                md_word(")");
                    263:        }
                    264:        md_word("-");
                    265:        md_word(mdoc->meta.vol);
                    266:        if (mdoc->meta.arch != NULL) {
                    267:                md_word("(");
                    268:                md_word(mdoc->meta.arch);
                    269:                md_word(")");
                    270:        }
                    271:        outflags |= MD_sp;
                    272:
                    273:        md_nodelist(mdoc->first->child);
                    274:
                    275:        outflags |= MD_sp;
                    276:        md_word(mdoc->meta.os);
                    277:        md_word("-");
                    278:        md_word(mdoc->meta.date);
                    279:        putchar('\n');
                    280: }
                    281:
                    282: static void
                    283: md_nodelist(struct roff_node *n)
                    284: {
                    285:        while (n != NULL) {
                    286:                md_node(n);
                    287:                n = n->next;
                    288:        }
                    289: }
                    290:
                    291: static void
                    292: md_node(struct roff_node *n)
                    293: {
                    294:        const struct md_act     *act;
                    295:        int                      cond, process_children;
                    296:
                    297:        if (n->flags & NODE_NOPRT)
                    298:                return;
                    299:
                    300:        if (outflags & MD_nonl)
                    301:                outflags &= ~(MD_nl | MD_sp);
                    302:        else if (outflags & MD_spc && n->flags & NODE_LINE)
                    303:                outflags |= MD_nl;
                    304:
                    305:        act = NULL;
                    306:        cond = 0;
                    307:        process_children = 1;
                    308:        n->flags &= ~NODE_ENDED;
                    309:
1.18      schwarze  310:        if (n->type == ROFFT_TEXT) {
1.1       schwarze  311:                if (n->flags & NODE_DELIMC)
                    312:                        outflags &= ~(MD_spc | MD_spc_force);
                    313:                else if (outflags & MD_Sm)
                    314:                        outflags |= MD_spc_force;
                    315:                md_word(n->string);
                    316:                if (n->flags & NODE_DELIMO)
                    317:                        outflags &= ~(MD_spc | MD_spc_force);
                    318:                else if (outflags & MD_Sm)
                    319:                        outflags |= MD_spc;
1.18      schwarze  320:        } else if (n->tok < ROFF_MAX) {
                    321:                switch (n->tok) {
                    322:                case ROFF_br:
1.19      schwarze  323:                        process_children = md_pre_br(n);
1.21      schwarze  324:                        break;
                    325:                case ROFF_sp:
                    326:                        process_children = md_pre_Pp(n);
1.19      schwarze  327:                        break;
1.20      schwarze  328:                default:
1.19      schwarze  329:                        process_children = 0;
1.18      schwarze  330:                        break;
                    331:                }
                    332:        } else {
                    333:                assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);
1.1       schwarze  334:                act = md_acts + n->tok;
                    335:                cond = act->cond == NULL || (*act->cond)(n);
                    336:                if (cond && act->pre != NULL &&
                    337:                    (n->end == ENDBODY_NOT || n->child != NULL))
                    338:                        process_children = (*act->pre)(n);
                    339:        }
                    340:
                    341:        if (process_children && n->child != NULL)
                    342:                md_nodelist(n->child);
                    343:
                    344:        if (n->flags & NODE_ENDED)
                    345:                return;
                    346:
                    347:        if (cond && act->post != NULL)
                    348:                (*act->post)(n);
                    349:
                    350:        if (n->end != ENDBODY_NOT)
                    351:                n->body->flags |= NODE_ENDED;
                    352: }
                    353:
                    354: static const char *
                    355: md_stack(char c)
                    356: {
                    357:        static char     *stack;
                    358:        static size_t    sz;
                    359:        static size_t    cur;
                    360:
                    361:        switch (c) {
                    362:        case '\0':
                    363:                break;
                    364:        case (char)-1:
                    365:                assert(cur);
                    366:                stack[--cur] = '\0';
                    367:                break;
                    368:        default:
                    369:                if (cur + 1 >= sz) {
                    370:                        sz += 8;
                    371:                        stack = mandoc_realloc(stack, sz);
                    372:                }
                    373:                stack[cur] = c;
                    374:                stack[++cur] = '\0';
                    375:                break;
                    376:        }
                    377:        return stack == NULL ? "" : stack;
                    378: }
                    379:
                    380: /*
                    381:  * Handle vertical and horizontal spacing.
                    382:  */
                    383: static void
                    384: md_preword(void)
                    385: {
1.9       schwarze  386:        const char      *cp;
                    387:
1.1       schwarze  388:        /*
                    389:         * If a list block is nested inside a code block or a blockquote,
                    390:         * blank lines for paragraph breaks no longer work; instead,
                    391:         * they terminate the list.  Work around this markdown issue
                    392:         * by using mere line breaks instead.
                    393:         */
1.8       schwarze  394:
1.1       schwarze  395:        if (list_blocks && outflags & MD_sp) {
                    396:                outflags &= ~MD_sp;
                    397:                outflags |= MD_br;
                    398:        }
                    399:
1.8       schwarze  400:        /*
                    401:         * End the old line if requested.
                    402:         * Escape whitespace at the end of the markdown line
                    403:         * such that it won't look like an output line break.
                    404:         */
1.1       schwarze  405:
                    406:        if (outflags & MD_sp)
                    407:                putchar('\n');
                    408:        else if (outflags & MD_br) {
                    409:                putchar(' ');
                    410:                putchar(' ');
1.8       schwarze  411:        } else if (outflags & MD_nl && escflags & ESC_EOL)
                    412:                md_named("zwnj");
1.1       schwarze  413:
                    414:        /* Start a new line if necessary. */
                    415:
                    416:        if (outflags & (MD_nl | MD_br | MD_sp)) {
                    417:                putchar('\n');
1.9       schwarze  418:                for (cp = md_stack('\0'); *cp != '\0'; cp++) {
                    419:                        putchar(*cp);
                    420:                        if (*cp == '>')
                    421:                                putchar(' ');
                    422:                }
1.1       schwarze  423:                outflags &= ~(MD_nl | MD_br | MD_sp);
                    424:                escflags = ESC_BOL;
                    425:                outcount = 0;
                    426:
                    427:        /* Handle horizontal spacing. */
                    428:
                    429:        } else if (outflags & MD_spc) {
                    430:                if (outflags & MD_Bk)
                    431:                        fputs("&nbsp;", stdout);
                    432:                else
                    433:                        putchar(' ');
                    434:                escflags &= ~ESC_FON;
                    435:                outcount++;
                    436:        }
                    437:
                    438:        outflags &= ~(MD_spc_force | MD_nonl);
                    439:        if (outflags & MD_Sm)
                    440:                outflags |= MD_spc;
                    441:        else
                    442:                outflags &= ~MD_spc;
                    443: }
                    444:
                    445: /*
                    446:  * Print markdown syntax elements.
                    447:  * Can also be used for constant strings when neither escaping
                    448:  * nor delimiter handling is required.
                    449:  */
                    450: static void
                    451: md_rawword(const char *s)
                    452: {
                    453:        md_preword();
                    454:
1.8       schwarze  455:        if (*s == '\0')
1.1       schwarze  456:                return;
                    457:
                    458:        if (escflags & ESC_FON) {
                    459:                escflags &= ~ESC_FON;
                    460:                if (*s == '*' && !code_blocks)
                    461:                        fputs("&zwnj;", stdout);
                    462:        }
                    463:
                    464:        while (*s != '\0') {
                    465:                switch(*s) {
                    466:                case '*':
                    467:                        if (s[1] == '\0')
                    468:                                escflags |= ESC_FON;
                    469:                        break;
                    470:                case '[':
                    471:                        escflags |= ESC_SQU;
                    472:                        break;
                    473:                case ']':
                    474:                        escflags |= ESC_HYP;
                    475:                        escflags &= ~ESC_SQU;
                    476:                        break;
                    477:                default:
                    478:                        break;
                    479:                }
                    480:                md_char(*s++);
                    481:        }
1.8       schwarze  482:        if (s[-1] == ' ')
                    483:                escflags |= ESC_EOL;
                    484:        else
                    485:                escflags &= ~ESC_EOL;
1.1       schwarze  486: }
                    487:
                    488: /*
                    489:  * Print text and mdoc(7) syntax elements.
                    490:  */
                    491: static void
                    492: md_word(const char *s)
                    493: {
                    494:        const char      *seq, *prevfont, *currfont, *nextfont;
                    495:        char             c;
                    496:        int              bs, sz, uc;
                    497:
                    498:        /* No spacing before closing delimiters. */
                    499:        if (s[0] != '\0' && s[1] == '\0' &&
                    500:            strchr("!),.:;?]", s[0]) != NULL &&
                    501:            (outflags & MD_spc_force) == 0)
                    502:                outflags &= ~MD_spc;
                    503:
                    504:        md_preword();
                    505:
1.8       schwarze  506:        if (*s == '\0')
                    507:                return;
                    508:
1.1       schwarze  509:        /* No spacing after opening delimiters. */
                    510:        if ((s[0] == '(' || s[0] == '[') && s[1] == '\0')
                    511:                outflags &= ~MD_spc;
                    512:
                    513:        prevfont = currfont = "";
                    514:        while ((c = *s++) != '\0') {
                    515:                bs = 0;
                    516:                switch(c) {
                    517:                case ASCII_NBRSP:
                    518:                        if (code_blocks)
                    519:                                c = ' ';
                    520:                        else {
                    521:                                md_named("nbsp");
                    522:                                c = '\0';
                    523:                        }
                    524:                        break;
                    525:                case ASCII_HYPH:
                    526:                        bs = escflags & ESC_BOL && !code_blocks;
                    527:                        c = '-';
                    528:                        break;
                    529:                case ASCII_BREAK:
                    530:                        continue;
                    531:                case '#':
                    532:                case '+':
                    533:                case '-':
                    534:                        bs = escflags & ESC_BOL && !code_blocks;
                    535:                        break;
                    536:                case '(':
                    537:                        bs = escflags & ESC_HYP && !code_blocks;
                    538:                        break;
                    539:                case ')':
1.14      schwarze  540:                        bs = escflags & ESC_NUM && !code_blocks;
1.1       schwarze  541:                        break;
                    542:                case '*':
                    543:                case '[':
                    544:                case '_':
                    545:                case '`':
                    546:                        bs = !code_blocks;
                    547:                        break;
                    548:                case '.':
                    549:                        bs = escflags & ESC_NUM && !code_blocks;
                    550:                        break;
                    551:                case '<':
                    552:                        if (code_blocks == 0) {
                    553:                                md_named("lt");
                    554:                                c = '\0';
                    555:                        }
                    556:                        break;
                    557:                case '=':
                    558:                        if (escflags & ESC_BOL && !code_blocks) {
                    559:                                md_named("equals");
                    560:                                c = '\0';
                    561:                        }
                    562:                        break;
                    563:                case '>':
                    564:                        if (code_blocks == 0) {
                    565:                                md_named("gt");
                    566:                                c = '\0';
                    567:                        }
                    568:                        break;
                    569:                case '\\':
                    570:                        uc = 0;
                    571:                        nextfont = NULL;
                    572:                        switch (mandoc_escape(&s, &seq, &sz)) {
                    573:                        case ESCAPE_UNICODE:
                    574:                                uc = mchars_num2uc(seq + 1, sz - 1);
                    575:                                break;
                    576:                        case ESCAPE_NUMBERED:
                    577:                                uc = mchars_num2char(seq, sz);
                    578:                                break;
                    579:                        case ESCAPE_SPECIAL:
                    580:                                uc = mchars_spec2cp(seq, sz);
                    581:                                break;
                    582:                        case ESCAPE_FONTBOLD:
                    583:                                nextfont = "**";
                    584:                                break;
                    585:                        case ESCAPE_FONTITALIC:
                    586:                                nextfont = "*";
                    587:                                break;
                    588:                        case ESCAPE_FONTBI:
                    589:                                nextfont = "***";
                    590:                                break;
                    591:                        case ESCAPE_FONT:
                    592:                        case ESCAPE_FONTROMAN:
                    593:                                nextfont = "";
                    594:                                break;
                    595:                        case ESCAPE_FONTPREV:
                    596:                                nextfont = prevfont;
                    597:                                break;
                    598:                        case ESCAPE_NOSPACE:
                    599:                        case ESCAPE_SKIPCHAR:
                    600:                        case ESCAPE_OVERSTRIKE:
                    601:                                /* XXX not implemented */
                    602:                                /* FALLTHROUGH */
                    603:                        case ESCAPE_ERROR:
                    604:                        default:
                    605:                                break;
                    606:                        }
                    607:                        if (nextfont != NULL && !code_blocks) {
                    608:                                if (*currfont != '\0') {
                    609:                                        outflags &= ~MD_spc;
                    610:                                        md_rawword(currfont);
                    611:                                }
                    612:                                prevfont = currfont;
                    613:                                currfont = nextfont;
                    614:                                if (*currfont != '\0') {
                    615:                                        outflags &= ~MD_spc;
                    616:                                        md_rawword(currfont);
                    617:                                }
                    618:                        }
                    619:                        if (uc) {
                    620:                                if ((uc < 0x20 && uc != 0x09) ||
                    621:                                    (uc > 0x7E && uc < 0xA0))
                    622:                                        uc = 0xFFFD;
                    623:                                if (code_blocks) {
                    624:                                        seq = mchars_uc2str(uc);
                    625:                                        fputs(seq, stdout);
                    626:                                        outcount += strlen(seq);
                    627:                                } else {
                    628:                                        printf("&#%d;", uc);
                    629:                                        outcount++;
                    630:                                }
                    631:                                escflags &= ~ESC_FON;
                    632:                        }
                    633:                        c = '\0';
                    634:                        break;
                    635:                case ']':
                    636:                        bs = escflags & ESC_SQU && !code_blocks;
                    637:                        escflags |= ESC_HYP;
                    638:                        break;
                    639:                default:
                    640:                        break;
                    641:                }
                    642:                if (bs)
                    643:                        putchar('\\');
                    644:                md_char(c);
                    645:        }
                    646:        if (*currfont != '\0') {
                    647:                outflags &= ~MD_spc;
                    648:                md_rawword(currfont);
1.8       schwarze  649:        } else if (s[-2] == ' ')
                    650:                escflags |= ESC_EOL;
                    651:        else
                    652:                escflags &= ~ESC_EOL;
1.1       schwarze  653: }
                    654:
                    655: /*
                    656:  * Print a single HTML named character reference.
                    657:  */
                    658: static void
                    659: md_named(const char *s)
                    660: {
                    661:        printf("&%s;", s);
1.8       schwarze  662:        escflags &= ~(ESC_FON | ESC_EOL);
1.1       schwarze  663:        outcount++;
                    664: }
                    665:
                    666: /*
                    667:  * Print a single raw character and maintain certain escape flags.
                    668:  */
                    669: static void
                    670: md_char(unsigned char c)
                    671: {
                    672:        if (c != '\0') {
                    673:                putchar(c);
                    674:                if (c == '*')
                    675:                        escflags |= ESC_FON;
                    676:                else
                    677:                        escflags &= ~ESC_FON;
                    678:                outcount++;
                    679:        }
                    680:        if (c != ']')
                    681:                escflags &= ~ESC_HYP;
                    682:        if (c == ' ' || c == '\t' || c == '>')
                    683:                return;
                    684:        if (isdigit(c) == 0)
                    685:                escflags &= ~ESC_NUM;
                    686:        else if (escflags & ESC_BOL)
                    687:                escflags |= ESC_NUM;
                    688:        escflags &= ~ESC_BOL;
                    689: }
                    690:
                    691: static int
                    692: md_cond_head(struct roff_node *n)
                    693: {
                    694:        return n->type == ROFFT_HEAD;
                    695: }
                    696:
                    697: static int
                    698: md_cond_body(struct roff_node *n)
                    699: {
                    700:        return n->type == ROFFT_BODY;
                    701: }
                    702:
                    703: static int
                    704: md_pre_raw(struct roff_node *n)
                    705: {
                    706:        const char      *prefix;
                    707:
                    708:        if ((prefix = md_acts[n->tok].prefix) != NULL) {
                    709:                md_rawword(prefix);
                    710:                outflags &= ~MD_spc;
1.13      schwarze  711:                if (*prefix == '`')
                    712:                        code_blocks++;
1.1       schwarze  713:        }
                    714:        return 1;
                    715: }
                    716:
                    717: static void
                    718: md_post_raw(struct roff_node *n)
                    719: {
                    720:        const char      *suffix;
                    721:
                    722:        if ((suffix = md_acts[n->tok].suffix) != NULL) {
                    723:                outflags &= ~(MD_spc | MD_nl);
                    724:                md_rawword(suffix);
1.13      schwarze  725:                if (*suffix == '`')
                    726:                        code_blocks--;
1.1       schwarze  727:        }
                    728: }
                    729:
                    730: static int
                    731: md_pre_word(struct roff_node *n)
                    732: {
                    733:        const char      *prefix;
                    734:
                    735:        if ((prefix = md_acts[n->tok].prefix) != NULL) {
                    736:                md_word(prefix);
                    737:                outflags &= ~MD_spc;
                    738:        }
                    739:        return 1;
                    740: }
                    741:
                    742: static void
                    743: md_post_word(struct roff_node *n)
                    744: {
                    745:        const char      *suffix;
                    746:
                    747:        if ((suffix = md_acts[n->tok].suffix) != NULL) {
                    748:                outflags &= ~(MD_spc | MD_nl);
                    749:                md_word(suffix);
                    750:        }
                    751: }
                    752:
                    753: static void
                    754: md_post_pc(struct roff_node *n)
                    755: {
                    756:        md_post_raw(n);
                    757:        if (n->parent->tok != MDOC_Rs)
                    758:                return;
                    759:        if (n->next != NULL) {
                    760:                md_word(",");
                    761:                if (n->prev != NULL &&
                    762:                    n->prev->tok == n->tok &&
                    763:                    n->next->tok == n->tok)
                    764:                        md_word("and");
                    765:        } else {
                    766:                md_word(".");
                    767:                outflags |= MD_nl;
                    768:        }
                    769: }
                    770:
                    771: static int
                    772: md_pre_skip(struct roff_node *n)
                    773: {
                    774:        return 0;
                    775: }
                    776:
                    777: static void
                    778: md_pre_syn(struct roff_node *n)
                    779: {
                    780:        if (n->prev == NULL || ! (n->flags & NODE_SYNPRETTY))
                    781:                return;
                    782:
                    783:        if (n->prev->tok == n->tok &&
                    784:            n->tok != MDOC_Ft &&
                    785:            n->tok != MDOC_Fo &&
                    786:            n->tok != MDOC_Fn) {
                    787:                outflags |= MD_br;
                    788:                return;
                    789:        }
                    790:
                    791:        switch (n->prev->tok) {
                    792:        case MDOC_Fd:
                    793:        case MDOC_Fn:
                    794:        case MDOC_Fo:
                    795:        case MDOC_In:
                    796:        case MDOC_Vt:
                    797:                outflags |= MD_sp;
                    798:                break;
                    799:        case MDOC_Ft:
                    800:                if (n->tok != MDOC_Fn && n->tok != MDOC_Fo) {
                    801:                        outflags |= MD_sp;
                    802:                        break;
                    803:                }
                    804:                /* FALLTHROUGH */
                    805:        default:
                    806:                outflags |= MD_br;
                    807:                break;
                    808:        }
                    809: }
                    810:
                    811: static int
1.5       schwarze  812: md_pre_An(struct roff_node *n)
                    813: {
                    814:        switch (n->norm->An.auth) {
                    815:        case AUTH_split:
                    816:                outflags &= ~MD_An_nosplit;
                    817:                outflags |= MD_An_split;
                    818:                return 0;
                    819:        case AUTH_nosplit:
                    820:                outflags &= ~MD_An_split;
                    821:                outflags |= MD_An_nosplit;
                    822:                return 0;
                    823:        default:
                    824:                if (outflags & MD_An_split)
                    825:                        outflags |= MD_br;
                    826:                else if (n->sec == SEC_AUTHORS &&
                    827:                    ! (outflags & MD_An_nosplit))
                    828:                        outflags |= MD_An_split;
                    829:                return 1;
                    830:        }
                    831: }
                    832:
                    833: static int
1.1       schwarze  834: md_pre_Ap(struct roff_node *n)
                    835: {
                    836:        outflags &= ~MD_spc;
                    837:        md_word("'");
                    838:        outflags &= ~MD_spc;
                    839:        return 0;
                    840: }
                    841:
                    842: static int
                    843: md_pre_Bd(struct roff_node *n)
                    844: {
                    845:        switch (n->norm->Bd.type) {
                    846:        case DISP_unfilled:
                    847:        case DISP_literal:
                    848:                return md_pre_Dl(n);
                    849:        default:
                    850:                return md_pre_D1(n);
                    851:        }
                    852: }
                    853:
                    854: static int
                    855: md_pre_Bk(struct roff_node *n)
                    856: {
                    857:        switch (n->type) {
                    858:        case ROFFT_BLOCK:
                    859:                return 1;
                    860:        case ROFFT_BODY:
                    861:                outflags |= MD_Bk;
                    862:                return 1;
                    863:        default:
                    864:                return 0;
                    865:        }
                    866: }
                    867:
                    868: static void
                    869: md_post_Bk(struct roff_node *n)
                    870: {
                    871:        if (n->type == ROFFT_BODY)
                    872:                outflags &= ~MD_Bk;
                    873: }
                    874:
                    875: static int
                    876: md_pre_Bl(struct roff_node *n)
                    877: {
                    878:        n->norm->Bl.count = 0;
                    879:        if (n->norm->Bl.type == LIST_column)
                    880:                md_pre_Dl(n);
                    881:        outflags |= MD_sp;
                    882:        return 1;
                    883: }
                    884:
                    885: static void
                    886: md_post_Bl(struct roff_node *n)
                    887: {
                    888:        n->norm->Bl.count = 0;
                    889:        if (n->norm->Bl.type == LIST_column)
                    890:                md_post_D1(n);
                    891:        outflags |= MD_sp;
                    892: }
                    893:
                    894: static int
                    895: md_pre_D1(struct roff_node *n)
                    896: {
                    897:        /*
                    898:         * Markdown blockquote syntax does not work inside code blocks.
                    899:         * The best we can do is fall back to another nested code block.
                    900:         */
                    901:        if (code_blocks) {
                    902:                md_stack('\t');
                    903:                code_blocks++;
                    904:        } else {
                    905:                md_stack('>');
                    906:                quote_blocks++;
                    907:        }
                    908:        outflags |= MD_sp;
                    909:        return 1;
                    910: }
                    911:
                    912: static void
                    913: md_post_D1(struct roff_node *n)
                    914: {
                    915:        md_stack((char)-1);
                    916:        if (code_blocks)
                    917:                code_blocks--;
                    918:        else
                    919:                quote_blocks--;
                    920:        outflags |= MD_sp;
                    921: }
                    922:
                    923: static int
                    924: md_pre_Dl(struct roff_node *n)
                    925: {
                    926:        /*
                    927:         * Markdown code block syntax does not work inside blockquotes.
                    928:         * The best we can do is fall back to another nested blockquote.
                    929:         */
                    930:        if (quote_blocks) {
                    931:                md_stack('>');
                    932:                quote_blocks++;
                    933:        } else {
                    934:                md_stack('\t');
                    935:                code_blocks++;
                    936:        }
                    937:        outflags |= MD_sp;
                    938:        return 1;
                    939: }
                    940:
                    941: static int
                    942: md_pre_En(struct roff_node *n)
                    943: {
                    944:        if (n->norm->Es == NULL ||
                    945:            n->norm->Es->child == NULL)
                    946:                return 1;
                    947:
                    948:        md_word(n->norm->Es->child->string);
                    949:        outflags &= ~MD_spc;
                    950:        return 1;
                    951: }
                    952:
                    953: static void
                    954: md_post_En(struct roff_node *n)
                    955: {
                    956:        if (n->norm->Es == NULL ||
                    957:            n->norm->Es->child == NULL ||
                    958:            n->norm->Es->child->next == NULL)
                    959:                return;
                    960:
                    961:        outflags &= ~MD_spc;
                    962:        md_word(n->norm->Es->child->next->string);
                    963: }
                    964:
                    965: static int
                    966: md_pre_Eo(struct roff_node *n)
                    967: {
                    968:        if (n->end == ENDBODY_NOT &&
                    969:            n->parent->head->child == NULL &&
                    970:            n->child != NULL &&
                    971:            n->child->end != ENDBODY_NOT)
                    972:                md_preword();
                    973:        else if (n->end != ENDBODY_NOT ? n->child != NULL :
                    974:            n->parent->head->child != NULL && (n->child != NULL ||
                    975:            (n->parent->tail != NULL && n->parent->tail->child != NULL)))
                    976:                outflags &= ~(MD_spc | MD_nl);
                    977:        return 1;
                    978: }
                    979:
                    980: static void
                    981: md_post_Eo(struct roff_node *n)
                    982: {
                    983:        if (n->end != ENDBODY_NOT) {
                    984:                outflags |= MD_spc;
                    985:                return;
                    986:        }
                    987:
1.7       schwarze  988:        if (n->child == NULL && n->parent->head->child == NULL)
                    989:                return;
1.1       schwarze  990:
1.7       schwarze  991:        if (n->parent->tail != NULL && n->parent->tail->child != NULL)
1.1       schwarze  992:                outflags &= ~MD_spc;
1.7       schwarze  993:         else
1.1       schwarze  994:                outflags |= MD_spc;
                    995: }
                    996:
                    997: static int
                    998: md_pre_Fa(struct roff_node *n)
                    999: {
                   1000:        int      am_Fa;
                   1001:
                   1002:        am_Fa = n->tok == MDOC_Fa;
                   1003:
                   1004:        if (am_Fa)
                   1005:                n = n->child;
                   1006:
                   1007:        while (n != NULL) {
                   1008:                md_rawword("*");
                   1009:                outflags &= ~MD_spc;
                   1010:                md_node(n);
                   1011:                outflags &= ~MD_spc;
                   1012:                md_rawword("*");
                   1013:                if ((n = n->next) != NULL)
                   1014:                        md_word(",");
                   1015:        }
                   1016:        return 0;
                   1017: }
                   1018:
                   1019: static void
                   1020: md_post_Fa(struct roff_node *n)
                   1021: {
                   1022:        if (n->next != NULL && n->next->tok == MDOC_Fa)
                   1023:                md_word(",");
                   1024: }
                   1025:
                   1026: static int
                   1027: md_pre_Fd(struct roff_node *n)
                   1028: {
                   1029:        md_pre_syn(n);
                   1030:        md_pre_raw(n);
                   1031:        return 1;
                   1032: }
                   1033:
                   1034: static void
                   1035: md_post_Fd(struct roff_node *n)
                   1036: {
                   1037:        md_post_raw(n);
                   1038:        outflags |= MD_br;
1.6       schwarze 1039: }
                   1040:
                   1041: static void
                   1042: md_post_Fl(struct roff_node *n)
                   1043: {
                   1044:        md_post_raw(n);
                   1045:        if (n->child == NULL && n->next != NULL &&
                   1046:            n->next->type != ROFFT_TEXT && !(n->next->flags & NODE_LINE))
                   1047:                outflags &= ~MD_spc;
1.1       schwarze 1048: }
                   1049:
                   1050: static int
                   1051: md_pre_Fn(struct roff_node *n)
                   1052: {
                   1053:        md_pre_syn(n);
                   1054:
                   1055:        if ((n = n->child) == NULL)
                   1056:                return 0;
                   1057:
                   1058:        md_rawword("**");
                   1059:        outflags &= ~MD_spc;
                   1060:        md_node(n);
                   1061:        outflags &= ~MD_spc;
                   1062:        md_rawword("**");
                   1063:        outflags &= ~MD_spc;
                   1064:        md_word("(");
                   1065:
                   1066:        if ((n = n->next) != NULL)
                   1067:                md_pre_Fa(n);
                   1068:        return 0;
                   1069: }
                   1070:
                   1071: static void
                   1072: md_post_Fn(struct roff_node *n)
                   1073: {
                   1074:        md_word(")");
                   1075:        if (n->flags & NODE_SYNPRETTY) {
                   1076:                md_word(";");
                   1077:                outflags |= MD_sp;
                   1078:        }
                   1079: }
                   1080:
                   1081: static int
                   1082: md_pre_Fo(struct roff_node *n)
                   1083: {
                   1084:        switch (n->type) {
                   1085:        case ROFFT_BLOCK:
                   1086:                md_pre_syn(n);
                   1087:                break;
                   1088:        case ROFFT_HEAD:
                   1089:                if (n->child == NULL)
                   1090:                        return 0;
                   1091:                md_pre_raw(n);
                   1092:                break;
                   1093:        case ROFFT_BODY:
                   1094:                outflags &= ~(MD_spc | MD_nl);
                   1095:                md_word("(");
                   1096:                break;
                   1097:        default:
                   1098:                break;
                   1099:        }
                   1100:        return 1;
                   1101: }
                   1102:
                   1103: static void
                   1104: md_post_Fo(struct roff_node *n)
                   1105: {
                   1106:        switch (n->type) {
                   1107:        case ROFFT_HEAD:
                   1108:                if (n->child != NULL)
                   1109:                        md_post_raw(n);
                   1110:                break;
                   1111:        case ROFFT_BODY:
                   1112:                md_post_Fn(n);
                   1113:                break;
                   1114:        default:
                   1115:                break;
                   1116:        }
                   1117: }
                   1118:
                   1119: static int
                   1120: md_pre_In(struct roff_node *n)
                   1121: {
                   1122:        if (n->flags & NODE_SYNPRETTY) {
                   1123:                md_pre_syn(n);
1.4       schwarze 1124:                md_rawword("**");
1.1       schwarze 1125:                outflags &= ~MD_spc;
                   1126:                md_word("#include <");
                   1127:        } else {
                   1128:                md_word("<");
                   1129:                outflags &= ~MD_spc;
1.4       schwarze 1130:                md_rawword("*");
1.1       schwarze 1131:        }
1.4       schwarze 1132:        outflags &= ~MD_spc;
1.1       schwarze 1133:        return 1;
                   1134: }
                   1135:
                   1136: static void
                   1137: md_post_In(struct roff_node *n)
                   1138: {
                   1139:        if (n->flags & NODE_SYNPRETTY) {
                   1140:                outflags &= ~MD_spc;
1.4       schwarze 1141:                md_rawword(">**");
1.1       schwarze 1142:                outflags |= MD_nl;
                   1143:        } else {
                   1144:                outflags &= ~MD_spc;
1.4       schwarze 1145:                md_rawword("*>");
1.1       schwarze 1146:        }
                   1147: }
                   1148:
                   1149: static int
                   1150: md_pre_It(struct roff_node *n)
                   1151: {
                   1152:        struct roff_node        *bln;
                   1153:
                   1154:        switch (n->type) {
                   1155:        case ROFFT_BLOCK:
                   1156:                return 1;
                   1157:
                   1158:        case ROFFT_HEAD:
                   1159:                bln = n->parent->parent;
1.10      schwarze 1160:                if (bln->norm->Bl.comp == 0 &&
                   1161:                    bln->norm->Bl.type != LIST_column)
1.1       schwarze 1162:                        outflags |= MD_sp;
                   1163:                outflags |= MD_nl;
                   1164:
                   1165:                switch (bln->norm->Bl.type) {
                   1166:                case LIST_item:
                   1167:                        outflags |= MD_br;
                   1168:                        return 0;
                   1169:                case LIST_inset:
                   1170:                case LIST_diag:
                   1171:                case LIST_ohang:
                   1172:                        outflags |= MD_br;
                   1173:                        return 1;
                   1174:                case LIST_tag:
                   1175:                case LIST_hang:
                   1176:                        outflags |= MD_sp;
                   1177:                        return 1;
                   1178:                case LIST_bullet:
                   1179:                        md_rawword("*\t");
                   1180:                        break;
                   1181:                case LIST_dash:
                   1182:                case LIST_hyphen:
                   1183:                        md_rawword("-\t");
                   1184:                        break;
                   1185:                case LIST_enum:
                   1186:                        md_preword();
1.11      schwarze 1187:                        if (bln->norm->Bl.count < 99)
                   1188:                                bln->norm->Bl.count++;
                   1189:                        printf("%d.\t", bln->norm->Bl.count);
1.1       schwarze 1190:                        escflags &= ~ESC_FON;
                   1191:                        break;
1.10      schwarze 1192:                case LIST_column:
                   1193:                        outflags |= MD_br;
                   1194:                        return 0;
1.1       schwarze 1195:                default:
                   1196:                        return 0;
                   1197:                }
                   1198:                outflags &= ~MD_spc;
                   1199:                outflags |= MD_nonl;
                   1200:                outcount = 0;
                   1201:                md_stack('\t');
                   1202:                if (code_blocks || quote_blocks)
                   1203:                        list_blocks++;
                   1204:                return 0;
                   1205:
                   1206:        case ROFFT_BODY:
                   1207:                bln = n->parent->parent;
                   1208:                switch (bln->norm->Bl.type) {
                   1209:                case LIST_ohang:
                   1210:                        outflags |= MD_br;
                   1211:                        break;
                   1212:                case LIST_tag:
                   1213:                case LIST_hang:
                   1214:                        md_pre_D1(n);
                   1215:                        break;
                   1216:                default:
                   1217:                        break;
                   1218:                }
                   1219:                return 1;
                   1220:
                   1221:        default:
                   1222:                return 0;
                   1223:        }
                   1224: }
                   1225:
                   1226: static void
                   1227: md_post_It(struct roff_node *n)
                   1228: {
                   1229:        struct roff_node        *bln;
                   1230:        int                      i, nc;
                   1231:
                   1232:        if (n->type != ROFFT_BODY)
                   1233:                return;
                   1234:
                   1235:        bln = n->parent->parent;
                   1236:        switch (bln->norm->Bl.type) {
                   1237:        case LIST_bullet:
                   1238:        case LIST_dash:
                   1239:        case LIST_hyphen:
                   1240:        case LIST_enum:
                   1241:                md_stack((char)-1);
                   1242:                if (code_blocks || quote_blocks)
                   1243:                        list_blocks--;
                   1244:                break;
                   1245:        case LIST_tag:
                   1246:        case LIST_hang:
                   1247:                md_post_D1(n);
                   1248:                break;
                   1249:
                   1250:        case LIST_column:
                   1251:                if (n->next == NULL)
                   1252:                        break;
                   1253:
                   1254:                /* Calculate the array index of the current column. */
                   1255:
                   1256:                i = 0;
                   1257:                while ((n = n->prev) != NULL && n->type != ROFFT_HEAD)
                   1258:                        i++;
                   1259:
                   1260:                /*
                   1261:                 * If a width was specified for this column,
                   1262:                 * subtract what printed, and
                   1263:                 * add the same spacing as in mdoc_term.c.
                   1264:                 */
                   1265:
                   1266:                nc = bln->norm->Bl.ncols;
                   1267:                i = i < nc ? strlen(bln->norm->Bl.cols[i]) - outcount +
                   1268:                    (nc < 5 ? 4 : nc == 5 ? 3 : 1) : 1;
                   1269:                if (i < 1)
                   1270:                        i = 1;
                   1271:                while (i-- > 0)
                   1272:                        putchar(' ');
                   1273:
                   1274:                outflags &= ~MD_spc;
                   1275:                escflags &= ~ESC_FON;
                   1276:                outcount = 0;
                   1277:                break;
                   1278:
                   1279:        default:
                   1280:                break;
                   1281:        }
                   1282: }
                   1283:
                   1284: static void
                   1285: md_post_Lb(struct roff_node *n)
                   1286: {
                   1287:        if (n->sec == SEC_LIBRARY)
                   1288:                outflags |= MD_br;
                   1289: }
                   1290:
1.15      schwarze 1291: static void
                   1292: md_uri(const char *s)
                   1293: {
                   1294:        while (*s != '\0') {
                   1295:                if (strchr("%()<>", *s) != NULL) {
                   1296:                        printf("%%%2.2hhX", *s);
                   1297:                        outcount += 3;
                   1298:                } else {
                   1299:                        putchar(*s);
                   1300:                        outcount++;
                   1301:                }
                   1302:                s++;
                   1303:        }
                   1304: }
                   1305:
1.1       schwarze 1306: static int
                   1307: md_pre_Lk(struct roff_node *n)
                   1308: {
1.22    ! schwarze 1309:        const struct roff_node *link, *descr, *punct;
1.1       schwarze 1310:
                   1311:        if ((link = n->child) == NULL)
                   1312:                return 0;
                   1313:
1.22    ! schwarze 1314:        /* Find beginning of trailing punctuation. */
        !          1315:        punct = n->last;
        !          1316:        while (punct != link && punct->flags & NODE_DELIMC)
        !          1317:                punct = punct->prev;
        !          1318:        punct = punct->next;
        !          1319:
1.16      schwarze 1320:        /* Link text. */
                   1321:        descr = link->next;
1.22    ! schwarze 1322:        if (descr == punct)
1.16      schwarze 1323:                descr = link;  /* no text */
1.15      schwarze 1324:        md_rawword("[");
                   1325:        outflags &= ~MD_spc;
                   1326:        do {
                   1327:                md_word(descr->string);
1.16      schwarze 1328:                descr = descr->next;
1.22    ! schwarze 1329:        } while (descr != punct);
1.15      schwarze 1330:        outflags &= ~MD_spc;
1.16      schwarze 1331:
                   1332:        /* Link target. */
1.15      schwarze 1333:        md_rawword("](");
                   1334:        md_uri(link->string);
                   1335:        outflags &= ~MD_spc;
                   1336:        md_rawword(")");
1.16      schwarze 1337:
                   1338:        /* Trailing punctuation. */
1.22    ! schwarze 1339:        while (punct != NULL) {
        !          1340:                md_word(punct->string);
        !          1341:                punct = punct->next;
1.16      schwarze 1342:        }
1.15      schwarze 1343:        return 0;
                   1344: }
                   1345:
                   1346: static int
                   1347: md_pre_Mt(struct roff_node *n)
                   1348: {
                   1349:        const struct roff_node *nch;
1.1       schwarze 1350:
1.15      schwarze 1351:        md_rawword("[");
                   1352:        outflags &= ~MD_spc;
                   1353:        for (nch = n->child; nch != NULL; nch = nch->next)
                   1354:                md_word(nch->string);
                   1355:        outflags &= ~MD_spc;
                   1356:        md_rawword("](mailto:");
                   1357:        for (nch = n->child; nch != NULL; nch = nch->next) {
                   1358:                md_uri(nch->string);
                   1359:                if (nch->next != NULL) {
                   1360:                        putchar(' ');
1.3       schwarze 1361:                        outcount++;
                   1362:                }
                   1363:        }
1.1       schwarze 1364:        outflags &= ~MD_spc;
1.15      schwarze 1365:        md_rawword(")");
1.1       schwarze 1366:        return 0;
                   1367: }
                   1368:
                   1369: static int
                   1370: md_pre_Nd(struct roff_node *n)
                   1371: {
                   1372:        outflags &= ~MD_nl;
                   1373:        outflags |= MD_spc;
                   1374:        md_word("-");
                   1375:        return 1;
                   1376: }
                   1377:
                   1378: static int
                   1379: md_pre_Nm(struct roff_node *n)
                   1380: {
                   1381:        switch (n->type) {
                   1382:        case ROFFT_BLOCK:
                   1383:                outflags |= MD_Bk;
                   1384:                md_pre_syn(n);
                   1385:                break;
                   1386:        case ROFFT_HEAD:
                   1387:        case ROFFT_ELEM:
                   1388:                md_pre_raw(n);
                   1389:                break;
                   1390:        default:
                   1391:                break;
                   1392:        }
                   1393:        return 1;
                   1394: }
                   1395:
                   1396: static void
                   1397: md_post_Nm(struct roff_node *n)
                   1398: {
                   1399:        switch (n->type) {
                   1400:        case ROFFT_BLOCK:
                   1401:                outflags &= ~MD_Bk;
                   1402:                break;
                   1403:        case ROFFT_HEAD:
                   1404:        case ROFFT_ELEM:
                   1405:                md_post_raw(n);
                   1406:                break;
                   1407:        default:
                   1408:                break;
                   1409:        }
                   1410: }
                   1411:
                   1412: static int
                   1413: md_pre_No(struct roff_node *n)
                   1414: {
                   1415:        outflags |= MD_spc_force;
                   1416:        return 1;
                   1417: }
                   1418:
                   1419: static int
                   1420: md_pre_Ns(struct roff_node *n)
                   1421: {
                   1422:        outflags &= ~MD_spc;
                   1423:        return 0;
                   1424: }
                   1425:
                   1426: static void
                   1427: md_post_Pf(struct roff_node *n)
                   1428: {
                   1429:        if (n->next != NULL && (n->next->flags & NODE_LINE) == 0)
                   1430:                outflags &= ~MD_spc;
                   1431: }
                   1432:
                   1433: static int
                   1434: md_pre_Pp(struct roff_node *n)
                   1435: {
                   1436:        outflags |= MD_sp;
                   1437:        return 0;
                   1438: }
                   1439:
                   1440: static int
                   1441: md_pre_Rs(struct roff_node *n)
                   1442: {
                   1443:        if (n->sec == SEC_SEE_ALSO)
                   1444:                outflags |= MD_sp;
                   1445:        return 1;
                   1446: }
                   1447:
                   1448: static int
                   1449: md_pre_Sh(struct roff_node *n)
                   1450: {
                   1451:        switch (n->type) {
1.5       schwarze 1452:        case ROFFT_BLOCK:
                   1453:                if (n->sec == SEC_AUTHORS)
                   1454:                        outflags &= ~(MD_An_split | MD_An_nosplit);
                   1455:                break;
1.1       schwarze 1456:        case ROFFT_HEAD:
                   1457:                outflags |= MD_sp;
                   1458:                md_rawword(n->tok == MDOC_Sh ? "#" : "##");
                   1459:                break;
                   1460:        case ROFFT_BODY:
                   1461:                outflags |= MD_sp;
                   1462:                break;
                   1463:        default:
                   1464:                break;
                   1465:        }
                   1466:        return 1;
                   1467: }
                   1468:
                   1469: static int
                   1470: md_pre_Sm(struct roff_node *n)
                   1471: {
                   1472:        if (n->child == NULL)
                   1473:                outflags ^= MD_Sm;
                   1474:        else if (strcmp("on", n->child->string) == 0)
                   1475:                outflags |= MD_Sm;
                   1476:        else
                   1477:                outflags &= ~MD_Sm;
                   1478:
                   1479:        if (outflags & MD_Sm)
                   1480:                outflags |= MD_spc;
                   1481:
                   1482:        return 0;
                   1483: }
                   1484:
                   1485: static int
                   1486: md_pre_Vt(struct roff_node *n)
                   1487: {
                   1488:        switch (n->type) {
                   1489:        case ROFFT_BLOCK:
                   1490:                md_pre_syn(n);
                   1491:                return 1;
                   1492:        case ROFFT_BODY:
                   1493:        case ROFFT_ELEM:
                   1494:                md_pre_raw(n);
                   1495:                return 1;
                   1496:        default:
                   1497:                return 0;
                   1498:        }
                   1499: }
                   1500:
                   1501: static void
                   1502: md_post_Vt(struct roff_node *n)
                   1503: {
                   1504:        switch (n->type) {
                   1505:        case ROFFT_BODY:
                   1506:        case ROFFT_ELEM:
                   1507:                md_post_raw(n);
                   1508:                break;
                   1509:        default:
                   1510:                break;
                   1511:        }
                   1512: }
                   1513:
                   1514: static int
                   1515: md_pre_Xr(struct roff_node *n)
                   1516: {
                   1517:        n = n->child;
                   1518:        if (n == NULL)
                   1519:                return 0;
                   1520:        md_node(n);
                   1521:        n = n->next;
                   1522:        if (n == NULL)
                   1523:                return 0;
                   1524:        outflags &= ~MD_spc;
                   1525:        md_word("(");
                   1526:        md_node(n);
                   1527:        md_word(")");
                   1528:        return 0;
                   1529: }
                   1530:
                   1531: static int
                   1532: md_pre__T(struct roff_node *n)
                   1533: {
1.2       schwarze 1534:        if (n->parent->tok == MDOC_Rs && n->parent->norm->Rs.quote_T)
1.1       schwarze 1535:                md_word("\"");
                   1536:        else
                   1537:                md_rawword("*");
                   1538:        outflags &= ~MD_spc;
                   1539:        return 1;
                   1540: }
                   1541:
                   1542: static void
                   1543: md_post__T(struct roff_node *n)
                   1544: {
                   1545:        outflags &= ~MD_spc;
1.2       schwarze 1546:        if (n->parent->tok == MDOC_Rs && n->parent->norm->Rs.quote_T)
1.1       schwarze 1547:                md_word("\"");
                   1548:        else
                   1549:                md_rawword("*");
                   1550:        md_post_pc(n);
                   1551: }
                   1552:
                   1553: static int
                   1554: md_pre_br(struct roff_node *n)
                   1555: {
                   1556:        outflags |= MD_br;
                   1557:        return 0;
                   1558: }

CVSweb