?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dhcpcd: update README.DRAGONFLY
[dragonfly.git] / contrib / mdocml / man_term.c
blobd289f2d12bfb5f3d6416a24e588cb4dd6b31eacf
1 /* $Id: man_term.c,v 1.236 2021/06/28 19:50:15 schwarze Exp $ */
2 /*
3 * Copyright (c) 2010-2015, 2017-2020 Ingo Schwarze <schwarze@openbsd.org>
4 * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
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 AUTHORS DISCLAIM ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS 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 * Plain text formatter for man(7), used by mandoc(1)
19 * for ASCII, UTF-8, PostScript, and PDF output.
20 */
21 #include "config.h"
22
23 #include <sys/types.h>
24
25 #include <assert.h>
26 #include <ctype.h>
27 #include <limits.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "mandoc_aux.h"
33 #include "mandoc.h"
34 #include "roff.h"
35 #include "man.h"
36 #include "out.h"
37 #include "term.h"
38 #include "term_tag.h"
39 #include "main.h"
40
41 #define MAXMARGINS 64 /* maximum number of indented scopes */
42
43 struct mtermp {
44 int lmargin[MAXMARGINS]; /* margins (incl. vis. page) */
45 int lmargincur; /* index of current margin */
46 int lmarginsz; /* actual number of nested margins */
47 size_t offset; /* default offset to visible page */
48 int pardist; /* vert. space before par., unit: [v] */
49 };
50
51 #define DECL_ARGS struct termp *p, \
52 struct mtermp *mt, \
53 struct roff_node *n, \
54 const struct roff_meta *meta
55
56 struct man_term_act {
57 int (*pre)(DECL_ARGS);
58 void (*post)(DECL_ARGS);
59 int flags;
60 #define MAN_NOTEXT (1 << 0) /* Never has text children. */
61 };
62
63 static void print_man_nodelist(DECL_ARGS);
64 static void print_man_node(DECL_ARGS);
65 static void print_man_head(struct termp *,
66 const struct roff_meta *);
67 static void print_man_foot(struct termp *,
68 const struct roff_meta *);
69 static void print_bvspace(struct termp *,
70 struct roff_node *, int);
71
72 static int pre_B(DECL_ARGS);
73 static int pre_DT(DECL_ARGS);
74 static int pre_HP(DECL_ARGS);
75 static int pre_I(DECL_ARGS);
76 static int pre_IP(DECL_ARGS);
77 static int pre_OP(DECL_ARGS);
78 static int pre_PD(DECL_ARGS);
79 static int pre_PP(DECL_ARGS);
80 static int pre_RS(DECL_ARGS);
81 static int pre_SH(DECL_ARGS);
82 static int pre_SS(DECL_ARGS);
83 static int pre_SY(DECL_ARGS);
84 static int pre_TP(DECL_ARGS);
85 static int pre_UR(DECL_ARGS);
86 static int pre_abort(DECL_ARGS);
87 static int pre_alternate(DECL_ARGS);
88 static int pre_ign(DECL_ARGS);
89 static int pre_in(DECL_ARGS);
90 static int pre_literal(DECL_ARGS);
91
92 static void post_IP(DECL_ARGS);
93 static void post_HP(DECL_ARGS);
94 static void post_RS(DECL_ARGS);
95 static void post_SH(DECL_ARGS);
96 static void post_SY(DECL_ARGS);
97 static void post_TP(DECL_ARGS);
98 static void post_UR(DECL_ARGS);
99
100 static const struct man_term_act man_term_acts[MAN_MAX - MAN_TH] = {
101 { NULL, NULL, 0 }, /* TH */
102 { pre_SH, post_SH, 0 }, /* SH */
103 { pre_SS, post_SH, 0 }, /* SS */
104 { pre_TP, post_TP, 0 }, /* TP */
105 { pre_TP, post_TP, 0 }, /* TQ */
106 { pre_abort, NULL, 0 }, /* LP */
107 { pre_PP, NULL, 0 }, /* PP */
108 { pre_abort, NULL, 0 }, /* P */
109 { pre_IP, post_IP, 0 }, /* IP */
110 { pre_HP, post_HP, 0 }, /* HP */
111 { NULL, NULL, 0 }, /* SM */
112 { pre_B, NULL, 0 }, /* SB */
113 { pre_alternate, NULL, 0 }, /* BI */
114 { pre_alternate, NULL, 0 }, /* IB */
115 { pre_alternate, NULL, 0 }, /* BR */
116 { pre_alternate, NULL, 0 }, /* RB */
117 { NULL, NULL, 0 }, /* R */
118 { pre_B, NULL, 0 }, /* B */
119 { pre_I, NULL, 0 }, /* I */
120 { pre_alternate, NULL, 0 }, /* IR */
121 { pre_alternate, NULL, 0 }, /* RI */
122 { NULL, NULL, 0 }, /* RE */
123 { pre_RS, post_RS, 0 }, /* RS */
124 { pre_DT, NULL, 0 }, /* DT */
125 { pre_ign, NULL, MAN_NOTEXT }, /* UC */
126 { pre_PD, NULL, MAN_NOTEXT }, /* PD */
127 { pre_ign, NULL, 0 }, /* AT */
128 { pre_in, NULL, MAN_NOTEXT }, /* in */
129 { pre_SY, post_SY, 0 }, /* SY */
130 { NULL, NULL, 0 }, /* YS */
131 { pre_OP, NULL, 0 }, /* OP */
132 { pre_literal, NULL, 0 }, /* EX */
133 { pre_literal, NULL, 0 }, /* EE */
134 { pre_UR, post_UR, 0 }, /* UR */
135 { NULL, NULL, 0 }, /* UE */
136 { pre_UR, post_UR, 0 }, /* MT */
137 { NULL, NULL, 0 }, /* ME */
138 };
139 static const struct man_term_act *man_term_act(enum roff_tok);
140
141
142 static const struct man_term_act *
143 man_term_act(enum roff_tok tok)
144 {
145 assert(tok >= MAN_TH && tok <= MAN_MAX);
146 return man_term_acts + (tok - MAN_TH);
147 }
148
149 void
150 terminal_man(void *arg, const struct roff_meta *man)
151 {
152 struct mtermp mt;
153 struct termp *p;
154 struct roff_node *n, *nc, *nn;
155 size_t save_defindent;
156
157 p = (struct termp *)arg;
158 save_defindent = p->defindent;
159 if (p->synopsisonly == 0 && p->defindent == 0)
160 p->defindent = 7;
161 p->tcol->rmargin = p->maxrmargin = p->defrmargin;
162 term_tab_set(p, NULL);
163 term_tab_set(p, "T");
164 term_tab_set(p, ".5i");
165
166 memset(&mt, 0, sizeof(mt));
167 mt.lmargin[mt.lmargincur] = term_len(p, p->defindent);
168 mt.offset = term_len(p, p->defindent);
169 mt.pardist = 1;
170
171 n = man->first->child;
172 if (p->synopsisonly) {
173 for (nn = NULL; n != NULL; n = n->next) {
174 if (n->tok != MAN_SH)
175 continue;
176 nc = n->child->child;
177 if (nc->type != ROFFT_TEXT)
178 continue;
179 if (strcmp(nc->string, "SYNOPSIS") == 0)
180 break;
181 if (nn == NULL && strcmp(nc->string, "NAME") == 0)
182 nn = n;
183 }
184 if (n == NULL)
185 n = nn;
186 p->flags |= TERMP_NOSPACE;
187 if (n != NULL && (n = n->child->next->child) != NULL)
188 print_man_nodelist(p, &mt, n, man);
189 term_newln(p);
190 } else {
191 term_begin(p, print_man_head, print_man_foot, man);
192 p->flags |= TERMP_NOSPACE;
193 if (n != NULL)
194 print_man_nodelist(p, &mt, n, man);
195 term_end(p);
196 }
197 p->defindent = save_defindent;
198 }
199
200 /*
201 * Printing leading vertical space before a block.
202 * This is used for the paragraph macros.
203 * The rules are pretty simple, since there's very little nesting going
204 * on here. Basically, if we're the first within another block (SS/SH),
205 * then don't emit vertical space. If we are (RS), then do. If not the
206 * first, print it.
207 */
208 static void
209 print_bvspace(struct termp *p, struct roff_node *n, int pardist)
210 {
211 struct roff_node *nch;
212 int i;
213
214 term_newln(p);
215
216 if (n->body != NULL &&
217 (nch = roff_node_child(n->body)) != NULL &&
218 nch->type == ROFFT_TBL)
219 return;
220
221 if (n->parent->tok != MAN_RS && roff_node_prev(n) == NULL)
222 return;
223
224 for (i = 0; i < pardist; i++)
225 term_vspace(p);
226 }
227
228
229 static int
230 pre_abort(DECL_ARGS)
231 {
232 abort();
233 }
234
235 static int
236 pre_ign(DECL_ARGS)
237 {
238 return 0;
239 }
240
241 static int
242 pre_I(DECL_ARGS)
243 {
244 term_fontrepl(p, TERMFONT_UNDER);
245 return 1;
246 }
247
248 static int
249 pre_literal(DECL_ARGS)
250 {
251 term_newln(p);
252
253 /*
254 * Unlike .IP and .TP, .HP does not have a HEAD.
255 * So in case a second call to term_flushln() is needed,
256 * indentation has to be set up explicitly.
257 */
258 if (n->parent->tok == MAN_HP && p->tcol->rmargin < p->maxrmargin) {
259 p->tcol->offset = p->tcol->rmargin;
260 p->tcol->rmargin = p->maxrmargin;
261 p->trailspace = 0;
262 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
263 p->flags |= TERMP_NOSPACE;
264 }
265 return 0;
266 }
267
268 static int
269 pre_PD(DECL_ARGS)
270 {
271 struct roffsu su;
272
273 n = n->child;
274 if (n == NULL) {
275 mt->pardist = 1;
276 return 0;
277 }
278 assert(n->type == ROFFT_TEXT);
279 if (a2roffsu(n->string, &su, SCALE_VS) != NULL)
280 mt->pardist = term_vspan(p, &su);
281 return 0;
282 }
283
284 static int
285 pre_alternate(DECL_ARGS)
286 {
287 enum termfont font[2];
288 struct roff_node *nn;
289 int i;
290
291 switch (n->tok) {
292 case MAN_RB:
293 font[0] = TERMFONT_NONE;
294 font[1] = TERMFONT_BOLD;
295 break;
296 case MAN_RI:
297 font[0] = TERMFONT_NONE;
298 font[1] = TERMFONT_UNDER;
299 break;
300 case MAN_BR:
301 font[0] = TERMFONT_BOLD;
302 font[1] = TERMFONT_NONE;
303 break;
304 case MAN_BI:
305 font[0] = TERMFONT_BOLD;
306 font[1] = TERMFONT_UNDER;
307 break;
308 case MAN_IR:
309 font[0] = TERMFONT_UNDER;
310 font[1] = TERMFONT_NONE;
311 break;
312 case MAN_IB:
313 font[0] = TERMFONT_UNDER;
314 font[1] = TERMFONT_BOLD;
315 break;
316 default:
317 abort();
318 }
319 for (i = 0, nn = n->child; nn != NULL; nn = nn->next, i = 1 - i) {
320 term_fontrepl(p, font[i]);
321 assert(nn->type == ROFFT_TEXT);
322 term_word(p, nn->string);
323 if (nn->flags & NODE_EOS)
324 p->flags |= TERMP_SENTENCE;
325 if (nn->next != NULL)
326 p->flags |= TERMP_NOSPACE;
327 }
328 return 0;
329 }
330
331 static int
332 pre_B(DECL_ARGS)
333 {
334 term_fontrepl(p, TERMFONT_BOLD);
335 return 1;
336 }
337
338 static int
339 pre_OP(DECL_ARGS)
340 {
341 term_word(p, "[");
342 p->flags |= TERMP_KEEP | TERMP_NOSPACE;
343
344 if ((n = n->child) != NULL) {
345 term_fontrepl(p, TERMFONT_BOLD);
346 term_word(p, n->string);
347 }
348 if (n != NULL && n->next != NULL) {
349 term_fontrepl(p, TERMFONT_UNDER);
350 term_word(p, n->next->string);
351 }
352 term_fontrepl(p, TERMFONT_NONE);
353 p->flags &= ~TERMP_KEEP;
354 p->flags |= TERMP_NOSPACE;
355 term_word(p, "]");
356 return 0;
357 }
358
359 static int
360 pre_in(DECL_ARGS)
361 {
362 struct roffsu su;
363 const char *cp;
364 size_t v;
365 int less;
366
367 term_newln(p);
368
369 if (n->child == NULL) {
370 p->tcol->offset = mt->offset;
371 return 0;
372 }
373
374 cp = n->child->string;
375 less = 0;
376
377 if (*cp == '-')
378 less = -1;
379 else if (*cp == '+')
380 less = 1;
381 else
382 cp--;
383
384 if (a2roffsu(++cp, &su, SCALE_EN) == NULL)
385 return 0;
386
387 v = term_hen(p, &su);
388
389 if (less < 0)
390 p->tcol->offset -= p->tcol->offset > v ? v : p->tcol->offset;
391 else if (less > 0)
392 p->tcol->offset += v;
393 else
394 p->tcol->offset = v;
395 if (p->tcol->offset > SHRT_MAX)
396 p->tcol->offset = term_len(p, p->defindent);
397
398 return 0;
399 }
400
401 static int
402 pre_DT(DECL_ARGS)
403 {
404 term_tab_set(p, NULL);
405 term_tab_set(p, "T");
406 term_tab_set(p, ".5i");
407 return 0;
408 }
409
410 static int
411 pre_HP(DECL_ARGS)
412 {
413 struct roffsu su;
414 const struct roff_node *nn;
415 int len;
416
417 switch (n->type) {
418 case ROFFT_BLOCK:
419 print_bvspace(p, n, mt->pardist);
420 return 1;
421 case ROFFT_HEAD:
422 return 0;
423 case ROFFT_BODY:
424 break;
425 default:
426 abort();
427 }
428
429 if (n->child == NULL)
430 return 0;
431
432 if ((n->child->flags & NODE_NOFILL) == 0) {
433 p->flags |= TERMP_NOBREAK | TERMP_BRIND;
434 p->trailspace = 2;
435 }
436
437 /* Calculate offset. */
438
439 if ((nn = n->parent->head->child) != NULL &&
440 a2roffsu(nn->string, &su, SCALE_EN) != NULL) {
441 len = term_hen(p, &su);
442 if (len < 0 && (size_t)(-len) > mt->offset)
443 len = -mt->offset;
444 else if (len > SHRT_MAX)
445 len = term_len(p, p->defindent);
446 mt->lmargin[mt->lmargincur] = len;
447 } else
448 len = mt->lmargin[mt->lmargincur];
449
450 p->tcol->offset = mt->offset;
451 p->tcol->rmargin = mt->offset + len;
452 return 1;
453 }
454
455 static void
456 post_HP(DECL_ARGS)
457 {
458 switch (n->type) {
459 case ROFFT_BLOCK:
460 case ROFFT_HEAD:
461 break;
462 case ROFFT_BODY:
463 term_newln(p);
464
465 /*
466 * Compatibility with a groff bug.
467 * The .HP macro uses the undocumented .tag request
468 * which causes a line break and cancels no-space
469 * mode even if there isn't any output.
470 */
471
472 if (n->child == NULL)
473 term_vspace(p);
474
475 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
476 p->trailspace = 0;
477 p->tcol->offset = mt->offset;
478 p->tcol->rmargin = p->maxrmargin;
479 break;
480 default:
481 abort();
482 }
483 }
484
485 static int
486 pre_PP(DECL_ARGS)
487 {
488 switch (n->type) {
489 case ROFFT_BLOCK:
490 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
491 print_bvspace(p, n, mt->pardist);
492 break;
493 case ROFFT_HEAD:
494 return 0;
495 case ROFFT_BODY:
496 p->tcol->offset = mt->offset;
497 break;
498 default:
499 abort();
500 }
501 return 1;
502 }
503
504 static int
505 pre_IP(DECL_ARGS)
506 {
507 struct roffsu su;
508 const struct roff_node *nn;
509 int len;
510
511 switch (n->type) {
512 case ROFFT_BLOCK:
513 print_bvspace(p, n, mt->pardist);
514 return 1;
515 case ROFFT_HEAD:
516 p->flags |= TERMP_NOBREAK;
517 p->trailspace = 1;
518 break;
519 case ROFFT_BODY:
520 p->flags |= TERMP_NOSPACE;
521 break;
522 default:
523 abort();
524 }
525
526 /* Calculate the offset from the optional second argument. */
527 if ((nn = n->parent->head->child) != NULL &&
528 (nn = nn->next) != NULL &&
529 a2roffsu(nn->string, &su, SCALE_EN) != NULL) {
530 len = term_hen(p, &su);
531 if (len < 0 && (size_t)(-len) > mt->offset)
532 len = -mt->offset;
533 else if (len > SHRT_MAX)
534 len = term_len(p, p->defindent);
535 mt->lmargin[mt->lmargincur] = len;
536 } else
537 len = mt->lmargin[mt->lmargincur];
538
539 switch (n->type) {
540 case ROFFT_HEAD:
541 p->tcol->offset = mt->offset;
542 p->tcol->rmargin = mt->offset + len;
543 if (n->child != NULL)
544 print_man_node(p, mt, n->child, meta);
545 return 0;
546 case ROFFT_BODY:
547 p->tcol->offset = mt->offset + len;
548 p->tcol->rmargin = p->maxrmargin;
549 break;
550 default:
551 abort();
552 }
553 return 1;
554 }
555
556 static void
557 post_IP(DECL_ARGS)
558 {
559 switch (n->type) {
560 case ROFFT_BLOCK:
561 break;
562 case ROFFT_HEAD:
563 term_flushln(p);
564 p->flags &= ~TERMP_NOBREAK;
565 p->trailspace = 0;
566 p->tcol->rmargin = p->maxrmargin;
567 break;
568 case ROFFT_BODY:
569 term_newln(p);
570 p->tcol->offset = mt->offset;
571 break;
572 default:
573 abort();
574 }
575 }
576
577 static int
578 pre_TP(DECL_ARGS)
579 {
580 struct roffsu su;
581 struct roff_node *nn;
582 int len;
583
584 switch (n->type) {
585 case ROFFT_BLOCK:
586 if (n->tok == MAN_TP)
587 print_bvspace(p, n, mt->pardist);
588 return 1;
589 case ROFFT_HEAD:
590 p->flags |= TERMP_NOBREAK | TERMP_BRTRSP;
591 p->trailspace = 1;
592 break;
593 case ROFFT_BODY:
594 p->flags |= TERMP_NOSPACE;
595 break;
596 default:
597 abort();
598 }
599
600 /* Calculate offset. */
601
602 if ((nn = n->parent->head->child) != NULL &&
603 nn->string != NULL && ! (NODE_LINE & nn->flags) &&
604 a2roffsu(nn->string, &su, SCALE_EN) != NULL) {
605 len = term_hen(p, &su);
606 if (len < 0 && (size_t)(-len) > mt->offset)
607 len = -mt->offset;
608 else if (len > SHRT_MAX)
609 len = term_len(p, p->defindent);
610 mt->lmargin[mt->lmargincur] = len;
611 } else
612 len = mt->lmargin[mt->lmargincur];
613
614 switch (n->type) {
615 case ROFFT_HEAD:
616 p->tcol->offset = mt->offset;
617 p->tcol->rmargin = mt->offset + len;
618
619 /* Don't print same-line elements. */
620 nn = n->child;
621 while (nn != NULL && (nn->flags & NODE_LINE) == 0)
622 nn = nn->next;
623
624 while (nn != NULL) {
625 print_man_node(p, mt, nn, meta);
626 nn = nn->next;
627 }
628 return 0;
629 case ROFFT_BODY:
630 p->tcol->offset = mt->offset + len;
631 p->tcol->rmargin = p->maxrmargin;
632 p->trailspace = 0;
633 p->flags &= ~(TERMP_NOBREAK | TERMP_BRTRSP);
634 break;
635 default:
636 abort();
637 }
638 return 1;
639 }
640
641 static void
642 post_TP(DECL_ARGS)
643 {
644 switch (n->type) {
645 case ROFFT_BLOCK:
646 break;
647 case ROFFT_HEAD:
648 term_flushln(p);
649 break;
650 case ROFFT_BODY:
651 term_newln(p);
652 p->tcol->offset = mt->offset;
653 break;
654 default:
655 abort();
656 }
657 }
658
659 static int
660 pre_SS(DECL_ARGS)
661 {
662 int i;
663
664 switch (n->type) {
665 case ROFFT_BLOCK:
666 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
667 mt->offset = term_len(p, p->defindent);
668
669 /*
670 * No vertical space before the first subsection
671 * and after an empty subsection.
672 */
673
674 if ((n = roff_node_prev(n)) == NULL ||
675 (n->tok == MAN_SS && roff_node_child(n->body) == NULL))
676 break;
677
678 for (i = 0; i < mt->pardist; i++)
679 term_vspace(p);
680 break;
681 case ROFFT_HEAD:
682 term_fontrepl(p, TERMFONT_BOLD);
683 p->tcol->offset = term_len(p, 3);
684 p->tcol->rmargin = mt->offset;
685 p->trailspace = mt->offset;
686 p->flags |= TERMP_NOBREAK | TERMP_BRIND;
687 break;
688 case ROFFT_BODY:
689 p->tcol->offset = mt->offset;
690 p->tcol->rmargin = p->maxrmargin;
691 p->trailspace = 0;
692 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
693 break;
694 default:
695 break;
696 }
697 return 1;
698 }
699
700 static int
701 pre_SH(DECL_ARGS)
702 {
703 int i;
704
705 switch (n->type) {
706 case ROFFT_BLOCK:
707 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
708 mt->offset = term_len(p, p->defindent);
709
710 /*
711 * No vertical space before the first section
712 * and after an empty section.
713 */
714
715 if ((n = roff_node_prev(n)) == NULL ||
716 (n->tok == MAN_SH && roff_node_child(n->body) == NULL))
717 break;
718
719 for (i = 0; i < mt->pardist; i++)
720 term_vspace(p);
721 break;
722 case ROFFT_HEAD:
723 term_fontrepl(p, TERMFONT_BOLD);
724 p->tcol->offset = 0;
725 p->tcol->rmargin = mt->offset;
726 p->trailspace = mt->offset;
727 p->flags |= TERMP_NOBREAK | TERMP_BRIND;
728 break;
729 case ROFFT_BODY:
730 p->tcol->offset = mt->offset;
731 p->tcol->rmargin = p->maxrmargin;
732 p->trailspace = 0;
733 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
734 break;
735 default:
736 abort();
737 }
738 return 1;
739 }
740
741 static void
742 post_SH(DECL_ARGS)
743 {
744 switch (n->type) {
745 case ROFFT_BLOCK:
746 break;
747 case ROFFT_HEAD:
748 case ROFFT_BODY:
749 term_newln(p);
750 break;
751 default:
752 abort();
753 }
754 }
755
756 static int
757 pre_RS(DECL_ARGS)
758 {
759 struct roffsu su;
760
761 switch (n->type) {
762 case ROFFT_BLOCK:
763 term_newln(p);
764 return 1;
765 case ROFFT_HEAD:
766 return 0;
767 case ROFFT_BODY:
768 break;
769 default:
770 abort();
771 }
772
773 n = n->parent->head;
774 n->aux = SHRT_MAX + 1;
775 if (n->child == NULL)
776 n->aux = mt->lmargin[mt->lmargincur];
777 else if (a2roffsu(n->child->string, &su, SCALE_EN) != NULL)
778 n->aux = term_hen(p, &su);
779 if (n->aux < 0 && (size_t)(-n->aux) > mt->offset)
780 n->aux = -mt->offset;
781 else if (n->aux > SHRT_MAX)
782 n->aux = term_len(p, p->defindent);
783
784 mt->offset += n->aux;
785 p->tcol->offset = mt->offset;
786 p->tcol->rmargin = p->maxrmargin;
787
788 if (++mt->lmarginsz < MAXMARGINS)
789 mt->lmargincur = mt->lmarginsz;
790
791 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
792 return 1;
793 }
794
795 static void
796 post_RS(DECL_ARGS)
797 {
798 switch (n->type) {
799 case ROFFT_BLOCK:
800 case ROFFT_HEAD:
801 return;
802 case ROFFT_BODY:
803 break;
804 default:
805 abort();
806 }
807 term_newln(p);
808 mt->offset -= n->parent->head->aux;
809 p->tcol->offset = mt->offset;
810 if (--mt->lmarginsz < MAXMARGINS)
811 mt->lmargincur = mt->lmarginsz;
812 }
813
814 static int
815 pre_SY(DECL_ARGS)
816 {
817 const struct roff_node *nn;
818 int len;
819
820 switch (n->type) {
821 case ROFFT_BLOCK:
822 if ((nn = roff_node_prev(n)) == NULL || nn->tok != MAN_SY)
823 print_bvspace(p, n, mt->pardist);
824 return 1;
825 case ROFFT_HEAD:
826 case ROFFT_BODY:
827 break;
828 default:
829 abort();
830 }
831
832 nn = n->parent->head->child;
833 len = nn == NULL ? 1 : term_strlen(p, nn->string) + 1;
834
835 switch (n->type) {
836 case ROFFT_HEAD:
837 p->tcol->offset = mt->offset;
838 p->tcol->rmargin = mt->offset + len;
839 if (n->next->child == NULL ||
840 (n->next->child->flags & NODE_NOFILL) == 0)
841 p->flags |= TERMP_NOBREAK;
842 term_fontrepl(p, TERMFONT_BOLD);
843 break;
844 case ROFFT_BODY:
845 mt->lmargin[mt->lmargincur] = len;
846 p->tcol->offset = mt->offset + len;
847 p->tcol->rmargin = p->maxrmargin;
848 p->flags |= TERMP_NOSPACE;
849 break;
850 default:
851 abort();
852 }
853 return 1;
854 }
855
856 static void
857 post_SY(DECL_ARGS)
858 {
859 switch (n->type) {
860 case ROFFT_BLOCK:
861 break;
862 case ROFFT_HEAD:
863 term_flushln(p);
864 p->flags &= ~TERMP_NOBREAK;
865 break;
866 case ROFFT_BODY:
867 term_newln(p);
868 p->tcol->offset = mt->offset;
869 break;
870 default:
871 abort();
872 }
873 }
874
875 static int
876 pre_UR(DECL_ARGS)
877 {
878 return n->type != ROFFT_HEAD;
879 }
880
881 static void
882 post_UR(DECL_ARGS)
883 {
884 if (n->type != ROFFT_BLOCK)
885 return;
886
887 term_word(p, "<");
888 p->flags |= TERMP_NOSPACE;
889
890 if (n->child->child != NULL)
891 print_man_node(p, mt, n->child->child, meta);
892
893 p->flags |= TERMP_NOSPACE;
894 term_word(p, ">");
895 }
896
897 static void
898 print_man_node(DECL_ARGS)
899 {
900 const struct man_term_act *act;
901 int c;
902
903 if (n->flags & NODE_ID)
904 term_tag_write(n, p->line);
905
906 switch (n->type) {
907 case ROFFT_TEXT:
908 /*
909 * If we have a blank line, output a vertical space.
910 * If we have a space as the first character, break
911 * before printing the line's data.
912 */
913 if (*n->string == '\0') {
914 if (p->flags & TERMP_NONEWLINE)
915 term_newln(p);
916 else
917 term_vspace(p);
918 return;
919 } else if (*n->string == ' ' && n->flags & NODE_LINE &&
920 (p->flags & TERMP_NONEWLINE) == 0)
921 term_newln(p);
922 else if (n->flags & NODE_DELIMC)
923 p->flags |= TERMP_NOSPACE;
924
925 term_word(p, n->string);
926 goto out;
927 case ROFFT_COMMENT:
928 return;
929 case ROFFT_EQN:
930 if ( ! (n->flags & NODE_LINE))
931 p->flags |= TERMP_NOSPACE;
932 term_eqn(p, n->eqn);
933 if (n->next != NULL && ! (n->next->flags & NODE_LINE))
934 p->flags |= TERMP_NOSPACE;
935 return;
936 case ROFFT_TBL:
937 if (p->tbl.cols == NULL)
938 term_vspace(p);
939 term_tbl(p, n->span);
940 return;
941 default:
942 break;
943 }
944
945 if (n->tok < ROFF_MAX) {
946 roff_term_pre(p, n);
947 return;
948 }
949
950 act = man_term_act(n->tok);
951 if ((act->flags & MAN_NOTEXT) == 0 && n->tok != MAN_SM)
952 term_fontrepl(p, TERMFONT_NONE);
953
954 c = 1;
955 if (act->pre != NULL)
956 c = (*act->pre)(p, mt, n, meta);
957
958 if (c && n->child != NULL)
959 print_man_nodelist(p, mt, n->child, meta);
960
961 if (act->post != NULL)
962 (*act->post)(p, mt, n, meta);
963 if ((act->flags & MAN_NOTEXT) == 0 && n->tok != MAN_SM)
964 term_fontrepl(p, TERMFONT_NONE);
965
966 out:
967 /*
968 * If we're in a literal context, make sure that words
969 * together on the same line stay together. This is a
970 * POST-printing call, so we check the NEXT word. Since
971 * -man doesn't have nested macros, we don't need to be
972 * more specific than this.
973 */
974 if (n->flags & NODE_NOFILL &&
975 ! (p->flags & (TERMP_NOBREAK | TERMP_NONEWLINE)) &&
976 (n->next == NULL || n->next->flags & NODE_LINE)) {
977 p->flags |= TERMP_BRNEVER | TERMP_NOSPACE;
978 if (n->string != NULL && *n->string != '\0')
979 term_flushln(p);
980 else
981 term_newln(p);
982 p->flags &= ~TERMP_BRNEVER;
983 if (p->tcol->rmargin < p->maxrmargin &&
984 n->parent->tok == MAN_HP) {
985 p->tcol->offset = p->tcol->rmargin;
986 p->tcol->rmargin = p->maxrmargin;
987 }
988 }
989 if (n->flags & NODE_EOS)
990 p->flags |= TERMP_SENTENCE;
991 }
992
993 static void
994 print_man_nodelist(DECL_ARGS)
995 {
996 while (n != NULL) {
997 print_man_node(p, mt, n, meta);
998 n = n->next;
999 }
1000 }
1001
1002 static void
1003 print_man_foot(struct termp *p, const struct roff_meta *meta)
1004 {
1005 char *title;
1006 size_t datelen, titlen;
1007
1008 assert(meta->title);
1009 assert(meta->msec);
1010 assert(meta->date);
1011
1012 term_fontrepl(p, TERMFONT_NONE);
1013
1014 if (meta->hasbody)
1015 term_vspace(p);
1016
1017 /*
1018 * Temporary, undocumented option to imitate mdoc(7) output.
1019 * In the bottom right corner, use the operating system
1020 * instead of the title.
1021 */
1022
1023 if ( ! p->mdocstyle) {
1024 mandoc_asprintf(&title, "%s(%s)",
1025 meta->title, meta->msec);
1026 } else if (meta->os != NULL) {
1027 title = mandoc_strdup(meta->os);
1028 } else {
1029 title = mandoc_strdup("");
1030 }
1031 datelen = term_strlen(p, meta->date);
1032
1033 /* Bottom left corner: operating system. */
1034
1035 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
1036 p->trailspace = 1;
1037 p->tcol->offset = 0;
1038 p->tcol->rmargin = p->maxrmargin > datelen ?
1039 (p->maxrmargin + term_len(p, 1) - datelen) / 2 : 0;
1040
1041 if (meta->os)
1042 term_word(p, meta->os);
1043 term_flushln(p);
1044
1045 /* At the bottom in the middle: manual date. */
1046
1047 p->tcol->offset = p->tcol->rmargin;
1048 titlen = term_strlen(p, title);
1049 p->tcol->rmargin = p->maxrmargin > titlen ?
1050 p->maxrmargin - titlen : 0;
1051 p->flags |= TERMP_NOSPACE;
1052
1053 term_word(p, meta->date);
1054 term_flushln(p);
1055
1056 /* Bottom right corner: manual title and section. */
1057
1058 p->flags &= ~TERMP_NOBREAK;
1059 p->flags |= TERMP_NOSPACE;
1060 p->trailspace = 0;
1061 p->tcol->offset = p->tcol->rmargin;
1062 p->tcol->rmargin = p->maxrmargin;
1063
1064 term_word(p, title);
1065 term_flushln(p);
1066
1067 /*
1068 * Reset the terminal state for more output after the footer:
1069 * Some output modes, in particular PostScript and PDF, print
1070 * the header and the footer into a buffer such that it can be
1071 * reused for multiple output pages, then go on to format the
1072 * main text.
1073 */
1074
1075 p->tcol->offset = 0;
1076 p->flags = 0;
1077
1078 free(title);
1079 }
1080
1081 static void
1082 print_man_head(struct termp *p, const struct roff_meta *meta)
1083 {
1084 const char *volume;
1085 char *title;
1086 size_t vollen, titlen;
1087
1088 assert(meta->title);
1089 assert(meta->msec);
1090
1091 volume = NULL == meta->vol ? "" : meta->vol;
1092 vollen = term_strlen(p, volume);
1093
1094 /* Top left corner: manual title and section. */
1095
1096 mandoc_asprintf(&title, "%s(%s)", meta->title, meta->msec);
1097 titlen = term_strlen(p, title);
1098
1099 p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
1100 p->trailspace = 1;
1101 p->tcol->offset = 0;
1102 p->tcol->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ?
1103 (p->maxrmargin - vollen + term_len(p, 1)) / 2 :
1104 vollen < p->maxrmargin ? p->maxrmargin - vollen : 0;
1105
1106 term_word(p, title);
1107 term_flushln(p);
1108
1109 /* At the top in the middle: manual volume. */
1110
1111 p->flags |= TERMP_NOSPACE;
1112 p->tcol->offset = p->tcol->rmargin;
1113 p->tcol->rmargin = p->tcol->offset + vollen + titlen <
1114 p->maxrmargin ? p->maxrmargin - titlen : p->maxrmargin;
1115
1116 term_word(p, volume);
1117 term_flushln(p);
1118
1119 /* Top right corner: title and section, again. */
1120
1121 p->flags &= ~TERMP_NOBREAK;
1122 p->trailspace = 0;
1123 if (p->tcol->rmargin + titlen <= p->maxrmargin) {
1124 p->flags |= TERMP_NOSPACE;
1125 p->tcol->offset = p->tcol->rmargin;
1126 p->tcol->rmargin = p->maxrmargin;
1127 term_word(p, title);
1128 term_flushln(p);
1129 }
1130
1131 p->flags &= ~TERMP_NOSPACE;
1132 p->tcol->offset = 0;
1133 p->tcol->rmargin = p->maxrmargin;
1134
1135 /*
1136 * Groff prints three blank lines before the content.
1137 * Do the same, except in the temporary, undocumented
1138 * mode imitating mdoc(7) output.
1139 */
1140
1141 term_vspace(p);
1142 free(title);
1143 }
DragonFly BSD