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
39struct	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
54struct	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
61static	void		  print_man_nodelist(DECL_ARGS);
62static	void		  print_man_node(DECL_ARGS);
63static	void		  print_man_head(struct termp *,
64				const struct roff_meta *);
65static	void		  print_man_foot(struct termp *,
66				const struct roff_meta *);
67static	void		  print_bvspace(struct termp *,
68				const struct roff_node *, int);
69
70static	int		  pre_B(DECL_ARGS);
71static	int		  pre_DT(DECL_ARGS);
72static	int		  pre_HP(DECL_ARGS);
73static	int		  pre_I(DECL_ARGS);
74static	int		  pre_IP(DECL_ARGS);
75static	int		  pre_OP(DECL_ARGS);
76static	int		  pre_PD(DECL_ARGS);
77static	int		  pre_PP(DECL_ARGS);
78static	int		  pre_RS(DECL_ARGS);
79static	int		  pre_SH(DECL_ARGS);
80static	int		  pre_SS(DECL_ARGS);
81static	int		  pre_TP(DECL_ARGS);
82static	int		  pre_UR(DECL_ARGS);
83static	int		  pre_alternate(DECL_ARGS);
84static	int		  pre_ign(DECL_ARGS);
85static	int		  pre_in(DECL_ARGS);
86static	int		  pre_literal(DECL_ARGS);
87
88static	void		  post_IP(DECL_ARGS);
89static	void		  post_HP(DECL_ARGS);
90static	void		  post_RS(DECL_ARGS);
91static	void		  post_SH(DECL_ARGS);
92static	void		  post_SS(DECL_ARGS);
93static	void		  post_TP(DECL_ARGS);
94static	void		  post_UR(DECL_ARGS);
95
96static	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};
134static	const struct termact *termacts = __termacts - MAN_TH;
135
136
137void
138terminal_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 */
192static void
193print_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
212static int
213pre_ign(DECL_ARGS)
214{
215
216	return 0;
217}
218
219static int
220pre_I(DECL_ARGS)
221{
222
223	term_fontrepl(p, TERMFONT_UNDER);
224	return 1;
225}
226
227static int
228pre_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
254static int
255pre_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
270static int
271pre_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
324static int
325pre_B(DECL_ARGS)
326{
327
328	term_fontrepl(p, TERMFONT_BOLD);
329	return 1;
330}
331
332static int
333pre_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
354static int
355pre_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
396static int
397pre_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
405static int
406pre_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
445static void
446post_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
473static int
474pre_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
490static int
491pre_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
551static void
552post_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
571static int
572pre_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
641static void
642post_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
658static int
659pre_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
704static void
705post_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
720static int
721pre_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
766static void
767post_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
782static int
783pre_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
819static void
820post_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
840static int
841pre_UR(DECL_ARGS)
842{
843
844	return n->type != ROFFT_HEAD;
845}
846
847static void
848post_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
864static void
865print_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
926out:
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
954static void
955print_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
964static void
965print_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
1035static void
1036print_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}
1102