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