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