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