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