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