1 /* $Id: mdoc_man.c,v 1.122 2017/06/14 22:51:25 schwarze Exp $ */
2 /*
3 * Copyright (c) 2011-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 AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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 "config.h"
18
19 #include <sys/types.h>
20
21 #include <assert.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "mandoc_aux.h"
27 #include "mandoc.h"
28 #include "roff.h"
29 #include "mdoc.h"
30 #include "man.h"
31 #include "out.h"
32 #include "main.h"
33
34 #define DECL_ARGS const struct roff_meta *meta, struct roff_node *n
35
36 typedef int (*int_fp)(DECL_ARGS);
37 typedef void (*void_fp)(DECL_ARGS);
38
39 struct manact {
40 int_fp cond; /* DON'T run actions */
41 int_fp pre; /* pre-node action */
42 void_fp post; /* post-node action */
43 const char *prefix; /* pre-node string constant */
44 const char *suffix; /* post-node string constant */
45 };
46
47 static int cond_body(DECL_ARGS);
48 static int cond_head(DECL_ARGS);
49 static void font_push(char);
50 static void font_pop(void);
51 static int man_strlen(const char *);
52 static void mid_it(void);
53 static void post__t(DECL_ARGS);
54 static void post_aq(DECL_ARGS);
55 static void post_bd(DECL_ARGS);
56 static void post_bf(DECL_ARGS);
57 static void post_bk(DECL_ARGS);
58 static void post_bl(DECL_ARGS);
59 static void post_dl(DECL_ARGS);
60 static void post_en(DECL_ARGS);
61 static void post_enc(DECL_ARGS);
62 static void post_eo(DECL_ARGS);
63 static void post_fa(DECL_ARGS);
64 static void post_fd(DECL_ARGS);
65 static void post_fl(DECL_ARGS);
66 static void post_fn(DECL_ARGS);
67 static void post_fo(DECL_ARGS);
68 static void post_font(DECL_ARGS);
69 static void post_in(DECL_ARGS);
70 static void post_it(DECL_ARGS);
71 static void post_lb(DECL_ARGS);
72 static void post_nm(DECL_ARGS);
73 static void post_percent(DECL_ARGS);
74 static void post_pf(DECL_ARGS);
75 static void post_sect(DECL_ARGS);
76 static void post_vt(DECL_ARGS);
77 static int pre__t(DECL_ARGS);
78 static int pre_an(DECL_ARGS);
79 static int pre_ap(DECL_ARGS);
80 static int pre_aq(DECL_ARGS);
81 static int pre_bd(DECL_ARGS);
82 static int pre_bf(DECL_ARGS);
83 static int pre_bk(DECL_ARGS);
84 static int pre_bl(DECL_ARGS);
85 static void pre_br(DECL_ARGS);
86 static int pre_dl(DECL_ARGS);
87 static int pre_en(DECL_ARGS);
88 static int pre_enc(DECL_ARGS);
89 static int pre_em(DECL_ARGS);
90 static int pre_skip(DECL_ARGS);
91 static int pre_eo(DECL_ARGS);
92 static int pre_ex(DECL_ARGS);
93 static int pre_fa(DECL_ARGS);
94 static int pre_fd(DECL_ARGS);
95 static int pre_fl(DECL_ARGS);
96 static int pre_fn(DECL_ARGS);
97 static int pre_fo(DECL_ARGS);
98 static void pre_ft(DECL_ARGS);
99 static int pre_Ft(DECL_ARGS);
100 static int pre_in(DECL_ARGS);
101 static int pre_it(DECL_ARGS);
102 static int pre_lk(DECL_ARGS);
103 static int pre_li(DECL_ARGS);
104 static int pre_nm(DECL_ARGS);
105 static int pre_no(DECL_ARGS);
106 static int pre_ns(DECL_ARGS);
107 static void pre_onearg(DECL_ARGS);
108 static int pre_pp(DECL_ARGS);
109 static int pre_rs(DECL_ARGS);
110 static int pre_sm(DECL_ARGS);
111 static void pre_sp(DECL_ARGS);
112 static int pre_sect(DECL_ARGS);
113 static int pre_sy(DECL_ARGS);
114 static void pre_syn(const struct roff_node *);
115 static void pre_ta(DECL_ARGS);
116 static int pre_vt(DECL_ARGS);
117 static int pre_xr(DECL_ARGS);
118 static void print_word(const char *);
119 static void print_line(const char *, int);
120 static void print_block(const char *, int);
121 static void print_offs(const char *, int);
122 static void print_width(const struct mdoc_bl *,
123 const struct roff_node *);
124 static void print_count(int *);
125 static void print_node(DECL_ARGS);
126
127 static const void_fp roff_manacts[ROFF_MAX] = {
128 pre_br, /* br */
129 pre_onearg, /* ce */
130 pre_ft, /* ft */
131 pre_onearg, /* ll */
132 pre_onearg, /* mc */
133 pre_onearg, /* po */
134 pre_onearg, /* rj */
135 pre_sp, /* sp */
136 pre_ta, /* ta */
137 pre_onearg, /* ti */
138 };
139
140 static const struct manact __manacts[MDOC_MAX - MDOC_Dd] = {
141 { NULL, NULL, NULL, NULL, NULL }, /* Dd */
142 { NULL, NULL, NULL, NULL, NULL }, /* Dt */
143 { NULL, NULL, NULL, NULL, NULL }, /* Os */
144 { NULL, pre_sect, post_sect, ".SH", NULL }, /* Sh */
145 { NULL, pre_sect, post_sect, ".SS", NULL }, /* Ss */
146 { NULL, pre_pp, NULL, NULL, NULL }, /* Pp */
147 { cond_body, pre_dl, post_dl, NULL, NULL }, /* D1 */
148 { cond_body, pre_dl, post_dl, NULL, NULL }, /* Dl */
149 { cond_body, pre_bd, post_bd, NULL, NULL }, /* Bd */
150 { NULL, NULL, NULL, NULL, NULL }, /* Ed */
151 { cond_body, pre_bl, post_bl, NULL, NULL }, /* Bl */
152 { NULL, NULL, NULL, NULL, NULL }, /* El */
153 { NULL, pre_it, post_it, NULL, NULL }, /* It */
154 { NULL, pre_em, post_font, NULL, NULL }, /* Ad */
155 { NULL, pre_an, NULL, NULL, NULL }, /* An */
156 { NULL, pre_ap, NULL, NULL, NULL }, /* Ap */
157 { NULL, pre_em, post_font, NULL, NULL }, /* Ar */
158 { NULL, pre_sy, post_font, NULL, NULL }, /* Cd */
159 { NULL, pre_sy, post_font, NULL, NULL }, /* Cm */
160 { NULL, pre_li, post_font, NULL, NULL }, /* Dv */
161 { NULL, pre_li, post_font, NULL, NULL }, /* Er */
162 { NULL, pre_li, post_font, NULL, NULL }, /* Ev */
163 { NULL, pre_ex, NULL, NULL, NULL }, /* Ex */
164 { NULL, pre_fa, post_fa, NULL, NULL }, /* Fa */
165 { NULL, pre_fd, post_fd, NULL, NULL }, /* Fd */
166 { NULL, pre_fl, post_fl, NULL, NULL }, /* Fl */
167 { NULL, pre_fn, post_fn, NULL, NULL }, /* Fn */
168 { NULL, pre_Ft, post_font, NULL, NULL }, /* Ft */
169 { NULL, pre_sy, post_font, NULL, NULL }, /* Ic */
170 { NULL, pre_in, post_in, NULL, NULL }, /* In */
171 { NULL, pre_li, post_font, NULL, NULL }, /* Li */
172 { cond_head, pre_enc, NULL, "\\- ", NULL }, /* Nd */
173 { NULL, pre_nm, post_nm, NULL, NULL }, /* Nm */
174 { cond_body, pre_enc, post_enc, "[", "]" }, /* Op */
175 { NULL, pre_Ft, post_font, NULL, NULL }, /* Ot */
176 { NULL, pre_em, post_font, NULL, NULL }, /* Pa */
177 { NULL, pre_ex, NULL, NULL, NULL }, /* Rv */
178 { NULL, NULL, NULL, NULL, NULL }, /* St */
179 { NULL, pre_em, post_font, NULL, NULL }, /* Va */
180 { NULL, pre_vt, post_vt, NULL, NULL }, /* Vt */
181 { NULL, pre_xr, NULL, NULL, NULL }, /* Xr */
182 { NULL, NULL, post_percent, NULL, NULL }, /* %A */
183 { NULL, pre_em, post_percent, NULL, NULL }, /* %B */
184 { NULL, NULL, post_percent, NULL, NULL }, /* %D */
185 { NULL, pre_em, post_percent, NULL, NULL }, /* %I */
186 { NULL, pre_em, post_percent, NULL, NULL }, /* %J */
187 { NULL, NULL, post_percent, NULL, NULL }, /* %N */
188 { NULL, NULL, post_percent, NULL, NULL }, /* %O */
189 { NULL, NULL, post_percent, NULL, NULL }, /* %P */
190 { NULL, NULL, post_percent, NULL, NULL }, /* %R */
191 { NULL, pre__t, post__t, NULL, NULL }, /* %T */
192 { NULL, NULL, post_percent, NULL, NULL }, /* %V */
193 { NULL, NULL, NULL, NULL, NULL }, /* Ac */
194 { cond_body, pre_aq, post_aq, NULL, NULL }, /* Ao */
195 { cond_body, pre_aq, post_aq, NULL, NULL }, /* Aq */
196 { NULL, NULL, NULL, NULL, NULL }, /* At */
197 { NULL, NULL, NULL, NULL, NULL }, /* Bc */
198 { NULL, pre_bf, post_bf, NULL, NULL }, /* Bf */
199 { cond_body, pre_enc, post_enc, "[", "]" }, /* Bo */
200 { cond_body, pre_enc, post_enc, "[", "]" }, /* Bq */
201 { NULL, pre_bk, post_bk, NULL, NULL }, /* Bsx */
202 { NULL, pre_bk, post_bk, NULL, NULL }, /* Bx */
203 { NULL, pre_skip, NULL, NULL, NULL }, /* Db */
204 { NULL, NULL, NULL, NULL, NULL }, /* Dc */
205 { cond_body, pre_enc, post_enc, "\\(Lq", "\\(Rq" }, /* Do */
206 { cond_body, pre_enc, post_enc, "\\(Lq", "\\(Rq" }, /* Dq */
207 { NULL, NULL, NULL, NULL, NULL }, /* Ec */
208 { NULL, NULL, NULL, NULL, NULL }, /* Ef */
209 { NULL, pre_em, post_font, NULL, NULL }, /* Em */
210 { cond_body, pre_eo, post_eo, NULL, NULL }, /* Eo */
211 { NULL, pre_bk, post_bk, NULL, NULL }, /* Fx */
212 { NULL, pre_sy, post_font, NULL, NULL }, /* Ms */
213 { NULL, pre_no, NULL, NULL, NULL }, /* No */
214 { NULL, pre_ns, NULL, NULL, NULL }, /* Ns */
215 { NULL, pre_bk, post_bk, NULL, NULL }, /* Nx */
216 { NULL, pre_bk, post_bk, NULL, NULL }, /* Ox */
217 { NULL, NULL, NULL, NULL, NULL }, /* Pc */
218 { NULL, NULL, post_pf, NULL, NULL }, /* Pf */
219 { cond_body, pre_enc, post_enc, "(", ")" }, /* Po */
220 { cond_body, pre_enc, post_enc, "(", ")" }, /* Pq */
221 { NULL, NULL, NULL, NULL, NULL }, /* Qc */
222 { cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* Ql */
223 { cond_body, pre_enc, post_enc, "\"", "\"" }, /* Qo */
224 { cond_body, pre_enc, post_enc, "\"", "\"" }, /* Qq */
225 { NULL, NULL, NULL, NULL, NULL }, /* Re */
226 { cond_body, pre_rs, NULL, NULL, NULL }, /* Rs */
227 { NULL, NULL, NULL, NULL, NULL }, /* Sc */
228 { cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* So */
229 { cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* Sq */
230 { NULL, pre_sm, NULL, NULL, NULL }, /* Sm */
231 { NULL, pre_em, post_font, NULL, NULL }, /* Sx */
232 { NULL, pre_sy, post_font, NULL, NULL }, /* Sy */
233 { NULL, pre_li, post_font, NULL, NULL }, /* Tn */
234 { NULL, NULL, NULL, NULL, NULL }, /* Ux */
235 { NULL, NULL, NULL, NULL, NULL }, /* Xc */
236 { NULL, NULL, NULL, NULL, NULL }, /* Xo */
237 { NULL, pre_fo, post_fo, NULL, NULL }, /* Fo */
238 { NULL, NULL, NULL, NULL, NULL }, /* Fc */
239 { cond_body, pre_enc, post_enc, "[", "]" }, /* Oo */
240 { NULL, NULL, NULL, NULL, NULL }, /* Oc */
241 { NULL, pre_bk, post_bk, NULL, NULL }, /* Bk */
242 { NULL, NULL, NULL, NULL, NULL }, /* Ek */
243 { NULL, NULL, NULL, NULL, NULL }, /* Bt */
244 { NULL, NULL, NULL, NULL, NULL }, /* Hf */
245 { NULL, pre_em, post_font, NULL, NULL }, /* Fr */
246 { NULL, NULL, NULL, NULL, NULL }, /* Ud */
247 { NULL, NULL, post_lb, NULL, NULL }, /* Lb */
248 { NULL, pre_pp, NULL, NULL, NULL }, /* Lp */
249 { NULL, pre_lk, NULL, NULL, NULL }, /* Lk */
250 { NULL, pre_em, post_font, NULL, NULL }, /* Mt */
251 { cond_body, pre_enc, post_enc, "{", "}" }, /* Brq */
252 { cond_body, pre_enc, post_enc, "{", "}" }, /* Bro */
253 { NULL, NULL, NULL, NULL, NULL }, /* Brc */
254 { NULL, NULL, post_percent, NULL, NULL }, /* %C */
255 { NULL, pre_skip, NULL, NULL, NULL }, /* Es */
256 { cond_body, pre_en, post_en, NULL, NULL }, /* En */
257 { NULL, pre_bk, post_bk, NULL, NULL }, /* Dx */
258 { NULL, NULL, post_percent, NULL, NULL }, /* %Q */
259 { NULL, NULL, post_percent, NULL, NULL }, /* %U */
260 { NULL, NULL, NULL, NULL, NULL }, /* Ta */
261 };
262 static const struct manact *const manacts = __manacts - MDOC_Dd;
263
264 static int outflags;
265 #define MMAN_spc (1 << 0) /* blank character before next word */
266 #define MMAN_spc_force (1 << 1) /* even before trailing punctuation */
267 #define MMAN_nl (1 << 2) /* break man(7) code line */
268 #define MMAN_br (1 << 3) /* break output line */
269 #define MMAN_sp (1 << 4) /* insert a blank output line */
270 #define MMAN_PP (1 << 5) /* reset indentation etc. */
271 #define MMAN_Sm (1 << 6) /* horizontal spacing mode */
272 #define MMAN_Bk (1 << 7) /* word keep mode */
273 #define MMAN_Bk_susp (1 << 8) /* suspend this (after a macro) */
274 #define MMAN_An_split (1 << 9) /* author mode is "split" */
275 #define MMAN_An_nosplit (1 << 10) /* author mode is "nosplit" */
276 #define MMAN_PD (1 << 11) /* inter-paragraph spacing disabled */
277 #define MMAN_nbrword (1 << 12) /* do not break the next word */
278
279 #define BL_STACK_MAX 32
280
281 static int Bl_stack[BL_STACK_MAX]; /* offsets [chars] */
282 static int Bl_stack_post[BL_STACK_MAX]; /* add final .RE */
283 static int Bl_stack_len; /* number of nested Bl blocks */
284 static int TPremain; /* characters before tag is full */
285
286 static struct {
287 char *head;
288 char *tail;
289 size_t size;
290 } fontqueue;
291
292
293 static int
294 man_strlen(const char *cp)
295 {
296 size_t rsz;
297 int skip, sz;
298
299 sz = 0;
300 skip = 0;
301 for (;;) {
302 rsz = strcspn(cp, "\\");
303 if (rsz) {
304 cp += rsz;
305 if (skip) {
306 skip = 0;
307 rsz--;
308 }
309 sz += rsz;
310 }
311 if ('\0' == *cp)
312 break;
313 cp++;
314 switch (mandoc_escape(&cp, NULL, NULL)) {
315 case ESCAPE_ERROR:
316 return sz;
317 case ESCAPE_UNICODE:
318 case ESCAPE_NUMBERED:
319 case ESCAPE_SPECIAL:
320 case ESCAPE_OVERSTRIKE:
321 if (skip)
322 skip = 0;
323 else
324 sz++;
325 break;
326 case ESCAPE_SKIPCHAR:
327 skip = 1;
328 break;
329 default:
330 break;
331 }
332 }
333 return sz;
334 }
335
336 static void
337 font_push(char newfont)
338 {
339
340 if (fontqueue.head + fontqueue.size <= ++fontqueue.tail) {
341 fontqueue.size += 8;
342 fontqueue.head = mandoc_realloc(fontqueue.head,
343 fontqueue.size);
344 }
345 *fontqueue.tail = newfont;
346 print_word("");
347 printf("\\f");
348 putchar(newfont);
349 outflags &= ~MMAN_spc;
350 }
351
352 static void
353 font_pop(void)
354 {
355
356 if (fontqueue.tail > fontqueue.head)
357 fontqueue.tail--;
358 outflags &= ~MMAN_spc;
359 print_word("");
360 printf("\\f");
361 putchar(*fontqueue.tail);
362 }
363
364 static void
365 print_word(const char *s)
366 {
367
368 if ((MMAN_PP | MMAN_sp | MMAN_br | MMAN_nl) & outflags) {
369 /*
370 * If we need a newline, print it now and start afresh.
371 */
372 if (MMAN_PP & outflags) {
373 if (MMAN_sp & outflags) {
374 if (MMAN_PD & outflags) {
375 printf("\n.PD");
376 outflags &= ~MMAN_PD;
377 }
378 } else if ( ! (MMAN_PD & outflags)) {
379 printf("\n.PD 0");
380 outflags |= MMAN_PD;
381 }
382 printf("\n.PP\n");
383 } else if (MMAN_sp & outflags)
384 printf("\n.sp\n");
385 else if (MMAN_br & outflags)
386 printf("\n.br\n");
387 else if (MMAN_nl & outflags)
388 putchar('\n');
389 outflags &= ~(MMAN_PP|MMAN_sp|MMAN_br|MMAN_nl|MMAN_spc);
390 if (1 == TPremain)
391 printf(".br\n");
392 TPremain = 0;
393 } else if (MMAN_spc & outflags) {
394 /*
395 * If we need a space, only print it if
396 * (1) it is forced by `No' or
397 * (2) what follows is not terminating punctuation or
398 * (3) what follows is longer than one character.
399 */
400 if (MMAN_spc_force & outflags || '\0' == s[0] ||
401 NULL == strchr(".,:;)]?!", s[0]) || '\0' != s[1]) {
402 if (MMAN_Bk & outflags &&
403 ! (MMAN_Bk_susp & outflags))
404 putchar('\\');
405 putchar(' ');
406 if (TPremain)
407 TPremain--;
408 }
409 }
410
411 /*
412 * Reassign needing space if we're not following opening
413 * punctuation.
414 */
415 if (MMAN_Sm & outflags && ('\0' == s[0] ||
416 (('(' != s[0] && '[' != s[0]) || '\0' != s[1])))
417 outflags |= MMAN_spc;
418 else
419 outflags &= ~MMAN_spc;
420 outflags &= ~(MMAN_spc_force | MMAN_Bk_susp);
421
422 for ( ; *s; s++) {
423 switch (*s) {
424 case ASCII_NBRSP:
425 printf("\\ ");
426 break;
427 case ASCII_HYPH:
428 putchar('-');
429 break;
430 case ASCII_BREAK:
431 printf("\\:");
432 break;
433 case ' ':
434 if (MMAN_nbrword & outflags) {
435 printf("\\ ");
436 break;
437 }
438 /* FALLTHROUGH */
439 default:
440 putchar((unsigned char)*s);
441 break;
442 }
443 if (TPremain)
444 TPremain--;
445 }
446 outflags &= ~MMAN_nbrword;
447 }
448
449 static void
450 print_line(const char *s, int newflags)
451 {
452
453 outflags |= MMAN_nl;
454 print_word(s);
455 outflags |= newflags;
456 }
457
458 static void
459 print_block(const char *s, int newflags)
460 {
461
462 outflags &= ~MMAN_PP;
463 if (MMAN_sp & outflags) {
464 outflags &= ~(MMAN_sp | MMAN_br);
465 if (MMAN_PD & outflags) {
466 print_line(".PD", 0);
467 outflags &= ~MMAN_PD;
468 }
469 } else if (! (MMAN_PD & outflags))
470 print_line(".PD 0", MMAN_PD);
471 outflags |= MMAN_nl;
472 print_word(s);
473 outflags |= MMAN_Bk_susp | newflags;
474 }
475
476 static void
477 print_offs(const char *v, int keywords)
478 {
479 char buf[24];
480 struct roffsu su;
481 const char *end;
482 int sz;
483
484 print_line(".RS", MMAN_Bk_susp);
485
486 /* Convert v into a number (of characters). */
487 if (NULL == v || '\0' == *v || (keywords && !strcmp(v, "left")))
488 sz = 0;
489 else if (keywords && !strcmp(v, "indent"))
490 sz = 6;
491 else if (keywords && !strcmp(v, "indent-two"))
492 sz = 12;
493 else {
494 end = a2roffsu(v, &su, SCALE_EN);
495 if (end == NULL || *end != '\0')
496 sz = man_strlen(v);
497 else if (SCALE_EN == su.unit)
498 sz = su.scale;
499 else {
500 /*
501 * XXX
502 * If we are inside an enclosing list,
503 * there is no easy way to add the two
504 * indentations because they are provided
505 * in terms of different units.
506 */
507 print_word(v);
508 outflags |= MMAN_nl;
509 return;
510 }
511 }
512
513 /*
514 * We are inside an enclosing list.
515 * Add the two indentations.
516 */
517 if (Bl_stack_len)
518 sz += Bl_stack[Bl_stack_len - 1];
519
520 (void)snprintf(buf, sizeof(buf), "%dn", sz);
521 print_word(buf);
522 outflags |= MMAN_nl;
523 }
524
525 /*
526 * Set up the indentation for a list item; used from pre_it().
527 */
528 static void
529 print_width(const struct mdoc_bl *bl, const struct roff_node *child)
530 {
531 char buf[24];
532 struct roffsu su;
533 const char *end;
534 int numeric, remain, sz, chsz;
535
536 numeric = 1;
537 remain = 0;
538
539 /* Convert the width into a number (of characters). */
540 if (bl->width == NULL)
541 sz = (bl->type == LIST_hang) ? 6 : 0;
542 else {
543 end = a2roffsu(bl->width, &su, SCALE_MAX);
544 if (end == NULL || *end != '\0')
545 sz = man_strlen(bl->width);
546 else if (SCALE_EN == su.unit)
547 sz = su.scale;
548 else {
549 sz = 0;
550 numeric = 0;
551 }
552 }
553
554 /* XXX Rough estimation, might have multiple parts. */
555 if (bl->type == LIST_enum)
556 chsz = (bl->count > 8) + 1;
557 else if (child != NULL && child->type == ROFFT_TEXT)
558 chsz = man_strlen(child->string);
559 else
560 chsz = 0;
561
562 /* Maybe we are inside an enclosing list? */
563 mid_it();
564
565 /*
566 * Save our own indentation,
567 * such that child lists can use it.
568 */
569 Bl_stack[Bl_stack_len++] = sz + 2;
570
571 /* Set up the current list. */
572 if (chsz > sz && bl->type != LIST_tag)
573 print_block(".HP", 0);
574 else {
575 print_block(".TP", 0);
576 remain = sz + 2;
577 }
578 if (numeric) {
579 (void)snprintf(buf, sizeof(buf), "%dn", sz + 2);
580 print_word(buf);
581 } else
582 print_word(bl->width);
583 TPremain = remain;
584 }
585
586 static void
587 print_count(int *count)
588 {
589 char buf[24];
590
591 (void)snprintf(buf, sizeof(buf), "%d.\\&", ++*count);
592 print_word(buf);
593 }
594
595 void
596 man_man(void *arg, const struct roff_man *man)
597 {
598
599 /*
600 * Dump the keep buffer.
601 * We're guaranteed by now that this exists (is non-NULL).
602 * Flush stdout afterward, just in case.
603 */
604 fputs(mparse_getkeep(man_mparse(man)), stdout);
605 fflush(stdout);
606 }
607
608 void
609 man_mdoc(void *arg, const struct roff_man *mdoc)
610 {
611 struct roff_node *n;
612
613 printf(".TH \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n",
614 mdoc->meta.title,
615 (mdoc->meta.msec == NULL ? "" : mdoc->meta.msec),
616 mdoc->meta.date, mdoc->meta.os, mdoc->meta.vol);
617
618 /* Disable hyphenation and if nroff, disable justification. */
619 printf(".nh\n.if n .ad l");
620
621 outflags = MMAN_nl | MMAN_Sm;
622 if (0 == fontqueue.size) {
623 fontqueue.size = 8;
624 fontqueue.head = fontqueue.tail = mandoc_malloc(8);
625 *fontqueue.tail = 'R';
626 }
627 for (n = mdoc->first->child; n != NULL; n = n->next)
628 print_node(&mdoc->meta, n);
629 putchar('\n');
630 }
631
632 static void
633 print_node(DECL_ARGS)
634 {
635 const struct manact *act;
636 struct roff_node *sub;
637 int cond, do_sub;
638
639 if (n->flags & NODE_NOPRT)
640 return;
641
642 /*
643 * Break the line if we were parsed subsequent the current node.
644 * This makes the page structure be more consistent.
645 */
646 if (MMAN_spc & outflags && NODE_LINE & n->flags)
647 outflags |= MMAN_nl;
648
649 act = NULL;
650 cond = 0;
651 do_sub = 1;
652 n->flags &= ~NODE_ENDED;
653
654 if (n->type == ROFFT_TEXT) {
655 /*
656 * Make sure that we don't happen to start with a
657 * control character at the start of a line.
658 */
659 if (MMAN_nl & outflags &&
660 ('.' == *n->string || '\'' == *n->string)) {
661 print_word("");
662 printf("\\&");
663 outflags &= ~MMAN_spc;
664 }
665 if (n->flags & NODE_DELIMC)
666 outflags &= ~(MMAN_spc | MMAN_spc_force);
667 else if (outflags & MMAN_Sm)
668 outflags |= MMAN_spc_force;
669 print_word(n->string);
670 if (n->flags & NODE_DELIMO)
671 outflags &= ~(MMAN_spc | MMAN_spc_force);
672 else if (outflags & MMAN_Sm)
673 outflags |= MMAN_spc;
674 } else if (n->tok < ROFF_MAX) {
675 (*roff_manacts[n->tok])(meta, n);
676 return;
677 } else {
678 assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);
679 /*
680 * Conditionally run the pre-node action handler for a
681 * node.
682 */
683 act = manacts + n->tok;
684 cond = act->cond == NULL || (*act->cond)(meta, n);
685 if (cond && act->pre != NULL &&
686 (n->end == ENDBODY_NOT || n->child != NULL))
687 do_sub = (*act->pre)(meta, n);
688 }
689
690 /*
691 * Conditionally run all child nodes.
692 * Note that this iterates over children instead of using
693 * recursion. This prevents unnecessary depth in the stack.
694 */
695 if (do_sub)
696 for (sub = n->child; sub; sub = sub->next)
697 print_node(meta, sub);
698
699 /*
700 * Lastly, conditionally run the post-node handler.
701 */
702 if (NODE_ENDED & n->flags)
703 return;
704
705 if (cond && act->post)
706 (*act->post)(meta, n);
707
708 if (ENDBODY_NOT != n->end)
709 n->body->flags |= NODE_ENDED;
710 }
711
712 static int
713 cond_head(DECL_ARGS)
714 {
715
716 return n->type == ROFFT_HEAD;
717 }
718
719 static int
720 cond_body(DECL_ARGS)
721 {
722
723 return n->type == ROFFT_BODY;
724 }
725
726 static int
727 pre_enc(DECL_ARGS)
728 {
729 const char *prefix;
730
731 prefix = manacts[n->tok].prefix;
732 if (NULL == prefix)
733 return 1;
734 print_word(prefix);
735 outflags &= ~MMAN_spc;
736 return 1;
737 }
738
739 static void
740 post_enc(DECL_ARGS)
741 {
742 const char *suffix;
743
744 suffix = manacts[n->tok].suffix;
745 if (NULL == suffix)
746 return;
747 outflags &= ~(MMAN_spc | MMAN_nl);
748 print_word(suffix);
749 }
750
751 static int
752 pre_ex(DECL_ARGS)
753 {
754 outflags |= MMAN_br | MMAN_nl;
755 return 1;
756 }
757
758 static void
759 post_font(DECL_ARGS)
760 {
761
762 font_pop();
763 }
764
765 static void
766 post_percent(DECL_ARGS)
767 {
768
769 if (pre_em == manacts[n->tok].pre)
770 font_pop();
771 if (n->next) {
772 print_word(",");
773 if (n->prev && n->prev->tok == n->tok &&
774 n->next->tok == n->tok)
775 print_word("and");
776 } else {
777 print_word(".");
778 outflags |= MMAN_nl;
779 }
780 }
781
782 static int
783 pre__t(DECL_ARGS)
784 {
785
786 if (n->parent->tok == MDOC_Rs && n->parent->norm->Rs.quote_T) {
787 print_word("\\(lq");
788 outflags &= ~MMAN_spc;
789 } else
790 font_push('I');
791 return 1;
792 }
793
794 static void
795 post__t(DECL_ARGS)
796 {
797
798 if (n->parent->tok == MDOC_Rs && n->parent->norm->Rs.quote_T) {
799 outflags &= ~MMAN_spc;
800 print_word("\\(rq");
801 } else
802 font_pop();
803 post_percent(meta, n);
804 }
805
806 /*
807 * Print before a section header.
808 */
809 static int
810 pre_sect(DECL_ARGS)
811 {
812
813 if (n->type == ROFFT_HEAD) {
814 outflags |= MMAN_sp;
815 print_block(manacts[n->tok].prefix, 0);
816 print_word("");
817 putchar('\"');
818 outflags &= ~MMAN_spc;
819 }
820 return 1;
821 }
822
823 /*
824 * Print subsequent a section header.
825 */
826 static void
827 post_sect(DECL_ARGS)
828 {
829
830 if (n->type != ROFFT_HEAD)
831 return;
832 outflags &= ~MMAN_spc;
833 print_word("");
834 putchar('\"');
835 outflags |= MMAN_nl;
836 if (MDOC_Sh == n->tok && SEC_AUTHORS == n->sec)
837 outflags &= ~(MMAN_An_split | MMAN_An_nosplit);
838 }
839
840 /* See mdoc_term.c, synopsis_pre() for comments. */
841 static void
842 pre_syn(const struct roff_node *n)
843 {
844
845 if (NULL == n->prev || ! (NODE_SYNPRETTY & n->flags))
846 return;
847
848 if (n->prev->tok == n->tok &&
849 MDOC_Ft != n->tok &&
850 MDOC_Fo != n->tok &&
851 MDOC_Fn != n->tok) {
852 outflags |= MMAN_br;
853 return;
854 }
855
856 switch (n->prev->tok) {
857 case MDOC_Fd:
858 case MDOC_Fn:
859 case MDOC_Fo:
860 case MDOC_In:
861 case MDOC_Vt:
862 outflags |= MMAN_sp;
863 break;
864 case MDOC_Ft:
865 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
866 outflags |= MMAN_sp;
867 break;
868 }
869 /* FALLTHROUGH */
870 default:
871 outflags |= MMAN_br;
872 break;
873 }
874 }
875
876 static int
877 pre_an(DECL_ARGS)
878 {
879
880 switch (n->norm->An.auth) {
881 case AUTH_split:
882 outflags &= ~MMAN_An_nosplit;
883 outflags |= MMAN_An_split;
884 return 0;
885 case AUTH_nosplit:
886 outflags &= ~MMAN_An_split;
887 outflags |= MMAN_An_nosplit;
888 return 0;
889 default:
890 if (MMAN_An_split & outflags)
891 outflags |= MMAN_br;
892 else if (SEC_AUTHORS == n->sec &&
893 ! (MMAN_An_nosplit & outflags))
894 outflags |= MMAN_An_split;
895 return 1;
896 }
897 }
898
899 static int
900 pre_ap(DECL_ARGS)
901 {
902
903 outflags &= ~MMAN_spc;
904 print_word("'");
905 outflags &= ~MMAN_spc;
906 return 0;
907 }
908
909 static int
910 pre_aq(DECL_ARGS)
911 {
912
913 print_word(n->child != NULL && n->child->next == NULL &&
914 n->child->tok == MDOC_Mt ? "<" : "\\(la");
915 outflags &= ~MMAN_spc;
916 return 1;
917 }
918
919 static void
920 post_aq(DECL_ARGS)
921 {
922
923 outflags &= ~(MMAN_spc | MMAN_nl);
924 print_word(n->child != NULL && n->child->next == NULL &&
925 n->child->tok == MDOC_Mt ? ">" : "\\(ra");
926 }
927
928 static int
929 pre_bd(DECL_ARGS)
930 {
931
932 outflags &= ~(MMAN_PP | MMAN_sp | MMAN_br);
933
934 if (DISP_unfilled == n->norm->Bd.type ||
935 DISP_literal == n->norm->Bd.type)
936 print_line(".nf", 0);
937 if (0 == n->norm->Bd.comp && NULL != n->parent->prev)
938 outflags |= MMAN_sp;
939 print_offs(n->norm->Bd.offs, 1);
940 return 1;
941 }
942
943 static void
944 post_bd(DECL_ARGS)
945 {
946
947 /* Close out this display. */
948 print_line(".RE", MMAN_nl);
949 if (DISP_unfilled == n->norm->Bd.type ||
950 DISP_literal == n->norm->Bd.type)
951 print_line(".fi", MMAN_nl);
952
953 /* Maybe we are inside an enclosing list? */
954 if (NULL != n->parent->next)
955 mid_it();
956 }
957
958 static int
959 pre_bf(DECL_ARGS)
960 {
961
962 switch (n->type) {
963 case ROFFT_BLOCK:
964 return 1;
965 case ROFFT_BODY:
966 break;
967 default:
968 return 0;
969 }
970 switch (n->norm->Bf.font) {
971 case FONT_Em:
972 font_push('I');
973 break;
974 case FONT_Sy:
975 font_push('B');
976 break;
977 default:
978 font_push('R');
979 break;
980 }
981 return 1;
982 }
983
984 static void
985 post_bf(DECL_ARGS)
986 {
987
988 if (n->type == ROFFT_BODY)
989 font_pop();
990 }
991
992 static int
993 pre_bk(DECL_ARGS)
994 {
995 switch (n->type) {
996 case ROFFT_BLOCK:
997 return 1;
998 case ROFFT_BODY:
999 case ROFFT_ELEM:
1000 outflags |= MMAN_Bk;
1001 return 1;
1002 default:
1003 return 0;
1004 }
1005 }
1006
1007 static void
1008 post_bk(DECL_ARGS)
1009 {
1010 switch (n->type) {
1011 case ROFFT_ELEM:
1012 while ((n = n->parent) != NULL)
1013 if (n->tok == MDOC_Bk)
1014 return;
1015 /* FALLTHROUGH */
1016 case ROFFT_BODY:
1017 outflags &= ~MMAN_Bk;
1018 break;
1019 default:
1020 break;
1021 }
1022 }
1023
1024 static int
1025 pre_bl(DECL_ARGS)
1026 {
1027 size_t icol;
1028
1029 /*
1030 * print_offs() will increase the -offset to account for
1031 * a possible enclosing .It, but any enclosed .It blocks
1032 * just nest and do not add up their indentation.
1033 */
1034 if (n->norm->Bl.offs) {
1035 print_offs(n->norm->Bl.offs, 0);
1036 Bl_stack[Bl_stack_len++] = 0;
1037 }
1038
1039 switch (n->norm->Bl.type) {
1040 case LIST_enum:
1041 n->norm->Bl.count = 0;
1042 return 1;
1043 case LIST_column:
1044 break;
1045 default:
1046 return 1;
1047 }
1048
1049 if (n->child != NULL) {
1050 print_line(".TS", MMAN_nl);
1051 for (icol = 0; icol < n->norm->Bl.ncols; icol++)
1052 print_word("l");
1053 print_word(".");
1054 }
1055 outflags |= MMAN_nl;
1056 return 1;
1057 }
1058
1059 static void
1060 post_bl(DECL_ARGS)
1061 {
1062
1063 switch (n->norm->Bl.type) {
1064 case LIST_column:
1065 if (n->child != NULL)
1066 print_line(".TE", 0);
1067 break;
1068 case LIST_enum:
1069 n->norm->Bl.count = 0;
1070 break;
1071 default:
1072 break;
1073 }
1074
1075 if (n->norm->Bl.offs) {
1076 print_line(".RE", MMAN_nl);
1077 assert(Bl_stack_len);
1078 Bl_stack_len--;
1079 assert(0 == Bl_stack[Bl_stack_len]);
1080 } else {
1081 outflags |= MMAN_PP | MMAN_nl;
1082 outflags &= ~(MMAN_sp | MMAN_br);
1083 }
1084
1085 /* Maybe we are inside an enclosing list? */
1086 if (NULL != n->parent->next)
1087 mid_it();
1088
1089 }
1090
1091 static void
1092 pre_br(DECL_ARGS)
1093 {
1094 outflags |= MMAN_br;
1095 }
1096
1097 static int
1098 pre_dl(DECL_ARGS)
1099 {
1100
1101 print_offs("6n", 0);
1102 return 1;
1103 }
1104
1105 static void
1106 post_dl(DECL_ARGS)
1107 {
1108
1109 print_line(".RE", MMAN_nl);
1110
1111 /* Maybe we are inside an enclosing list? */
1112 if (NULL != n->parent->next)
1113 mid_it();
1114 }
1115
1116 static int
1117 pre_em(DECL_ARGS)
1118 {
1119
1120 font_push('I');
1121 return 1;
1122 }
1123
1124 static int
1125 pre_en(DECL_ARGS)
1126 {
1127
1128 if (NULL == n->norm->Es ||
1129 NULL == n->norm->Es->child)
1130 return 1;
1131
1132 print_word(n->norm->Es->child->string);
1133 outflags &= ~MMAN_spc;
1134 return 1;
1135 }
1136
1137 static void
1138 post_en(DECL_ARGS)
1139 {
1140
1141 if (NULL == n->norm->Es ||
1142 NULL == n->norm->Es->child ||
1143 NULL == n->norm->Es->child->next)
1144 return;
1145
1146 outflags &= ~MMAN_spc;
1147 print_word(n->norm->Es->child->next->string);
1148 return;
1149 }
1150
1151 static int
1152 pre_eo(DECL_ARGS)
1153 {
1154
1155 if (n->end == ENDBODY_NOT &&
1156 n->parent->head->child == NULL &&
1157 n->child != NULL &&
1158 n->child->end != ENDBODY_NOT)
1159 print_word("\\&");
1160 else if (n->end != ENDBODY_NOT ? n->child != NULL :
1161 n->parent->head->child != NULL && (n->child != NULL ||
1162 (n->parent->tail != NULL && n->parent->tail->child != NULL)))
1163 outflags &= ~(MMAN_spc | MMAN_nl);
1164 return 1;
1165 }
1166
1167 static void
1168 post_eo(DECL_ARGS)
1169 {
1170 int body, tail;
1171
1172 if (n->end != ENDBODY_NOT) {
1173 outflags |= MMAN_spc;
1174 return;
1175 }
1176
1177 body = n->child != NULL || n->parent->head->child != NULL;
1178 tail = n->parent->tail != NULL && n->parent->tail->child != NULL;
1179
1180 if (body && tail)
1181 outflags &= ~MMAN_spc;
1182 else if ( ! (body || tail))
1183 print_word("\\&");
1184 else if ( ! tail)
1185 outflags |= MMAN_spc;
1186 }
1187
1188 static int
1189 pre_fa(DECL_ARGS)
1190 {
1191 int am_Fa;
1192
1193 am_Fa = MDOC_Fa == n->tok;
1194
1195 if (am_Fa)
1196 n = n->child;
1197
1198 while (NULL != n) {
1199 font_push('I');
1200 if (am_Fa || NODE_SYNPRETTY & n->flags)
1201 outflags |= MMAN_nbrword;
1202 print_node(meta, n);
1203 font_pop();
1204 if (NULL != (n = n->next))
1205 print_word(",");
1206 }
1207 return 0;
1208 }
1209
1210 static void
1211 post_fa(DECL_ARGS)
1212 {
1213
1214 if (NULL != n->next && MDOC_Fa == n->next->tok)
1215 print_word(",");
1216 }
1217
1218 static int
1219 pre_fd(DECL_ARGS)
1220 {
1221
1222 pre_syn(n);
1223 font_push('B');
1224 return 1;
1225 }
1226
1227 static void
1228 post_fd(DECL_ARGS)
1229 {
1230
1231 font_pop();
1232 outflags |= MMAN_br;
1233 }
1234
1235 static int
1236 pre_fl(DECL_ARGS)
1237 {
1238
1239 font_push('B');
1240 print_word("\\-");
1241 if (n->child != NULL)
1242 outflags &= ~MMAN_spc;
1243 return 1;
1244 }
1245
1246 static void
1247 post_fl(DECL_ARGS)
1248 {
1249
1250 font_pop();
1251 if (!(n->child != NULL ||
1252 n->next == NULL ||
1253 n->next->type == ROFFT_TEXT ||
1254 n->next->flags & NODE_LINE))
1255 outflags &= ~MMAN_spc;
1256 }
1257
1258 static int
1259 pre_fn(DECL_ARGS)
1260 {
1261
1262 pre_syn(n);
1263
1264 n = n->child;
1265 if (NULL == n)
1266 return 0;
1267
1268 if (NODE_SYNPRETTY & n->flags)
1269 print_block(".HP 4n", MMAN_nl);
1270
1271 font_push('B');
1272 print_node(meta, n);
1273 font_pop();
1274 outflags &= ~MMAN_spc;
1275 print_word("(");
1276 outflags &= ~MMAN_spc;
1277
1278 n = n->next;
1279 if (NULL != n)
1280 pre_fa(meta, n);
1281 return 0;
1282 }
1283
1284 static void
1285 post_fn(DECL_ARGS)
1286 {
1287
1288 print_word(")");
1289 if (NODE_SYNPRETTY & n->flags) {
1290 print_word(";");
1291 outflags |= MMAN_PP;
1292 }
1293 }
1294
1295 static int
1296 pre_fo(DECL_ARGS)
1297 {
1298
1299 switch (n->type) {
1300 case ROFFT_BLOCK:
1301 pre_syn(n);
1302 break;
1303 case ROFFT_HEAD:
1304 if (n->child == NULL)
1305 return 0;
1306 if (NODE_SYNPRETTY & n->flags)
1307 print_block(".HP 4n", MMAN_nl);
1308 font_push('B');
1309 break;
1310 case ROFFT_BODY:
1311 outflags &= ~(MMAN_spc | MMAN_nl);
1312 print_word("(");
1313 outflags &= ~MMAN_spc;
1314 break;
1315 default:
1316 break;
1317 }
1318 return 1;
1319 }
1320
1321 static void
1322 post_fo(DECL_ARGS)
1323 {
1324
1325 switch (n->type) {
1326 case ROFFT_HEAD:
1327 if (n->child != NULL)
1328 font_pop();
1329 break;
1330 case ROFFT_BODY:
1331 post_fn(meta, n);
1332 break;
1333 default:
1334 break;
1335 }
1336 }
1337
1338 static int
1339 pre_Ft(DECL_ARGS)
1340 {
1341
1342 pre_syn(n);
1343 font_push('I');
1344 return 1;
1345 }
1346
1347 static void
1348 pre_ft(DECL_ARGS)
1349 {
1350 print_line(".ft", 0);
1351 print_word(n->child->string);
1352 outflags |= MMAN_nl;
1353 }
1354
1355 static int
1356 pre_in(DECL_ARGS)
1357 {
1358
1359 if (NODE_SYNPRETTY & n->flags) {
1360 pre_syn(n);
1361 font_push('B');
1362 print_word("#include <");
1363 outflags &= ~MMAN_spc;
1364 } else {
1365 print_word("<");
1366 outflags &= ~MMAN_spc;
1367 font_push('I');
1368 }
1369 return 1;
1370 }
1371
1372 static void
1373 post_in(DECL_ARGS)
1374 {
1375
1376 if (NODE_SYNPRETTY & n->flags) {
1377 outflags &= ~MMAN_spc;
1378 print_word(">");
1379 font_pop();
1380 outflags |= MMAN_br;
1381 } else {
1382 font_pop();
1383 outflags &= ~MMAN_spc;
1384 print_word(">");
1385 }
1386 }
1387
1388 static int
1389 pre_it(DECL_ARGS)
1390 {
1391 const struct roff_node *bln;
1392
1393 switch (n->type) {
1394 case ROFFT_HEAD:
1395 outflags |= MMAN_PP | MMAN_nl;
1396 bln = n->parent->parent;
1397 if (0 == bln->norm->Bl.comp ||
1398 (NULL == n->parent->prev &&
1399 NULL == bln->parent->prev))
1400 outflags |= MMAN_sp;
1401 outflags &= ~MMAN_br;
1402 switch (bln->norm->Bl.type) {
1403 case LIST_item:
1404 return 0;
1405 case LIST_inset:
1406 case LIST_diag:
1407 case LIST_ohang:
1408 if (bln->norm->Bl.type == LIST_diag)
1409 print_line(".B \"", 0);
1410 else
1411 print_line(".R \"", 0);
1412 outflags &= ~MMAN_spc;
1413 return 1;
1414 case LIST_bullet:
1415 case LIST_dash:
1416 case LIST_hyphen:
1417 print_width(&bln->norm->Bl, NULL);
1418 TPremain = 0;
1419 outflags |= MMAN_nl;
1420 font_push('B');
1421 if (LIST_bullet == bln->norm->Bl.type)
1422 print_word("\\(bu");
1423 else
1424 print_word("-");
1425 font_pop();
1426 outflags |= MMAN_nl;
1427 return 0;
1428 case LIST_enum:
1429 print_width(&bln->norm->Bl, NULL);
1430 TPremain = 0;
1431 outflags |= MMAN_nl;
1432 print_count(&bln->norm->Bl.count);
1433 outflags |= MMAN_nl;
1434 return 0;
1435 case LIST_hang:
1436 print_width(&bln->norm->Bl, n->child);
1437 TPremain = 0;
1438 outflags |= MMAN_nl;
1439 return 1;
1440 case LIST_tag:
1441 print_width(&bln->norm->Bl, n->child);
1442 putchar('\n');
1443 outflags &= ~MMAN_spc;
1444 return 1;
1445 default:
1446 return 1;
1447 }
1448 default:
1449 break;
1450 }
1451 return 1;
1452 }
1453
1454 /*
1455 * This function is called after closing out an indented block.
1456 * If we are inside an enclosing list, restore its indentation.
1457 */
1458 static void
1459 mid_it(void)
1460 {
1461 char buf[24];
1462
1463 /* Nothing to do outside a list. */
1464 if (0 == Bl_stack_len || 0 == Bl_stack[Bl_stack_len - 1])
1465 return;
1466
1467 /* The indentation has already been set up. */
1468 if (Bl_stack_post[Bl_stack_len - 1])
1469 return;
1470
1471 /* Restore the indentation of the enclosing list. */
1472 print_line(".RS", MMAN_Bk_susp);
1473 (void)snprintf(buf, sizeof(buf), "%dn",
1474 Bl_stack[Bl_stack_len - 1]);
1475 print_word(buf);
1476
1477 /* Remeber to close out this .RS block later. */
1478 Bl_stack_post[Bl_stack_len - 1] = 1;
1479 }
1480
1481 static void
1482 post_it(DECL_ARGS)
1483 {
1484 const struct roff_node *bln;
1485
1486 bln = n->parent->parent;
1487
1488 switch (n->type) {
1489 case ROFFT_HEAD:
1490 switch (bln->norm->Bl.type) {
1491 case LIST_diag:
1492 outflags &= ~MMAN_spc;
1493 print_word("\\ ");
1494 break;
1495 case LIST_ohang:
1496 outflags |= MMAN_br;
1497 break;
1498 default:
1499 break;
1500 }
1501 break;
1502 case ROFFT_BODY:
1503 switch (bln->norm->Bl.type) {
1504 case LIST_bullet:
1505 case LIST_dash:
1506 case LIST_hyphen:
1507 case LIST_enum:
1508 case LIST_hang:
1509 case LIST_tag:
1510 assert(Bl_stack_len);
1511 Bl_stack[--Bl_stack_len] = 0;
1512
1513 /*
1514 * Our indentation had to be restored
1515 * after a child display or child list.
1516 * Close out that indentation block now.
1517 */
1518 if (Bl_stack_post[Bl_stack_len]) {
1519 print_line(".RE", MMAN_nl);
1520 Bl_stack_post[Bl_stack_len] = 0;
1521 }
1522 break;
1523 case LIST_column:
1524 if (NULL != n->next) {
1525 putchar('\t');
1526 outflags &= ~MMAN_spc;
1527 }
1528 break;
1529 default:
1530 break;
1531 }
1532 break;
1533 default:
1534 break;
1535 }
1536 }
1537
1538 static void
1539 post_lb(DECL_ARGS)
1540 {
1541
1542 if (SEC_LIBRARY == n->sec)
1543 outflags |= MMAN_br;
1544 }
1545
1546 static int
1547 pre_lk(DECL_ARGS)
1548 {
1549 const struct roff_node *link, *descr, *punct;
1550 int display;
1551
1552 if ((link = n->child) == NULL)
1553 return 0;
1554
1555 /* Find beginning of trailing punctuation. */
1556 punct = n->last;
1557 while (punct != link && punct->flags & NODE_DELIMC)
1558 punct = punct->prev;
1559 punct = punct->next;
1560
1561 /* Link text. */
1562 if ((descr = link->next) != NULL && descr != punct) {
1563 font_push('I');
1564 while (descr != punct) {
1565 print_word(descr->string);
1566 descr = descr->next;
1567 }
1568 font_pop();
1569 print_word(":");
1570 }
1571
1572 /* Link target. */
1573 display = man_strlen(link->string) >= 26;
1574 if (display) {
1575 print_line(".RS", MMAN_Bk_susp);
1576 print_word("6n");
1577 outflags |= MMAN_nl;
1578 }
1579 font_push('B');
1580 print_word(link->string);
1581 font_pop();
1582
1583 /* Trailing punctuation. */
1584 while (punct != NULL) {
1585 print_word(punct->string);
1586 punct = punct->next;
1587 }
1588 if (display)
1589 print_line(".RE", MMAN_nl);
1590 return 0;
1591 }
1592
1593 static void
1594 pre_onearg(DECL_ARGS)
1595 {
1596 outflags |= MMAN_nl;
1597 print_word(".");
1598 outflags &= ~MMAN_spc;
1599 print_word(roff_name[n->tok]);
1600 if (n->child != NULL)
1601 print_word(n->child->string);
1602 outflags |= MMAN_nl;
1603 if (n->tok == ROFF_ce)
1604 for (n = n->child->next; n != NULL; n = n->next)
1605 print_node(meta, n);
1606 }
1607
1608 static int
1609 pre_li(DECL_ARGS)
1610 {
1611
1612 font_push('R');
1613 return 1;
1614 }
1615
1616 static int
1617 pre_nm(DECL_ARGS)
1618 {
1619 char *name;
1620
1621 if (n->type == ROFFT_BLOCK) {
1622 outflags |= MMAN_Bk;
1623 pre_syn(n);
1624 }
1625 if (n->type != ROFFT_ELEM && n->type != ROFFT_HEAD)
1626 return 1;
1627 name = n->child == NULL ? NULL : n->child->string;
1628 if (NULL == name)
1629 return 0;
1630 if (n->type == ROFFT_HEAD) {
1631 if (NULL == n->parent->prev)
1632 outflags |= MMAN_sp;
1633 print_block(".HP", 0);
1634 printf(" %dn", man_strlen(name) + 1);
1635 outflags |= MMAN_nl;
1636 }
1637 font_push('B');
1638 return 1;
1639 }
1640
1641 static void
1642 post_nm(DECL_ARGS)
1643 {
1644
1645 switch (n->type) {
1646 case ROFFT_BLOCK:
1647 outflags &= ~MMAN_Bk;
1648 break;
1649 case ROFFT_HEAD:
1650 case ROFFT_ELEM:
1651 if (n->child != NULL && n->child->string != NULL)
1652 font_pop();
1653 break;
1654 default:
1655 break;
1656 }
1657 }
1658
1659 static int
1660 pre_no(DECL_ARGS)
1661 {
1662
1663 outflags |= MMAN_spc_force;
1664 return 1;
1665 }
1666
1667 static int
1668 pre_ns(DECL_ARGS)
1669 {
1670
1671 outflags &= ~MMAN_spc;
1672 return 0;
1673 }
1674
1675 static void
1676 post_pf(DECL_ARGS)
1677 {
1678
1679 if ( ! (n->next == NULL || n->next->flags & NODE_LINE))
1680 outflags &= ~MMAN_spc;
1681 }
1682
1683 static int
1684 pre_pp(DECL_ARGS)
1685 {
1686
1687 if (MDOC_It != n->parent->tok)
1688 outflags |= MMAN_PP;
1689 outflags |= MMAN_sp | MMAN_nl;
1690 outflags &= ~MMAN_br;
1691 return 0;
1692 }
1693
1694 static int
1695 pre_rs(DECL_ARGS)
1696 {
1697
1698 if (SEC_SEE_ALSO == n->sec) {
1699 outflags |= MMAN_PP | MMAN_sp | MMAN_nl;
1700 outflags &= ~MMAN_br;
1701 }
1702 return 1;
1703 }
1704
1705 static int
1706 pre_skip(DECL_ARGS)
1707 {
1708
1709 return 0;
1710 }
1711
1712 static int
1713 pre_sm(DECL_ARGS)
1714 {
1715
1716 if (NULL == n->child)
1717 outflags ^= MMAN_Sm;
1718 else if (0 == strcmp("on", n->child->string))
1719 outflags |= MMAN_Sm;
1720 else
1721 outflags &= ~MMAN_Sm;
1722
1723 if (MMAN_Sm & outflags)
1724 outflags |= MMAN_spc;
1725
1726 return 0;
1727 }
1728
1729 static void
1730 pre_sp(DECL_ARGS)
1731 {
1732 if (outflags & MMAN_PP) {
1733 outflags &= ~MMAN_PP;
1734 print_line(".PP", 0);
1735 } else {
1736 print_line(".sp", 0);
1737 if (n->child != NULL)
1738 print_word(n->child->string);
1739 }
1740 outflags |= MMAN_nl;
1741 }
1742
1743 static int
1744 pre_sy(DECL_ARGS)
1745 {
1746
1747 font_push('B');
1748 return 1;
1749 }
1750
1751 static void
1752 pre_ta(DECL_ARGS)
1753 {
1754 print_line(".ta", 0);
1755 for (n = n->child; n != NULL; n = n->next)
1756 print_word(n->string);
1757 outflags |= MMAN_nl;
1758 }
1759
1760 static int
1761 pre_vt(DECL_ARGS)
1762 {
1763
1764 if (NODE_SYNPRETTY & n->flags) {
1765 switch (n->type) {
1766 case ROFFT_BLOCK:
1767 pre_syn(n);
1768 return 1;
1769 case ROFFT_BODY:
1770 break;
1771 default:
1772 return 0;
1773 }
1774 }
1775 font_push('I');
1776 return 1;
1777 }
1778
1779 static void
1780 post_vt(DECL_ARGS)
1781 {
1782
1783 if (n->flags & NODE_SYNPRETTY && n->type != ROFFT_BODY)
1784 return;
1785 font_pop();
1786 }
1787
1788 static int
1789 pre_xr(DECL_ARGS)
1790 {
1791
1792 n = n->child;
1793 if (NULL == n)
1794 return 0;
1795 print_node(meta, n);
1796 n = n->next;
1797 if (NULL == n)
1798 return 0;
1799 outflags &= ~MMAN_spc;
1800 print_word("(");
1801 print_node(meta, n);
1802 print_word(")");
1803 return 0;
1804 }