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