contrib/mandoc/mdoc_markdown.c

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