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