]> git.cameronkatri.com Git - mandoc.git/blob - mdoc_term.c
git.ckatri.com / mandoc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Some pre-handlers produce output, so reorder the code to set up
[mandoc.git] / mdoc_term.c
1 /* $Id: mdoc_term.c,v 1.217 2011/02/06 22:33:38 schwarze Exp $ */
2 /*
3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2010 Ingo Schwarze <schwarze@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #endif
21
22 #include <sys/types.h>
23
24 #include <assert.h>
25 #include <ctype.h>
26 #include <stdint.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include "mandoc.h"
32 #include "out.h"
33 #include "term.h"
34 #include "mdoc.h"
35 #include "chars.h"
36 #include "main.h"
37
38 #define INDENT 5
39 #define HALFINDENT 3
40
41 struct termpair {
42 struct termpair *ppair;
43 int count;
44 };
45
46 #define DECL_ARGS struct termp *p, \
47 struct termpair *pair, \
48 const struct mdoc_meta *m, \
49 const struct mdoc_node *n
50
51 struct termact {
52 int (*pre)(DECL_ARGS);
53 void (*post)(DECL_ARGS);
54 };
55
56 static size_t a2width(const struct termp *, const char *);
57 static size_t a2height(const struct termp *, const char *);
58 static size_t a2offs(const struct termp *, const char *);
59
60 static void print_bvspace(struct termp *,
61 const struct mdoc_node *,
62 const struct mdoc_node *);
63 static void print_mdoc_node(DECL_ARGS);
64 static void print_mdoc_nodelist(DECL_ARGS);
65 static void print_mdoc_head(struct termp *, const void *);
66 static void print_mdoc_foot(struct termp *, const void *);
67 static void synopsis_pre(struct termp *,
68 const struct mdoc_node *);
69
70 static void termp____post(DECL_ARGS);
71 static void termp__t_post(DECL_ARGS);
72 static void termp_an_post(DECL_ARGS);
73 static void termp_bd_post(DECL_ARGS);
74 static void termp_bk_post(DECL_ARGS);
75 static void termp_bl_post(DECL_ARGS);
76 static void termp_d1_post(DECL_ARGS);
77 static void termp_fo_post(DECL_ARGS);
78 static void termp_in_post(DECL_ARGS);
79 static void termp_it_post(DECL_ARGS);
80 static void termp_lb_post(DECL_ARGS);
81 static void termp_nm_post(DECL_ARGS);
82 static void termp_pf_post(DECL_ARGS);
83 static void termp_quote_post(DECL_ARGS);
84 static void termp_sh_post(DECL_ARGS);
85 static void termp_ss_post(DECL_ARGS);
86
87 static int termp__a_pre(DECL_ARGS);
88 static int termp__t_pre(DECL_ARGS);
89 static int termp_an_pre(DECL_ARGS);
90 static int termp_ap_pre(DECL_ARGS);
91 static int termp_bd_pre(DECL_ARGS);
92 static int termp_bf_pre(DECL_ARGS);
93 static int termp_bk_pre(DECL_ARGS);
94 static int termp_bl_pre(DECL_ARGS);
95 static int termp_bold_pre(DECL_ARGS);
96 static int termp_bt_pre(DECL_ARGS);
97 static int termp_bx_pre(DECL_ARGS);
98 static int termp_cd_pre(DECL_ARGS);
99 static int termp_d1_pre(DECL_ARGS);
100 static int termp_ex_pre(DECL_ARGS);
101 static int termp_fa_pre(DECL_ARGS);
102 static int termp_fd_pre(DECL_ARGS);
103 static int termp_fl_pre(DECL_ARGS);
104 static int termp_fn_pre(DECL_ARGS);
105 static int termp_fo_pre(DECL_ARGS);
106 static int termp_ft_pre(DECL_ARGS);
107 static int termp_igndelim_pre(DECL_ARGS);
108 static int termp_in_pre(DECL_ARGS);
109 static int termp_it_pre(DECL_ARGS);
110 static int termp_li_pre(DECL_ARGS);
111 static int termp_lk_pre(DECL_ARGS);
112 static int termp_nd_pre(DECL_ARGS);
113 static int termp_nm_pre(DECL_ARGS);
114 static int termp_ns_pre(DECL_ARGS);
115 static int termp_quote_pre(DECL_ARGS);
116 static int termp_rs_pre(DECL_ARGS);
117 static int termp_rv_pre(DECL_ARGS);
118 static int termp_sh_pre(DECL_ARGS);
119 static int termp_sm_pre(DECL_ARGS);
120 static int termp_sp_pre(DECL_ARGS);
121 static int termp_ss_pre(DECL_ARGS);
122 static int termp_under_pre(DECL_ARGS);
123 static int termp_ud_pre(DECL_ARGS);
124 static int termp_vt_pre(DECL_ARGS);
125 static int termp_xr_pre(DECL_ARGS);
126 static int termp_xx_pre(DECL_ARGS);
127
128 static const struct termact termacts[MDOC_MAX] = {
129 { termp_ap_pre, NULL }, /* Ap */
130 { NULL, NULL }, /* Dd */
131 { NULL, NULL }, /* Dt */
132 { NULL, NULL }, /* Os */
133 { termp_sh_pre, termp_sh_post }, /* Sh */
134 { termp_ss_pre, termp_ss_post }, /* Ss */
135 { termp_sp_pre, NULL }, /* Pp */
136 { termp_d1_pre, termp_d1_post }, /* D1 */
137 { termp_d1_pre, termp_d1_post }, /* Dl */
138 { termp_bd_pre, termp_bd_post }, /* Bd */
139 { NULL, NULL }, /* Ed */
140 { termp_bl_pre, termp_bl_post }, /* Bl */
141 { NULL, NULL }, /* El */
142 { termp_it_pre, termp_it_post }, /* It */
143 { termp_under_pre, NULL }, /* Ad */
144 { termp_an_pre, termp_an_post }, /* An */
145 { termp_under_pre, NULL }, /* Ar */
146 { termp_cd_pre, NULL }, /* Cd */
147 { termp_bold_pre, NULL }, /* Cm */
148 { NULL, NULL }, /* Dv */
149 { NULL, NULL }, /* Er */
150 { NULL, NULL }, /* Ev */
151 { termp_ex_pre, NULL }, /* Ex */
152 { termp_fa_pre, NULL }, /* Fa */
153 { termp_fd_pre, NULL }, /* Fd */
154 { termp_fl_pre, NULL }, /* Fl */
155 { termp_fn_pre, NULL }, /* Fn */
156 { termp_ft_pre, NULL }, /* Ft */
157 { termp_bold_pre, NULL }, /* Ic */
158 { termp_in_pre, termp_in_post }, /* In */
159 { termp_li_pre, NULL }, /* Li */
160 { termp_nd_pre, NULL }, /* Nd */
161 { termp_nm_pre, termp_nm_post }, /* Nm */
162 { termp_quote_pre, termp_quote_post }, /* Op */
163 { NULL, NULL }, /* Ot */
164 { termp_under_pre, NULL }, /* Pa */
165 { termp_rv_pre, NULL }, /* Rv */
166 { NULL, NULL }, /* St */
167 { termp_under_pre, NULL }, /* Va */
168 { termp_vt_pre, NULL }, /* Vt */
169 { termp_xr_pre, NULL }, /* Xr */
170 { termp__a_pre, termp____post }, /* %A */
171 { termp_under_pre, termp____post }, /* %B */
172 { NULL, termp____post }, /* %D */
173 { termp_under_pre, termp____post }, /* %I */
174 { termp_under_pre, termp____post }, /* %J */
175 { NULL, termp____post }, /* %N */
176 { NULL, termp____post }, /* %O */
177 { NULL, termp____post }, /* %P */
178 { NULL, termp____post }, /* %R */
179 { termp__t_pre, termp__t_post }, /* %T */
180 { NULL, termp____post }, /* %V */
181 { NULL, NULL }, /* Ac */
182 { termp_quote_pre, termp_quote_post }, /* Ao */
183 { termp_quote_pre, termp_quote_post }, /* Aq */
184 { NULL, NULL }, /* At */
185 { NULL, NULL }, /* Bc */
186 { termp_bf_pre, NULL }, /* Bf */
187 { termp_quote_pre, termp_quote_post }, /* Bo */
188 { termp_quote_pre, termp_quote_post }, /* Bq */
189 { termp_xx_pre, NULL }, /* Bsx */
190 { termp_bx_pre, NULL }, /* Bx */
191 { NULL, NULL }, /* Db */
192 { NULL, NULL }, /* Dc */
193 { termp_quote_pre, termp_quote_post }, /* Do */
194 { termp_quote_pre, termp_quote_post }, /* Dq */
195 { NULL, NULL }, /* Ec */ /* FIXME: no space */
196 { NULL, NULL }, /* Ef */
197 { termp_under_pre, NULL }, /* Em */
198 { NULL, NULL }, /* Eo */
199 { termp_xx_pre, NULL }, /* Fx */
200 { termp_bold_pre, NULL }, /* Ms */
201 { termp_igndelim_pre, NULL }, /* No */
202 { termp_ns_pre, NULL }, /* Ns */
203 { termp_xx_pre, NULL }, /* Nx */
204 { termp_xx_pre, NULL }, /* Ox */
205 { NULL, NULL }, /* Pc */
206 { termp_igndelim_pre, termp_pf_post }, /* Pf */
207 { termp_quote_pre, termp_quote_post }, /* Po */
208 { termp_quote_pre, termp_quote_post }, /* Pq */
209 { NULL, NULL }, /* Qc */
210 { termp_quote_pre, termp_quote_post }, /* Ql */
211 { termp_quote_pre, termp_quote_post }, /* Qo */
212 { termp_quote_pre, termp_quote_post }, /* Qq */
213 { NULL, NULL }, /* Re */
214 { termp_rs_pre, NULL }, /* Rs */
215 { NULL, NULL }, /* Sc */
216 { termp_quote_pre, termp_quote_post }, /* So */
217 { termp_quote_pre, termp_quote_post }, /* Sq */
218 { termp_sm_pre, NULL }, /* Sm */
219 { termp_under_pre, NULL }, /* Sx */
220 { termp_bold_pre, NULL }, /* Sy */
221 { NULL, NULL }, /* Tn */
222 { termp_xx_pre, NULL }, /* Ux */
223 { NULL, NULL }, /* Xc */
224 { NULL, NULL }, /* Xo */
225 { termp_fo_pre, termp_fo_post }, /* Fo */
226 { NULL, NULL }, /* Fc */
227 { termp_quote_pre, termp_quote_post }, /* Oo */
228 { NULL, NULL }, /* Oc */
229 { termp_bk_pre, termp_bk_post }, /* Bk */
230 { NULL, NULL }, /* Ek */
231 { termp_bt_pre, NULL }, /* Bt */
232 { NULL, NULL }, /* Hf */
233 { NULL, NULL }, /* Fr */
234 { termp_ud_pre, NULL }, /* Ud */
235 { NULL, termp_lb_post }, /* Lb */
236 { termp_sp_pre, NULL }, /* Lp */
237 { termp_lk_pre, NULL }, /* Lk */
238 { termp_under_pre, NULL }, /* Mt */
239 { termp_quote_pre, termp_quote_post }, /* Brq */
240 { termp_quote_pre, termp_quote_post }, /* Bro */
241 { NULL, NULL }, /* Brc */
242 { NULL, termp____post }, /* %C */
243 { NULL, NULL }, /* Es */ /* TODO */
244 { NULL, NULL }, /* En */ /* TODO */
245 { termp_xx_pre, NULL }, /* Dx */
246 { NULL, termp____post }, /* %Q */
247 { termp_sp_pre, NULL }, /* br */
248 { termp_sp_pre, NULL }, /* sp */
249 { termp_under_pre, termp____post }, /* %U */
250 { NULL, NULL }, /* Ta */
251 };
252
253
254 void
255 terminal_mdoc(void *arg, const struct mdoc *mdoc)
256 {
257 const struct mdoc_node *n;
258 const struct mdoc_meta *m;
259 struct termp *p;
260
261 p = (struct termp *)arg;
262
263 p->overstep = 0;
264 p->maxrmargin = p->defrmargin;
265 p->tabwidth = term_len(p, 5);
266
267 if (NULL == p->symtab)
268 switch (p->enc) {
269 case (TERMENC_ASCII):
270 p->symtab = chars_init(CHARS_ASCII);
271 break;
272 default:
273 abort();
274 /* NOTREACHED */
275 }
276
277 n = mdoc_node(mdoc);
278 m = mdoc_meta(mdoc);
279
280 term_begin(p, print_mdoc_head, print_mdoc_foot, m);
281
282 if (n->child)
283 print_mdoc_nodelist(p, NULL, m, n->child);
284
285 term_end(p);
286 }
287
288
289 static void
290 print_mdoc_nodelist(DECL_ARGS)
291 {
292
293 print_mdoc_node(p, pair, m, n);
294 if (n->next)
295 print_mdoc_nodelist(p, pair, m, n->next);
296 }
297
298
299 /* ARGSUSED */
300 static void
301 print_mdoc_node(DECL_ARGS)
302 {
303 int chld;
304 const void *font;
305 struct termpair npair;
306 size_t offset, rmargin;
307
308 chld = 1;
309 offset = p->offset;
310 rmargin = p->rmargin;
311 font = term_fontq(p);
312
313 memset(&npair, 0, sizeof(struct termpair));
314 npair.ppair = pair;
315
316 /*
317 * Keeps only work until the end of a line. If a keep was
318 * invoked in a prior line, revert it to PREKEEP.
319 *
320 * Also let SYNPRETTY sections behave as if they were wrapped
321 * in a `Bk' block.
322 */
323
324 if (TERMP_KEEP & p->flags || MDOC_SYNPRETTY & n->flags) {
325 if (n->prev && n->prev->line != n->line) {
326 p->flags &= ~TERMP_KEEP;
327 p->flags |= TERMP_PREKEEP;
328 } else if (NULL == n->prev) {
329 if (n->parent && n->parent->line != n->line) {
330 p->flags &= ~TERMP_KEEP;
331 p->flags |= TERMP_PREKEEP;
332 }
333 }
334 }
335
336 /*
337 * Since SYNPRETTY sections aren't "turned off" with `Ek',
338 * we have to intuit whether we should disable formatting.
339 */
340
341 if ( ! (MDOC_SYNPRETTY & n->flags) &&
342 ((n->prev && MDOC_SYNPRETTY & n->prev->flags) ||
343 (n->parent && MDOC_SYNPRETTY & n->parent->flags)))
344 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);
345
346 /*
347 * After the keep flags have been set up, we may now
348 * produce output. Note that some pre-handlers do so.
349 */
350
351 switch (n->type) {
352 case (MDOC_TEXT):
353 if (' ' == *n->string && MDOC_LINE & n->flags)
354 term_newln(p);
355 term_word(p, n->string);
356 break;
357 case (MDOC_EQN):
358 break;
359 case (MDOC_TBL):
360 term_tbl(p, n->span);
361 break;
362 default:
363 if (termacts[n->tok].pre && ENDBODY_NOT == n->end)
364 chld = (*termacts[n->tok].pre)
365 (p, &npair, m, n);
366 break;
367 }
368
369 if (chld && n->child)
370 print_mdoc_nodelist(p, &npair, m, n->child);
371
372 term_fontpopq(p, font);
373
374 switch (n->type) {
375 case (MDOC_TEXT):
376 break;
377 case (MDOC_TBL):
378 break;
379 case (MDOC_EQN):
380 break;
381 default:
382 if ( ! termacts[n->tok].post || MDOC_ENDED & n->flags)
383 break;
384 (void)(*termacts[n->tok].post)(p, &npair, m, n);
385
386 /*
387 * Explicit end tokens not only call the post
388 * handler, but also tell the respective block
389 * that it must not call the post handler again.
390 */
391 if (ENDBODY_NOT != n->end)
392 n->pending->flags |= MDOC_ENDED;
393
394 /*
395 * End of line terminating an implicit block
396 * while an explicit block is still open.
397 * Continue the explicit block without spacing.
398 */
399 if (ENDBODY_NOSPACE == n->end)
400 p->flags |= TERMP_NOSPACE;
401 break;
402 }
403
404 if (MDOC_EOS & n->flags)
405 p->flags |= TERMP_SENTENCE;
406
407 p->offset = offset;
408 p->rmargin = rmargin;
409 }
410
411
412 static void
413 print_mdoc_foot(struct termp *p, const void *arg)
414 {
415 char buf[DATESIZ], os[BUFSIZ];
416 const struct mdoc_meta *m;
417
418 m = (const struct mdoc_meta *)arg;
419
420 term_fontrepl(p, TERMFONT_NONE);
421
422 /*
423 * Output the footer in new-groff style, that is, three columns
424 * with the middle being the manual date and flanking columns
425 * being the operating system:
426 *
427 * SYSTEM DATE SYSTEM
428 */
429
430 time2a(m->date, buf, DATESIZ);
431 strlcpy(os, m->os, BUFSIZ);
432
433 term_vspace(p);
434
435 p->offset = 0;
436 p->rmargin = (p->maxrmargin -
437 term_strlen(p, buf) + term_len(p, 1)) / 2;
438 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
439
440 term_word(p, os);
441 term_flushln(p);
442
443 p->offset = p->rmargin;
444 p->rmargin = p->maxrmargin - term_strlen(p, os);
445 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
446
447 term_word(p, buf);
448 term_flushln(p);
449
450 p->offset = p->rmargin;
451 p->rmargin = p->maxrmargin;
452 p->flags &= ~TERMP_NOBREAK;
453 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
454
455 term_word(p, os);
456 term_flushln(p);
457
458 p->offset = 0;
459 p->rmargin = p->maxrmargin;
460 p->flags = 0;
461 }
462
463
464 static void
465 print_mdoc_head(struct termp *p, const void *arg)
466 {
467 char buf[BUFSIZ], title[BUFSIZ];
468 const struct mdoc_meta *m;
469
470 m = (const struct mdoc_meta *)arg;
471
472 p->rmargin = p->maxrmargin;
473 p->offset = 0;
474
475 /*
476 * The header is strange. It has three components, which are
477 * really two with the first duplicated. It goes like this:
478 *
479 * IDENTIFIER TITLE IDENTIFIER
480 *
481 * The IDENTIFIER is NAME(SECTION), which is the command-name
482 * (if given, or "unknown" if not) followed by the manual page
483 * section. These are given in `Dt'. The TITLE is a free-form
484 * string depending on the manual volume. If not specified, it
485 * switches on the manual section.
486 */
487
488 assert(m->vol);
489 strlcpy(buf, m->vol, BUFSIZ);
490
491 if (m->arch) {
492 strlcat(buf, " (", BUFSIZ);
493 strlcat(buf, m->arch, BUFSIZ);
494 strlcat(buf, ")", BUFSIZ);
495 }
496
497 snprintf(title, BUFSIZ, "%s(%s)", m->title, m->msec);
498
499 p->offset = 0;
500 p->rmargin = (p->maxrmargin -
501 term_strlen(p, buf) + term_len(p, 1)) / 2;
502 p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
503
504 term_word(p, title);
505 term_flushln(p);
506
507 p->offset = p->rmargin;
508 p->rmargin = p->maxrmargin - term_strlen(p, title);
509 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
510
511 term_word(p, buf);
512 term_flushln(p);
513
514 p->offset = p->rmargin;
515 p->rmargin = p->maxrmargin;
516 p->flags &= ~TERMP_NOBREAK;
517 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
518
519 term_word(p, title);
520 term_flushln(p);
521
522 p->offset = 0;
523 p->rmargin = p->maxrmargin;
524 p->flags &= ~TERMP_NOSPACE;
525 }
526
527
528 static size_t
529 a2height(const struct termp *p, const char *v)
530 {
531 struct roffsu su;
532
533 assert(v);
534 if ( ! a2roffsu(v, &su, SCALE_VS))
535 SCALE_VS_INIT(&su, term_len(p, 1));
536
537 return(term_vspan(p, &su));
538 }
539
540
541 static size_t
542 a2width(const struct termp *p, const char *v)
543 {
544 struct roffsu su;
545
546 assert(v);
547 if ( ! a2roffsu(v, &su, SCALE_MAX))
548 SCALE_HS_INIT(&su, term_strlen(p, v));
549
550 return(term_hspan(p, &su));
551 }
552
553
554 static size_t
555 a2offs(const struct termp *p, const char *v)
556 {
557 struct roffsu su;
558
559 if ('\0' == *v)
560 return(0);
561 else if (0 == strcmp(v, "left"))
562 return(0);
563 else if (0 == strcmp(v, "indent"))
564 return(term_len(p, INDENT + 1));
565 else if (0 == strcmp(v, "indent-two"))
566 return(term_len(p, (INDENT + 1) * 2));
567 else if ( ! a2roffsu(v, &su, SCALE_MAX))
568 SCALE_HS_INIT(&su, term_strlen(p, v));
569
570 return(term_hspan(p, &su));
571 }
572
573
574 /*
575 * Determine how much space to print out before block elements of `It'
576 * (and thus `Bl') and `Bd'. And then go ahead and print that space,
577 * too.
578 */
579 static void
580 print_bvspace(struct termp *p,
581 const struct mdoc_node *bl,
582 const struct mdoc_node *n)
583 {
584 const struct mdoc_node *nn;
585
586 term_newln(p);
587
588 if (MDOC_Bd == bl->tok && bl->norm->Bd.comp)
589 return;
590 if (MDOC_Bl == bl->tok && bl->norm->Bl.comp)
591 return;
592
593 /* Do not vspace directly after Ss/Sh. */
594
595 for (nn = n; nn; nn = nn->parent) {
596 if (MDOC_BLOCK != nn->type)
597 continue;
598 if (MDOC_Ss == nn->tok)
599 return;
600 if (MDOC_Sh == nn->tok)
601 return;
602 if (NULL == nn->prev)
603 continue;
604 break;
605 }
606
607 /* A `-column' does not assert vspace within the list. */
608
609 if (MDOC_Bl == bl->tok && LIST_column == bl->norm->Bl.type)
610 if (n->prev && MDOC_It == n->prev->tok)
611 return;
612
613 /* A `-diag' without body does not vspace. */
614
615 if (MDOC_Bl == bl->tok && LIST_diag == bl->norm->Bl.type)
616 if (n->prev && MDOC_It == n->prev->tok) {
617 assert(n->prev->body);
618 if (NULL == n->prev->body->child)
619 return;
620 }
621
622 term_vspace(p);
623 }
624
625
626 /* ARGSUSED */
627 static int
628 termp_it_pre(DECL_ARGS)
629 {
630 const struct mdoc_node *bl, *nn;
631 char buf[7];
632 int i;
633 size_t width, offset, ncols, dcol;
634 enum mdoc_list type;
635
636 if (MDOC_BLOCK == n->type) {
637 print_bvspace(p, n->parent->parent, n);
638 return(1);
639 }
640
641 bl = n->parent->parent->parent;
642 type = bl->norm->Bl.type;
643
644 /*
645 * First calculate width and offset. This is pretty easy unless
646 * we're a -column list, in which case all prior columns must
647 * be accounted for.
648 */
649
650 width = offset = 0;
651
652 if (bl->norm->Bl.offs)
653 offset = a2offs(p, bl->norm->Bl.offs);
654
655 switch (type) {
656 case (LIST_column):
657 if (MDOC_HEAD == n->type)
658 break;
659
660 /*
661 * Imitate groff's column handling:
662 * - For each earlier column, add its width.
663 * - For less than 5 columns, add four more blanks per
664 * column.
665 * - For exactly 5 columns, add three more blank per
666 * column.
667 * - For more than 5 columns, add only one column.
668 */
669 ncols = bl->norm->Bl.ncols;
670
671 /* LINTED */
672 dcol = ncols < 5 ? term_len(p, 4) :
673 ncols == 5 ? term_len(p, 3) : term_len(p, 1);
674
675 /*
676 * Calculate the offset by applying all prior MDOC_BODY,
677 * so we stop at the MDOC_HEAD (NULL == nn->prev).
678 */
679
680 for (i = 0, nn = n->prev;
681 nn->prev && i < (int)ncols;
682 nn = nn->prev, i++)
683 offset += dcol + a2width
684 (p, bl->norm->Bl.cols[i]);
685
686 /*
687 * When exceeding the declared number of columns, leave
688 * the remaining widths at 0. This will later be
689 * adjusted to the default width of 10, or, for the last
690 * column, stretched to the right margin.
691 */
692 if (i >= (int)ncols)
693 break;
694
695 /*
696 * Use the declared column widths, extended as explained
697 * in the preceding paragraph.
698 */
699 width = a2width(p, bl->norm->Bl.cols[i]) + dcol;
700 break;
701 default:
702 if (NULL == bl->norm->Bl.width)
703 break;
704
705 /*
706 * Note: buffer the width by 2, which is groff's magic
707 * number for buffering single arguments. See the above
708 * handling for column for how this changes.
709 */
710 assert(bl->norm->Bl.width);
711 width = a2width(p, bl->norm->Bl.width) + term_len(p, 2);
712 break;
713 }
714
715 /*
716 * List-type can override the width in the case of fixed-head
717 * values (bullet, dash/hyphen, enum). Tags need a non-zero
718 * offset.
719 */
720
721 switch (type) {
722 case (LIST_bullet):
723 /* FALLTHROUGH */
724 case (LIST_dash):
725 /* FALLTHROUGH */
726 case (LIST_hyphen):
727 if (width < term_len(p, 4))
728 width = term_len(p, 4);
729 break;
730 case (LIST_enum):
731 if (width < term_len(p, 5))
732 width = term_len(p, 5);
733 break;
734 case (LIST_hang):
735 if (0 == width)
736 width = term_len(p, 8);
737 break;
738 case (LIST_column):
739 /* FALLTHROUGH */
740 case (LIST_tag):
741 if (0 == width)
742 width = term_len(p, 10);
743 break;
744 default:
745 break;
746 }
747
748 /*
749 * Whitespace control. Inset bodies need an initial space,
750 * while diagonal bodies need two.
751 */
752
753 p->flags |= TERMP_NOSPACE;
754
755 switch (type) {
756 case (LIST_diag):
757 if (MDOC_BODY == n->type)
758 term_word(p, "\\ \\ ");
759 break;
760 case (LIST_inset):
761 if (MDOC_BODY == n->type)
762 term_word(p, "\\ ");
763 break;
764 default:
765 break;
766 }
767
768 p->flags |= TERMP_NOSPACE;
769
770 switch (type) {
771 case (LIST_diag):
772 if (MDOC_HEAD == n->type)
773 term_fontpush(p, TERMFONT_BOLD);
774 break;
775 default:
776 break;
777 }
778
779 /*
780 * Pad and break control. This is the tricky part. These flags
781 * are documented in term_flushln() in term.c. Note that we're
782 * going to unset all of these flags in termp_it_post() when we
783 * exit.
784 */
785
786 switch (type) {
787 case (LIST_bullet):
788 /* FALLTHROUGH */
789 case (LIST_dash):
790 /* FALLTHROUGH */
791 case (LIST_enum):
792 /* FALLTHROUGH */
793 case (LIST_hyphen):
794 if (MDOC_HEAD == n->type)
795 p->flags |= TERMP_NOBREAK;
796 else
797 p->flags |= TERMP_NOLPAD;
798 break;
799 case (LIST_hang):
800 if (MDOC_HEAD == n->type)
801 p->flags |= TERMP_NOBREAK;
802 else
803 p->flags |= TERMP_NOLPAD;
804
805 if (MDOC_HEAD != n->type)
806 break;
807
808 /*
809 * This is ugly. If `-hang' is specified and the body
810 * is a `Bl' or `Bd', then we want basically to nullify
811 * the "overstep" effect in term_flushln() and treat
812 * this as a `-ohang' list instead.
813 */
814 if (n->next->child &&
815 (MDOC_Bl == n->next->child->tok ||
816 MDOC_Bd == n->next->child->tok)) {
817 p->flags &= ~TERMP_NOBREAK;
818 p->flags &= ~TERMP_NOLPAD;
819 } else
820 p->flags |= TERMP_HANG;
821 break;
822 case (LIST_tag):
823 if (MDOC_HEAD == n->type)
824 p->flags |= TERMP_NOBREAK | TERMP_TWOSPACE;
825 else
826 p->flags |= TERMP_NOLPAD;
827
828 if (MDOC_HEAD != n->type)
829 break;
830 if (NULL == n->next || NULL == n->next->child)
831 p->flags |= TERMP_DANGLE;
832 break;
833 case (LIST_column):
834 if (MDOC_HEAD == n->type)
835 break;
836
837 if (NULL == n->next)
838 p->flags &= ~TERMP_NOBREAK;
839 else
840 p->flags |= TERMP_NOBREAK;
841
842 assert(n->prev);
843 if (MDOC_BODY == n->prev->type)
844 p->flags |= TERMP_NOLPAD;
845
846 break;
847 case (LIST_diag):
848 if (MDOC_HEAD == n->type)
849 p->flags |= TERMP_NOBREAK;
850 break;
851 default:
852 break;
853 }
854
855 /*
856 * Margin control. Set-head-width lists have their right
857 * margins shortened. The body for these lists has the offset
858 * necessarily lengthened. Everybody gets the offset.
859 */
860
861 p->offset += offset;
862
863 switch (type) {
864 case (LIST_hang):
865 /*
866 * Same stipulation as above, regarding `-hang'. We
867 * don't want to recalculate rmargin and offsets when
868 * using `Bd' or `Bl' within `-hang' overstep lists.
869 */
870 if (MDOC_HEAD == n->type && n->next->child &&
871 (MDOC_Bl == n->next->child->tok ||
872 MDOC_Bd == n->next->child->tok))
873 break;
874 /* FALLTHROUGH */
875 case (LIST_bullet):
876 /* FALLTHROUGH */
877 case (LIST_dash):
878 /* FALLTHROUGH */
879 case (LIST_enum):
880 /* FALLTHROUGH */
881 case (LIST_hyphen):
882 /* FALLTHROUGH */
883 case (LIST_tag):
884 assert(width);
885 if (MDOC_HEAD == n->type)
886 p->rmargin = p->offset + width;
887 else
888 p->offset += width;
889 break;
890 case (LIST_column):
891 assert(width);
892 p->rmargin = p->offset + width;
893 /*
894 * XXX - this behaviour is not documented: the
895 * right-most column is filled to the right margin.
896 */
897 if (MDOC_HEAD == n->type)
898 break;
899 if (NULL == n->next && p->rmargin < p->maxrmargin)
900 p->rmargin = p->maxrmargin;
901 break;
902 default:
903 break;
904 }
905
906 /*
907 * The dash, hyphen, bullet and enum lists all have a special
908 * HEAD character (temporarily bold, in some cases).
909 */
910
911 if (MDOC_HEAD == n->type)
912 switch (type) {
913 case (LIST_bullet):
914 term_fontpush(p, TERMFONT_BOLD);
915 term_word(p, "\\[bu]");
916 term_fontpop(p);
917 break;
918 case (LIST_dash):
919 /* FALLTHROUGH */
920 case (LIST_hyphen):
921 term_fontpush(p, TERMFONT_BOLD);
922 term_word(p, "\\(hy");
923 term_fontpop(p);
924 break;
925 case (LIST_enum):
926 (pair->ppair->ppair->count)++;
927 snprintf(buf, sizeof(buf), "%d.",
928 pair->ppair->ppair->count);
929 term_word(p, buf);
930 break;
931 default:
932 break;
933 }
934
935 /*
936 * If we're not going to process our children, indicate so here.
937 */
938
939 switch (type) {
940 case (LIST_bullet):
941 /* FALLTHROUGH */
942 case (LIST_item):
943 /* FALLTHROUGH */
944 case (LIST_dash):
945 /* FALLTHROUGH */
946 case (LIST_hyphen):
947 /* FALLTHROUGH */
948 case (LIST_enum):
949 if (MDOC_HEAD == n->type)
950 return(0);
951 break;
952 case (LIST_column):
953 if (MDOC_HEAD == n->type)
954 return(0);
955 break;
956 default:
957 break;
958 }
959
960 return(1);
961 }
962
963
964 /* ARGSUSED */
965 static void
966 termp_it_post(DECL_ARGS)
967 {
968 enum mdoc_list type;
969
970 if (MDOC_BLOCK == n->type)
971 return;
972
973 type = n->parent->parent->parent->norm->Bl.type;
974
975 switch (type) {
976 case (LIST_item):
977 /* FALLTHROUGH */
978 case (LIST_diag):
979 /* FALLTHROUGH */
980 case (LIST_inset):
981 if (MDOC_BODY == n->type)
982 term_newln(p);
983 break;
984 case (LIST_column):
985 if (MDOC_BODY == n->type)
986 term_flushln(p);
987 break;
988 default:
989 term_newln(p);
990 break;
991 }
992
993 /*
994 * Now that our output is flushed, we can reset our tags. Since
995 * only `It' sets these flags, we're free to assume that nobody
996 * has munged them in the meanwhile.
997 */
998
999 p->flags &= ~TERMP_DANGLE;
1000 p->flags &= ~TERMP_NOBREAK;
1001 p->flags &= ~TERMP_TWOSPACE;
1002 p->flags &= ~TERMP_NOLPAD;
1003 p->flags &= ~TERMP_HANG;
1004 }
1005
1006
1007 /* ARGSUSED */
1008 static int
1009 termp_nm_pre(DECL_ARGS)
1010 {
1011
1012 if (MDOC_BLOCK == n->type)
1013 return(1);
1014
1015 if (MDOC_BODY == n->type) {
1016 if (NULL == n->child)
1017 return(0);
1018 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1019 p->offset += term_len(p, 1) +
1020 (NULL == n->prev->child ? term_strlen(p, m->name) :
1021 MDOC_TEXT == n->prev->child->type ?
1022 term_strlen(p, n->prev->child->string) :
1023 term_len(p, 5));
1024 return(1);
1025 }
1026
1027 if (NULL == n->child && NULL == m->name)
1028 return(0);
1029
1030 if (MDOC_HEAD == n->type)
1031 synopsis_pre(p, n->parent);
1032
1033 if (MDOC_HEAD == n->type && n->next->child) {
1034 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
1035 p->rmargin = p->offset + term_len(p, 1);
1036 if (NULL == n->child) {
1037 p->rmargin += term_strlen(p, m->name);
1038 } else if (MDOC_TEXT == n->child->type) {
1039 p->rmargin += term_strlen(p, n->child->string);
1040 if (n->child->next)
1041 p->flags |= TERMP_HANG;
1042 } else {
1043 p->rmargin += term_len(p, 5);
1044 p->flags |= TERMP_HANG;
1045 }
1046 }
1047
1048 term_fontpush(p, TERMFONT_BOLD);
1049 if (NULL == n->child)
1050 term_word(p, m->name);
1051 return(1);
1052 }
1053
1054
1055 /* ARGSUSED */
1056 static void
1057 termp_nm_post(DECL_ARGS)
1058 {
1059
1060 if (MDOC_HEAD == n->type && n->next->child) {
1061 term_flushln(p);
1062 p->flags &= ~(TERMP_NOBREAK | TERMP_HANG);
1063 } else if (MDOC_BODY == n->type && n->child) {
1064 term_flushln(p);
1065 p->flags &= ~TERMP_NOLPAD;
1066 }
1067 }
1068
1069
1070 /* ARGSUSED */
1071 static int
1072 termp_fl_pre(DECL_ARGS)
1073 {
1074
1075 term_fontpush(p, TERMFONT_BOLD);
1076 term_word(p, "\\-");
1077
1078 if (n->child)
1079 p->flags |= TERMP_NOSPACE;
1080 else if (n->next && n->next->line == n->line)
1081 p->flags |= TERMP_NOSPACE;
1082
1083 return(1);
1084 }
1085
1086
1087 /* ARGSUSED */
1088 static int
1089 termp__a_pre(DECL_ARGS)
1090 {
1091
1092 if (n->prev && MDOC__A == n->prev->tok)
1093 if (NULL == n->next || MDOC__A != n->next->tok)
1094 term_word(p, "and");
1095
1096 return(1);
1097 }
1098
1099
1100 /* ARGSUSED */
1101 static int
1102 termp_an_pre(DECL_ARGS)
1103 {
1104
1105 if (NULL == n->child)
1106 return(1);
1107
1108 /*
1109 * If not in the AUTHORS section, `An -split' will cause
1110 * newlines to occur before the author name. If in the AUTHORS
1111 * section, by default, the first `An' invocation is nosplit,
1112 * then all subsequent ones, regardless of whether interspersed
1113 * with other macros/text, are split. -split, in this case,
1114 * will override the condition of the implied first -nosplit.
1115 */
1116
1117 if (n->sec == SEC_AUTHORS) {
1118 if ( ! (TERMP_ANPREC & p->flags)) {
1119 if (TERMP_SPLIT & p->flags)
1120 term_newln(p);
1121 return(1);
1122 }
1123 if (TERMP_NOSPLIT & p->flags)
1124 return(1);
1125 term_newln(p);
1126 return(1);
1127 }
1128
1129 if (TERMP_SPLIT & p->flags)
1130 term_newln(p);
1131
1132 return(1);
1133 }
1134
1135
1136 /* ARGSUSED */
1137 static void
1138 termp_an_post(DECL_ARGS)
1139 {
1140
1141 if (n->child) {
1142 if (SEC_AUTHORS == n->sec)
1143 p->flags |= TERMP_ANPREC;
1144 return;
1145 }
1146
1147 if (AUTH_split == n->norm->An.auth) {
1148 p->flags &= ~TERMP_NOSPLIT;
1149 p->flags |= TERMP_SPLIT;
1150 } else if (AUTH_nosplit == n->norm->An.auth) {
1151 p->flags &= ~TERMP_SPLIT;
1152 p->flags |= TERMP_NOSPLIT;
1153 }
1154
1155 }
1156
1157
1158 /* ARGSUSED */
1159 static int
1160 termp_ns_pre(DECL_ARGS)
1161 {
1162
1163 if ( ! (MDOC_LINE & n->flags))
1164 p->flags |= TERMP_NOSPACE;
1165 return(1);
1166 }
1167
1168
1169 /* ARGSUSED */
1170 static int
1171 termp_rs_pre(DECL_ARGS)
1172 {
1173
1174 if (SEC_SEE_ALSO != n->sec)
1175 return(1);
1176 if (MDOC_BLOCK == n->type && n->prev)
1177 term_vspace(p);
1178 return(1);
1179 }
1180
1181
1182 /* ARGSUSED */
1183 static int
1184 termp_rv_pre(DECL_ARGS)
1185 {
1186 const struct mdoc_node *nn;
1187
1188 term_newln(p);
1189 term_word(p, "The");
1190
1191 for (nn = n->child; nn; nn = nn->next) {
1192 term_fontpush(p, TERMFONT_BOLD);
1193 term_word(p, nn->string);
1194 term_fontpop(p);
1195 p->flags |= TERMP_NOSPACE;
1196 if (nn->next && NULL == nn->next->next)
1197 term_word(p, "(), and");
1198 else if (nn->next)
1199 term_word(p, "(),");
1200 else
1201 term_word(p, "()");
1202 }
1203
1204 if (n->child && n->child->next)
1205 term_word(p, "functions return");
1206 else
1207 term_word(p, "function returns");
1208
1209 term_word(p, "the value 0 if successful; otherwise the value "
1210 "-1 is returned and the global variable");
1211
1212 term_fontpush(p, TERMFONT_UNDER);
1213 term_word(p, "errno");
1214 term_fontpop(p);
1215
1216 term_word(p, "is set to indicate the error.");
1217 p->flags |= TERMP_SENTENCE;
1218
1219 return(0);
1220 }
1221
1222
1223 /* ARGSUSED */
1224 static int
1225 termp_ex_pre(DECL_ARGS)
1226 {
1227 const struct mdoc_node *nn;
1228
1229 term_word(p, "The");
1230
1231 for (nn = n->child; nn; nn = nn->next) {
1232 term_fontpush(p, TERMFONT_BOLD);
1233 term_word(p, nn->string);
1234 term_fontpop(p);
1235 p->flags |= TERMP_NOSPACE;
1236 if (nn->next && NULL == nn->next->next)
1237 term_word(p, ", and");
1238 else if (nn->next)
1239 term_word(p, ",");
1240 else
1241 p->flags &= ~TERMP_NOSPACE;
1242 }
1243
1244 if (n->child && n->child->next)
1245 term_word(p, "utilities exit");
1246 else
1247 term_word(p, "utility exits");
1248
1249 term_word(p, "0 on success, and >0 if an error occurs.");
1250 p->flags |= TERMP_SENTENCE;
1251
1252 return(0);
1253 }
1254
1255
1256 /* ARGSUSED */
1257 static int
1258 termp_nd_pre(DECL_ARGS)
1259 {
1260
1261 if (MDOC_BODY != n->type)
1262 return(1);
1263
1264 #if defined(__OpenBSD__) || defined(__linux__)
1265 term_word(p, "\\(en");
1266 #else
1267 term_word(p, "\\(em");
1268 #endif
1269 return(1);
1270 }
1271
1272
1273 /* ARGSUSED */
1274 static int
1275 termp_bl_pre(DECL_ARGS)
1276 {
1277
1278 return(MDOC_HEAD != n->type);
1279 }
1280
1281
1282 /* ARGSUSED */
1283 static void
1284 termp_bl_post(DECL_ARGS)
1285 {
1286
1287 if (MDOC_BLOCK == n->type)
1288 term_newln(p);
1289 }
1290
1291
1292 /* ARGSUSED */
1293 static int
1294 termp_xr_pre(DECL_ARGS)
1295 {
1296 const struct mdoc_node *nn;
1297
1298 if (NULL == n->child)
1299 return(0);
1300
1301 assert(MDOC_TEXT == n->child->type);
1302 nn = n->child;
1303
1304 term_word(p, nn->string);
1305 if (NULL == (nn = nn->next))
1306 return(0);
1307 p->flags |= TERMP_NOSPACE;
1308 term_word(p, "(");
1309 term_word(p, nn->string);
1310 term_word(p, ")");
1311
1312 return(0);
1313 }
1314
1315
1316 /*
1317 * This decides how to assert whitespace before any of the SYNOPSIS set
1318 * of macros (which, as in the case of Ft/Fo and Ft/Fn, may contain
1319 * macro combos).
1320 */
1321 static void
1322 synopsis_pre(struct termp *p, const struct mdoc_node *n)
1323 {
1324 /*
1325 * Obviously, if we're not in a SYNOPSIS or no prior macros
1326 * exist, do nothing.
1327 */
1328 if (NULL == n->prev || ! (MDOC_SYNPRETTY & n->flags))
1329 return;
1330
1331 /*
1332 * If we're the second in a pair of like elements, emit our
1333 * newline and return. UNLESS we're `Fo', `Fn', `Fn', in which
1334 * case we soldier on.
1335 */
1336 if (n->prev->tok == n->tok &&
1337 MDOC_Ft != n->tok &&
1338 MDOC_Fo != n->tok &&
1339 MDOC_Fn != n->tok) {
1340 term_newln(p);
1341 return;
1342 }
1343
1344 /*
1345 * If we're one of the SYNOPSIS set and non-like pair-wise after
1346 * another (or Fn/Fo, which we've let slip through) then assert
1347 * vertical space, else only newline and move on.
1348 */
1349 switch (n->prev->tok) {
1350 case (MDOC_Fd):
1351 /* FALLTHROUGH */
1352 case (MDOC_Fn):
1353 /* FALLTHROUGH */
1354 case (MDOC_Fo):
1355 /* FALLTHROUGH */
1356 case (MDOC_In):
1357 /* FALLTHROUGH */
1358 case (MDOC_Vt):
1359 term_vspace(p);
1360 break;
1361 case (MDOC_Ft):
1362 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
1363 term_vspace(p);
1364 break;
1365 }
1366 /* FALLTHROUGH */
1367 default:
1368 term_newln(p);
1369 break;
1370 }
1371 }
1372
1373
1374 static int
1375 termp_vt_pre(DECL_ARGS)
1376 {
1377
1378 if (MDOC_ELEM == n->type) {
1379 synopsis_pre(p, n);
1380 return(termp_under_pre(p, pair, m, n));
1381 } else if (MDOC_BLOCK == n->type) {
1382 synopsis_pre(p, n);
1383 return(1);
1384 } else if (MDOC_HEAD == n->type)
1385 return(0);
1386
1387 return(termp_under_pre(p, pair, m, n));
1388 }
1389
1390
1391 /* ARGSUSED */
1392 static int
1393 termp_bold_pre(DECL_ARGS)
1394 {
1395
1396 term_fontpush(p, TERMFONT_BOLD);
1397 return(1);
1398 }
1399
1400
1401 /* ARGSUSED */
1402 static int
1403 termp_fd_pre(DECL_ARGS)
1404 {
1405
1406 synopsis_pre(p, n);
1407 return(termp_bold_pre(p, pair, m, n));
1408 }
1409
1410
1411 /* ARGSUSED */
1412 static int
1413 termp_sh_pre(DECL_ARGS)
1414 {
1415
1416 /* No vspace between consecutive `Sh' calls. */
1417
1418 switch (n->type) {
1419 case (MDOC_BLOCK):
1420 if (n->prev && MDOC_Sh == n->prev->tok)
1421 if (NULL == n->prev->body->child)
1422 break;
1423 term_vspace(p);
1424 break;
1425 case (MDOC_HEAD):
1426 term_fontpush(p, TERMFONT_BOLD);
1427 break;
1428 case (MDOC_BODY):
1429 p->offset = term_len(p, INDENT);
1430 break;
1431 default:
1432 break;
1433 }
1434 return(1);
1435 }
1436
1437
1438 /* ARGSUSED */
1439 static void
1440 termp_sh_post(DECL_ARGS)
1441 {
1442
1443 switch (n->type) {
1444 case (MDOC_HEAD):
1445 term_newln(p);
1446 break;
1447 case (MDOC_BODY):
1448 term_newln(p);
1449 p->offset = 0;
1450 break;
1451 default:
1452 break;
1453 }
1454 }
1455
1456
1457 /* ARGSUSED */
1458 static int
1459 termp_bt_pre(DECL_ARGS)
1460 {
1461
1462 term_word(p, "is currently in beta test.");
1463 p->flags |= TERMP_SENTENCE;
1464 return(0);
1465 }
1466
1467
1468 /* ARGSUSED */
1469 static void
1470 termp_lb_post(DECL_ARGS)
1471 {
1472
1473 if (SEC_LIBRARY == n->sec && MDOC_LINE & n->flags)
1474 term_newln(p);
1475 }
1476
1477
1478 /* ARGSUSED */
1479 static int
1480 termp_ud_pre(DECL_ARGS)
1481 {
1482
1483 term_word(p, "currently under development.");
1484 p->flags |= TERMP_SENTENCE;
1485 return(0);
1486 }
1487
1488
1489 /* ARGSUSED */
1490 static int
1491 termp_d1_pre(DECL_ARGS)
1492 {
1493
1494 if (MDOC_BLOCK != n->type)
1495 return(1);
1496 term_newln(p);
1497 p->offset += term_len(p, (INDENT + 1));
1498 return(1);
1499 }
1500
1501
1502 /* ARGSUSED */
1503 static void
1504 termp_d1_post(DECL_ARGS)
1505 {
1506
1507 if (MDOC_BLOCK != n->type)
1508 return;
1509 term_newln(p);
1510 }
1511
1512
1513 /* ARGSUSED */
1514 static int
1515 termp_ft_pre(DECL_ARGS)
1516 {
1517
1518 /* NB: MDOC_LINE does not effect this! */
1519 synopsis_pre(p, n);
1520 term_fontpush(p, TERMFONT_UNDER);
1521 return(1);
1522 }
1523
1524
1525 /* ARGSUSED */
1526 static int
1527 termp_fn_pre(DECL_ARGS)
1528 {
1529 const struct mdoc_node *nn;
1530
1531 synopsis_pre(p, n);
1532
1533 term_fontpush(p, TERMFONT_BOLD);
1534 term_word(p, n->child->string);
1535 term_fontpop(p);
1536
1537 p->flags |= TERMP_NOSPACE;
1538 term_word(p, "(");
1539
1540 for (nn = n->child->next; nn; nn = nn->next) {
1541 term_fontpush(p, TERMFONT_UNDER);
1542 term_word(p, nn->string);
1543 term_fontpop(p);
1544
1545 if (nn->next)
1546 term_word(p, ",");
1547 }
1548
1549 term_word(p, ")");
1550
1551 if (MDOC_SYNPRETTY & n->flags)
1552 term_word(p, ";");
1553
1554 return(0);
1555 }
1556
1557
1558 /* ARGSUSED */
1559 static int
1560 termp_fa_pre(DECL_ARGS)
1561 {
1562 const struct mdoc_node *nn;
1563
1564 if (n->parent->tok != MDOC_Fo) {
1565 term_fontpush(p, TERMFONT_UNDER);
1566 return(1);
1567 }
1568
1569 for (nn = n->child; nn; nn = nn->next) {
1570 term_fontpush(p, TERMFONT_UNDER);
1571 term_word(p, nn->string);
1572 term_fontpop(p);
1573
1574 if (nn->next)
1575 term_word(p, ",");
1576 }
1577
1578 if (n->child && n->next && n->next->tok == MDOC_Fa)
1579 term_word(p, ",");
1580
1581 return(0);
1582 }
1583
1584
1585 /* ARGSUSED */
1586 static int
1587 termp_bd_pre(DECL_ARGS)
1588 {
1589 size_t tabwidth, rm, rmax;
1590 const struct mdoc_node *nn;
1591
1592 if (MDOC_BLOCK == n->type) {
1593 print_bvspace(p, n, n);
1594 return(1);
1595 } else if (MDOC_HEAD == n->type)
1596 return(0);
1597
1598 if (n->norm->Bd.offs)
1599 p->offset += a2offs(p, n->norm->Bd.offs);
1600
1601 /*
1602 * If -ragged or -filled are specified, the block does nothing
1603 * but change the indentation. If -unfilled or -literal are
1604 * specified, text is printed exactly as entered in the display:
1605 * for macro lines, a newline is appended to the line. Blank
1606 * lines are allowed.
1607 */
1608
1609 if (DISP_literal != n->norm->Bd.type &&
1610 DISP_unfilled != n->norm->Bd.type)
1611 return(1);
1612
1613 tabwidth = p->tabwidth;
1614 if (DISP_literal == n->norm->Bd.type)
1615 p->tabwidth = term_len(p, 8);
1616
1617 rm = p->rmargin;
1618 rmax = p->maxrmargin;
1619 p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
1620
1621 for (nn = n->child; nn; nn = nn->next) {
1622 print_mdoc_node(p, pair, m, nn);
1623 /*
1624 * If the printed node flushes its own line, then we
1625 * needn't do it here as well. This is hacky, but the
1626 * notion of selective eoln whitespace is pretty dumb
1627 * anyway, so don't sweat it.
1628 */
1629 switch (nn->tok) {
1630 case (MDOC_Sm):
1631 /* FALLTHROUGH */
1632 case (MDOC_br):
1633 /* FALLTHROUGH */
1634 case (MDOC_sp):
1635 /* FALLTHROUGH */
1636 case (MDOC_Bl):
1637 /* FALLTHROUGH */
1638 case (MDOC_D1):
1639 /* FALLTHROUGH */
1640 case (MDOC_Dl):
1641 /* FALLTHROUGH */
1642 case (MDOC_Lp):
1643 /* FALLTHROUGH */
1644 case (MDOC_Pp):
1645 continue;
1646 default:
1647 break;
1648 }
1649 if (nn->next && nn->next->line == nn->line)
1650 continue;
1651 term_flushln(p);
1652 p->flags |= TERMP_NOSPACE;
1653 }
1654
1655 p->tabwidth = tabwidth;
1656 p->rmargin = rm;
1657 p->maxrmargin = rmax;
1658 return(0);
1659 }
1660
1661
1662 /* ARGSUSED */
1663 static void
1664 termp_bd_post(DECL_ARGS)
1665 {
1666 size_t rm, rmax;
1667
1668 if (MDOC_BODY != n->type)
1669 return;
1670
1671 rm = p->rmargin;
1672 rmax = p->maxrmargin;
1673
1674 if (DISP_literal == n->norm->Bd.type ||
1675 DISP_unfilled == n->norm->Bd.type)
1676 p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
1677
1678 p->flags |= TERMP_NOSPACE;
1679 term_newln(p);
1680
1681 p->rmargin = rm;
1682 p->maxrmargin = rmax;
1683 }
1684
1685
1686 /* ARGSUSED */
1687 static int
1688 termp_bx_pre(DECL_ARGS)
1689 {
1690
1691 if (NULL != (n = n->child)) {
1692 term_word(p, n->string);
1693 p->flags |= TERMP_NOSPACE;
1694 term_word(p, "BSD");
1695 } else {
1696 term_word(p, "BSD");
1697 return(0);
1698 }
1699
1700 if (NULL != (n = n->next)) {
1701 p->flags |= TERMP_NOSPACE;
1702 term_word(p, "-");
1703 p->flags |= TERMP_NOSPACE;
1704 term_word(p, n->string);
1705 }
1706
1707 return(0);
1708 }
1709
1710
1711 /* ARGSUSED */
1712 static int
1713 termp_xx_pre(DECL_ARGS)
1714 {
1715 const char *pp;
1716
1717 pp = NULL;
1718 switch (n->tok) {
1719 case (MDOC_Bsx):
1720 pp = "BSD/OS";
1721 break;
1722 case (MDOC_Dx):
1723 pp = "DragonFly";
1724 break;
1725 case (MDOC_Fx):
1726 pp = "FreeBSD";
1727 break;
1728 case (MDOC_Nx):
1729 pp = "NetBSD";
1730 break;
1731 case (MDOC_Ox):
1732 pp = "OpenBSD";
1733 break;
1734 case (MDOC_Ux):
1735 pp = "UNIX";
1736 break;
1737 default:
1738 break;
1739 }
1740
1741 term_word(p, pp);
1742 if (n->child) {
1743 p->flags |= TERMP_KEEP;
1744 term_word(p, n->child->string);
1745 p->flags &= ~TERMP_KEEP;
1746 }
1747 return(0);
1748 }
1749
1750
1751 /* ARGSUSED */
1752 static int
1753 termp_igndelim_pre(DECL_ARGS)
1754 {
1755
1756 p->flags |= TERMP_IGNDELIM;
1757 return(1);
1758 }
1759
1760
1761 /* ARGSUSED */
1762 static void
1763 termp_pf_post(DECL_ARGS)
1764 {
1765
1766 p->flags |= TERMP_NOSPACE;
1767 }
1768
1769
1770 /* ARGSUSED */
1771 static int
1772 termp_ss_pre(DECL_ARGS)
1773 {
1774
1775 switch (n->type) {
1776 case (MDOC_BLOCK):
1777 term_newln(p);
1778 if (n->prev)
1779 term_vspace(p);
1780 break;
1781 case (MDOC_HEAD):
1782 term_fontpush(p, TERMFONT_BOLD);
1783 p->offset = term_len(p, HALFINDENT);
1784 break;
1785 default:
1786 break;
1787 }
1788
1789 return(1);
1790 }
1791
1792
1793 /* ARGSUSED */
1794 static void
1795 termp_ss_post(DECL_ARGS)
1796 {
1797
1798 if (MDOC_HEAD == n->type)
1799 term_newln(p);
1800 }
1801
1802
1803 /* ARGSUSED */
1804 static int
1805 termp_cd_pre(DECL_ARGS)
1806 {
1807
1808 synopsis_pre(p, n);
1809 term_fontpush(p, TERMFONT_BOLD);
1810 return(1);
1811 }
1812
1813
1814 /* ARGSUSED */
1815 static int
1816 termp_in_pre(DECL_ARGS)
1817 {
1818
1819 synopsis_pre(p, n);
1820
1821 if (MDOC_SYNPRETTY & n->flags && MDOC_LINE & n->flags) {
1822 term_fontpush(p, TERMFONT_BOLD);
1823 term_word(p, "#include");
1824 term_word(p, "<");
1825 } else {
1826 term_word(p, "<");
1827 term_fontpush(p, TERMFONT_UNDER);
1828 }
1829
1830 p->flags |= TERMP_NOSPACE;
1831 return(1);
1832 }
1833
1834
1835 /* ARGSUSED */
1836 static void
1837 termp_in_post(DECL_ARGS)
1838 {
1839
1840 if (MDOC_SYNPRETTY & n->flags)
1841 term_fontpush(p, TERMFONT_BOLD);
1842
1843 p->flags |= TERMP_NOSPACE;
1844 term_word(p, ">");
1845
1846 if (MDOC_SYNPRETTY & n->flags)
1847 term_fontpop(p);
1848 }
1849
1850
1851 /* ARGSUSED */
1852 static int
1853 termp_sp_pre(DECL_ARGS)
1854 {
1855 size_t i, len;
1856
1857 switch (n->tok) {
1858 case (MDOC_sp):
1859 len = n->child ? a2height(p, n->child->string) : 1;
1860 break;
1861 case (MDOC_br):
1862 len = 0;
1863 break;
1864 default:
1865 len = 1;
1866 break;
1867 }
1868
1869 if (0 == len)
1870 term_newln(p);
1871 for (i = 0; i < len; i++)
1872 term_vspace(p);
1873
1874 return(0);
1875 }
1876
1877
1878 /* ARGSUSED */
1879 static int
1880 termp_quote_pre(DECL_ARGS)
1881 {
1882
1883 if (MDOC_BODY != n->type && MDOC_ELEM != n->type)
1884 return(1);
1885
1886 switch (n->tok) {
1887 case (MDOC_Ao):
1888 /* FALLTHROUGH */
1889 case (MDOC_Aq):
1890 term_word(p, "<");
1891 break;
1892 case (MDOC_Bro):
1893 /* FALLTHROUGH */
1894 case (MDOC_Brq):
1895 term_word(p, "{");
1896 break;
1897 case (MDOC_Oo):
1898 /* FALLTHROUGH */
1899 case (MDOC_Op):
1900 /* FALLTHROUGH */
1901 case (MDOC_Bo):
1902 /* FALLTHROUGH */
1903 case (MDOC_Bq):
1904 term_word(p, "[");
1905 break;
1906 case (MDOC_Do):
1907 /* FALLTHROUGH */
1908 case (MDOC_Dq):
1909 term_word(p, "``");
1910 break;
1911 case (MDOC_Po):
1912 /* FALLTHROUGH */
1913 case (MDOC_Pq):
1914 term_word(p, "(");
1915 break;
1916 case (MDOC__T):
1917 /* FALLTHROUGH */
1918 case (MDOC_Qo):
1919 /* FALLTHROUGH */
1920 case (MDOC_Qq):
1921 term_word(p, "\"");
1922 break;
1923 case (MDOC_Ql):
1924 /* FALLTHROUGH */
1925 case (MDOC_So):
1926 /* FALLTHROUGH */
1927 case (MDOC_Sq):
1928 term_word(p, "`");
1929 break;
1930 default:
1931 abort();
1932 /* NOTREACHED */
1933 }
1934
1935 p->flags |= TERMP_NOSPACE;
1936 return(1);
1937 }
1938
1939
1940 /* ARGSUSED */
1941 static void
1942 termp_quote_post(DECL_ARGS)
1943 {
1944
1945 if (MDOC_BODY != n->type && MDOC_ELEM != n->type)
1946 return;
1947
1948 p->flags |= TERMP_NOSPACE;
1949
1950 switch (n->tok) {
1951 case (MDOC_Ao):
1952 /* FALLTHROUGH */
1953 case (MDOC_Aq):
1954 term_word(p, ">");
1955 break;
1956 case (MDOC_Bro):
1957 /* FALLTHROUGH */
1958 case (MDOC_Brq):
1959 term_word(p, "}");
1960 break;
1961 case (MDOC_Oo):
1962 /* FALLTHROUGH */
1963 case (MDOC_Op):
1964 /* FALLTHROUGH */
1965 case (MDOC_Bo):
1966 /* FALLTHROUGH */
1967 case (MDOC_Bq):
1968 term_word(p, "]");
1969 break;
1970 case (MDOC_Do):
1971 /* FALLTHROUGH */
1972 case (MDOC_Dq):
1973 term_word(p, "''");
1974 break;
1975 case (MDOC_Po):
1976 /* FALLTHROUGH */
1977 case (MDOC_Pq):
1978 term_word(p, ")");
1979 break;
1980 case (MDOC__T):
1981 /* FALLTHROUGH */
1982 case (MDOC_Qo):
1983 /* FALLTHROUGH */
1984 case (MDOC_Qq):
1985 term_word(p, "\"");
1986 break;
1987 case (MDOC_Ql):
1988 /* FALLTHROUGH */
1989 case (MDOC_So):
1990 /* FALLTHROUGH */
1991 case (MDOC_Sq):
1992 term_word(p, "'");
1993 break;
1994 default:
1995 abort();
1996 /* NOTREACHED */
1997 }
1998 }
1999
2000
2001 /* ARGSUSED */
2002 static int
2003 termp_fo_pre(DECL_ARGS)
2004 {
2005
2006 if (MDOC_BLOCK == n->type) {
2007 synopsis_pre(p, n);
2008 return(1);
2009 } else if (MDOC_BODY == n->type) {
2010 p->flags |= TERMP_NOSPACE;
2011 term_word(p, "(");
2012 return(1);
2013 }
2014
2015 if (NULL == n->child)
2016 return(0);
2017
2018 /* XXX: we drop non-initial arguments as per groff. */
2019
2020 assert(n->child->string);
2021 term_fontpush(p, TERMFONT_BOLD);
2022 term_word(p, n->child->string);
2023 return(0);
2024 }
2025
2026
2027 /* ARGSUSED */
2028 static void
2029 termp_fo_post(DECL_ARGS)
2030 {
2031
2032 if (MDOC_BODY != n->type)
2033 return;
2034
2035 term_word(p, ")");
2036
2037 if (MDOC_SYNPRETTY & n->flags)
2038 term_word(p, ";");
2039 }
2040
2041
2042 /* ARGSUSED */
2043 static int
2044 termp_bf_pre(DECL_ARGS)
2045 {
2046
2047 if (MDOC_HEAD == n->type)
2048 return(0);
2049 else if (MDOC_BLOCK != n->type)
2050 return(1);
2051
2052 if (FONT_Em == n->norm->Bf.font)
2053 term_fontpush(p, TERMFONT_UNDER);
2054 else if (FONT_Sy == n->norm->Bf.font)
2055 term_fontpush(p, TERMFONT_BOLD);
2056 else
2057 term_fontpush(p, TERMFONT_NONE);
2058
2059 return(1);
2060 }
2061
2062
2063 /* ARGSUSED */
2064 static int
2065 termp_sm_pre(DECL_ARGS)
2066 {
2067
2068 assert(n->child && MDOC_TEXT == n->child->type);
2069 if (0 == strcmp("on", n->child->string)) {
2070 if (p->col)
2071 p->flags &= ~TERMP_NOSPACE;
2072 p->flags &= ~TERMP_NONOSPACE;
2073 } else
2074 p->flags |= TERMP_NONOSPACE;
2075
2076 return(0);
2077 }
2078
2079
2080 /* ARGSUSED */
2081 static int
2082 termp_ap_pre(DECL_ARGS)
2083 {
2084
2085 p->flags |= TERMP_NOSPACE;
2086 term_word(p, "'");
2087 p->flags |= TERMP_NOSPACE;
2088 return(1);
2089 }
2090
2091
2092 /* ARGSUSED */
2093 static void
2094 termp____post(DECL_ARGS)
2095 {
2096
2097 /*
2098 * Handle lists of authors. In general, print each followed by
2099 * a comma. Don't print the comma if there are only two
2100 * authors.
2101 */
2102 if (MDOC__A == n->tok && n->next && MDOC__A == n->next->tok)
2103 if (NULL == n->next->next || MDOC__A != n->next->next->tok)
2104 if (NULL == n->prev || MDOC__A != n->prev->tok)
2105 return;
2106
2107 /* TODO: %U. */
2108
2109 if (NULL == n->parent || MDOC_Rs != n->parent->tok)
2110 return;
2111
2112 if (NULL == n->next) {
2113 term_word(p, ".");
2114 p->flags |= TERMP_SENTENCE;
2115 } else
2116 term_word(p, ",");
2117 }
2118
2119
2120 /* ARGSUSED */
2121 static int
2122 termp_li_pre(DECL_ARGS)
2123 {
2124
2125 term_fontpush(p, TERMFONT_NONE);
2126 return(1);
2127 }
2128
2129
2130 /* ARGSUSED */
2131 static int
2132 termp_lk_pre(DECL_ARGS)
2133 {
2134 const struct mdoc_node *nn, *sv;
2135
2136 term_fontpush(p, TERMFONT_UNDER);
2137
2138 nn = sv = n->child;
2139
2140 if (NULL == nn || NULL == nn->next)
2141 return(1);
2142
2143 for (nn = nn->next; nn; nn = nn->next)
2144 term_word(p, nn->string);
2145
2146 term_fontpop(p);
2147
2148 term_word(p, ":");
2149
2150 term_fontpush(p, TERMFONT_BOLD);
2151 term_word(p, sv->string);
2152 term_fontpop(p);
2153
2154 return(0);
2155 }
2156
2157
2158 /* ARGSUSED */
2159 static int
2160 termp_bk_pre(DECL_ARGS)
2161 {
2162
2163 switch (n->type) {
2164 case (MDOC_BLOCK):
2165 break;
2166 case (MDOC_HEAD):
2167 return(0);
2168 case (MDOC_BODY):
2169 if (n->parent->args || 0 == n->prev->nchild)
2170 p->flags |= TERMP_PREKEEP;
2171 break;
2172 default:
2173 abort();
2174 /* NOTREACHED */
2175 }
2176
2177 return(1);
2178 }
2179
2180
2181 /* ARGSUSED */
2182 static void
2183 termp_bk_post(DECL_ARGS)
2184 {
2185
2186 if (MDOC_BODY == n->type)
2187 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);
2188 }
2189
2190 /* ARGSUSED */
2191 static void
2192 termp__t_post(DECL_ARGS)
2193 {
2194
2195 /*
2196 * If we're in an `Rs' and there's a journal present, then quote
2197 * us instead of underlining us (for disambiguation).
2198 */
2199 if (n->parent && MDOC_Rs == n->parent->tok &&
2200 n->parent->norm->Rs.quote_T)
2201 termp_quote_post(p, pair, m, n);
2202
2203 termp____post(p, pair, m, n);
2204 }
2205
2206 /* ARGSUSED */
2207 static int
2208 termp__t_pre(DECL_ARGS)
2209 {
2210
2211 /*
2212 * If we're in an `Rs' and there's a journal present, then quote
2213 * us instead of underlining us (for disambiguation).
2214 */
2215 if (n->parent && MDOC_Rs == n->parent->tok &&
2216 n->parent->norm->Rs.quote_T)
2217 return(termp_quote_pre(p, pair, m, n));
2218
2219 term_fontpush(p, TERMFONT_UNDER);
2220 return(1);
2221 }
2222
2223 /* ARGSUSED */
2224 static int
2225 termp_under_pre(DECL_ARGS)
2226 {
2227
2228 term_fontpush(p, TERMFONT_UNDER);
2229 return(1);
2230 }
A git conversion mirror of mandoc.bsd.lv