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