]> git.cameronkatri.com Git - mandoc.git/blob - mdoc_markdown.c
git.ckatri.com / mandoc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
add arch.o
[mandoc.git] / mdoc_markdown.c
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("&nbsp;", 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("&zwnj;", 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 }
A git conversion mirror of mandoc.bsd.lv