1/*	$Id: man_html.c,v 1.145 2017/06/25 11:42:02 schwarze Exp $ */
2/*
3 * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2013, 2014, 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 <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27
28#include "mandoc_aux.h"
29#include "mandoc.h"
30#include "roff.h"
31#include "man.h"
32#include "out.h"
33#include "html.h"
34#include "main.h"
35
36/* FIXME: have PD set the default vspace width. */
37
38#define	INDENT		  5
39
40#define	MAN_ARGS	  const struct roff_meta *man, \
41			  const struct roff_node *n, \
42			  struct html *h
43
44struct	htmlman {
45	int		(*pre)(MAN_ARGS);
46	int		(*post)(MAN_ARGS);
47};
48
49static	void		  print_bvspace(struct html *,
50				const struct roff_node *);
51static	void		  print_man_head(MAN_ARGS);
52static	void		  print_man_nodelist(MAN_ARGS);
53static	void		  print_man_node(MAN_ARGS);
54static	int		  fillmode(struct html *, int);
55static	int		  a2width(const struct roff_node *,
56				struct roffsu *);
57static	int		  man_B_pre(MAN_ARGS);
58static	int		  man_HP_pre(MAN_ARGS);
59static	int		  man_IP_pre(MAN_ARGS);
60static	int		  man_I_pre(MAN_ARGS);
61static	int		  man_OP_pre(MAN_ARGS);
62static	int		  man_PP_pre(MAN_ARGS);
63static	int		  man_RS_pre(MAN_ARGS);
64static	int		  man_SH_pre(MAN_ARGS);
65static	int		  man_SM_pre(MAN_ARGS);
66static	int		  man_SS_pre(MAN_ARGS);
67static	int		  man_UR_pre(MAN_ARGS);
68static	int		  man_alt_pre(MAN_ARGS);
69static	int		  man_ign_pre(MAN_ARGS);
70static	int		  man_in_pre(MAN_ARGS);
71static	void		  man_root_post(MAN_ARGS);
72static	void		  man_root_pre(MAN_ARGS);
73
74static	const struct htmlman __mans[MAN_MAX - MAN_TH] = {
75	{ NULL, NULL }, /* TH */
76	{ man_SH_pre, NULL }, /* SH */
77	{ man_SS_pre, NULL }, /* SS */
78	{ man_IP_pre, NULL }, /* TP */
79	{ man_PP_pre, NULL }, /* LP */
80	{ man_PP_pre, NULL }, /* PP */
81	{ man_PP_pre, NULL }, /* P */
82	{ man_IP_pre, NULL }, /* IP */
83	{ man_HP_pre, NULL }, /* HP */
84	{ man_SM_pre, NULL }, /* SM */
85	{ man_SM_pre, NULL }, /* SB */
86	{ man_alt_pre, NULL }, /* BI */
87	{ man_alt_pre, NULL }, /* IB */
88	{ man_alt_pre, NULL }, /* BR */
89	{ man_alt_pre, NULL }, /* RB */
90	{ NULL, NULL }, /* R */
91	{ man_B_pre, NULL }, /* B */
92	{ man_I_pre, NULL }, /* I */
93	{ man_alt_pre, NULL }, /* IR */
94	{ man_alt_pre, NULL }, /* RI */
95	{ NULL, NULL }, /* nf */
96	{ NULL, NULL }, /* fi */
97	{ NULL, NULL }, /* RE */
98	{ man_RS_pre, NULL }, /* RS */
99	{ man_ign_pre, NULL }, /* DT */
100	{ man_ign_pre, NULL }, /* UC */
101	{ man_ign_pre, NULL }, /* PD */
102	{ man_ign_pre, NULL }, /* AT */
103	{ man_in_pre, NULL }, /* in */
104	{ man_OP_pre, NULL }, /* OP */
105	{ NULL, NULL }, /* EX */
106	{ NULL, NULL }, /* EE */
107	{ man_UR_pre, NULL }, /* UR */
108	{ NULL, NULL }, /* UE */
109	{ man_UR_pre, NULL }, /* MT */
110	{ NULL, NULL }, /* ME */
111};
112static	const struct htmlman *const mans = __mans - MAN_TH;
113
114
115/*
116 * Printing leading vertical space before a block.
117 * This is used for the paragraph macros.
118 * The rules are pretty simple, since there's very little nesting going
119 * on here.  Basically, if we're the first within another block (SS/SH),
120 * then don't emit vertical space.  If we are (RS), then do.  If not the
121 * first, print it.
122 */
123static void
124print_bvspace(struct html *h, const struct roff_node *n)
125{
126
127	if (n->body && n->body->child)
128		if (n->body->child->type == ROFFT_TBL)
129			return;
130
131	if (n->parent->type == ROFFT_ROOT || n->parent->tok != MAN_RS)
132		if (NULL == n->prev)
133			return;
134
135	print_paragraph(h);
136}
137
138void
139html_man(void *arg, const struct roff_man *man)
140{
141	struct html	*h;
142	struct tag	*t;
143
144	h = (struct html *)arg;
145
146	if ((h->oflags & HTML_FRAGMENT) == 0) {
147		print_gen_decls(h);
148		print_otag(h, TAG_HTML, "");
149		t = print_otag(h, TAG_HEAD, "");
150		print_man_head(&man->meta, man->first, h);
151		print_tagq(h, t);
152		print_otag(h, TAG_BODY, "");
153	}
154
155	man_root_pre(&man->meta, man->first, h);
156	t = print_otag(h, TAG_DIV, "c", "manual-text");
157	print_man_nodelist(&man->meta, man->first->child, h);
158	print_tagq(h, t);
159	man_root_post(&man->meta, man->first, h);
160	print_tagq(h, NULL);
161}
162
163static void
164print_man_head(MAN_ARGS)
165{
166	char	*cp;
167
168	print_gen_head(h);
169	mandoc_asprintf(&cp, "%s(%s)", man->title, man->msec);
170	print_otag(h, TAG_TITLE, "");
171	print_text(h, cp);
172	free(cp);
173}
174
175static void
176print_man_nodelist(MAN_ARGS)
177{
178
179	while (n != NULL) {
180		print_man_node(man, n, h);
181		n = n->next;
182	}
183}
184
185static void
186print_man_node(MAN_ARGS)
187{
188	static int	 want_fillmode = MAN_fi;
189	static int	 save_fillmode;
190
191	struct tag	*t;
192	int		 child;
193
194	/*
195	 * Handle fill mode switch requests up front,
196	 * they would just cause trouble in the subsequent code.
197	 */
198
199	switch (n->tok) {
200	case MAN_nf:
201	case MAN_EX:
202		want_fillmode = MAN_nf;
203		return;
204	case MAN_fi:
205	case MAN_EE:
206		want_fillmode = MAN_fi;
207		if (fillmode(h, 0) == MAN_fi)
208			print_otag(h, TAG_BR, "");
209		return;
210	default:
211		break;
212	}
213
214	/* Set up fill mode for the upcoming node. */
215
216	switch (n->type) {
217	case ROFFT_BLOCK:
218		save_fillmode = 0;
219		/* Some block macros suspend or cancel .nf. */
220		switch (n->tok) {
221		case MAN_TP:  /* Tagged paragraphs		*/
222		case MAN_IP:  /* temporarily disable .nf	*/
223		case MAN_HP:  /* for the head.			*/
224			save_fillmode = want_fillmode;
225			/* FALLTHROUGH */
226		case MAN_SH:  /* Section headers		*/
227		case MAN_SS:  /* permanently cancel .nf.	*/
228			want_fillmode = MAN_fi;
229			/* FALLTHROUGH */
230		case MAN_PP:  /* These have no head.		*/
231		case MAN_LP:  /* They will simply		*/
232		case MAN_P:   /* reopen .nf in the body.	*/
233		case MAN_RS:
234		case MAN_UR:
235		case MAN_MT:
236			fillmode(h, MAN_fi);
237			break;
238		default:
239			break;
240		}
241		break;
242	case ROFFT_TBL:
243		fillmode(h, MAN_fi);
244		break;
245	case ROFFT_ELEM:
246		/*
247		 * Some in-line macros produce tags and/or text
248		 * in the handler, so they require fill mode to be
249		 * configured up front just like for text nodes.
250		 * For the others, keep the traditional approach
251		 * of doing the same, for now.
252		 */
253		fillmode(h, want_fillmode);
254		break;
255	case ROFFT_TEXT:
256		if (fillmode(h, want_fillmode) == MAN_fi &&
257		    want_fillmode == MAN_fi &&
258		    n->flags & NODE_LINE && *n->string == ' ' &&
259		    (h->flags & HTML_NONEWLINE) == 0)
260			print_otag(h, TAG_BR, "");
261		if (*n->string != '\0')
262			break;
263		print_paragraph(h);
264		return;
265	default:
266		break;
267	}
268
269	/* Produce output for this node. */
270
271	child = 1;
272	switch (n->type) {
273	case ROFFT_TEXT:
274		t = h->tag;
275		print_text(h, n->string);
276		break;
277	case ROFFT_EQN:
278		t = h->tag;
279		print_eqn(h, n->eqn);
280		break;
281	case ROFFT_TBL:
282		/*
283		 * This will take care of initialising all of the table
284		 * state data for the first table, then tearing it down
285		 * for the last one.
286		 */
287		print_tbl(h, n->span);
288		return;
289	default:
290		/*
291		 * Close out scope of font prior to opening a macro
292		 * scope.
293		 */
294		if (HTMLFONT_NONE != h->metac) {
295			h->metal = h->metac;
296			h->metac = HTMLFONT_NONE;
297		}
298
299		/*
300		 * Close out the current table, if it's open, and unset
301		 * the "meta" table state.  This will be reopened on the
302		 * next table element.
303		 */
304		if (h->tblt)
305			print_tblclose(h);
306
307		t = h->tag;
308		if (n->tok < ROFF_MAX) {
309			roff_html_pre(h, n);
310			child = 0;
311			break;
312		}
313
314		assert(n->tok >= MAN_TH && n->tok < MAN_MAX);
315		if (mans[n->tok].pre)
316			child = (*mans[n->tok].pre)(man, n, h);
317
318		/* Some block macros resume .nf in the body. */
319		if (save_fillmode && n->type == ROFFT_BODY)
320			want_fillmode = save_fillmode;
321
322		break;
323	}
324
325	if (child && n->child)
326		print_man_nodelist(man, n->child, h);
327
328	/* This will automatically close out any font scope. */
329	print_stagq(h, t);
330
331	if (fillmode(h, 0) == MAN_nf &&
332	    n->next != NULL && n->next->flags & NODE_LINE)
333		print_endline(h);
334}
335
336/*
337 * MAN_nf switches to no-fill mode, MAN_fi to fill mode.
338 * Other arguments do not switch.
339 * The old mode is returned.
340 */
341static int
342fillmode(struct html *h, int want)
343{
344	struct tag	*pre;
345	int		 had;
346
347	for (pre = h->tag; pre != NULL; pre = pre->next)
348		if (pre->tag == TAG_PRE)
349			break;
350
351	had = pre == NULL ? MAN_fi : MAN_nf;
352
353	if (want && want != had) {
354		if (want == MAN_nf)
355			print_otag(h, TAG_PRE, "");
356		else
357			print_tagq(h, pre);
358	}
359	return had;
360}
361
362static int
363a2width(const struct roff_node *n, struct roffsu *su)
364{
365	if (n->type != ROFFT_TEXT)
366		return 0;
367	return a2roffsu(n->string, su, SCALE_EN) != NULL;
368}
369
370static void
371man_root_pre(MAN_ARGS)
372{
373	struct tag	*t, *tt;
374	char		*title;
375
376	assert(man->title);
377	assert(man->msec);
378	mandoc_asprintf(&title, "%s(%s)", man->title, man->msec);
379
380	t = print_otag(h, TAG_TABLE, "c", "head");
381	tt = print_otag(h, TAG_TR, "");
382
383	print_otag(h, TAG_TD, "c", "head-ltitle");
384	print_text(h, title);
385	print_stagq(h, tt);
386
387	print_otag(h, TAG_TD, "c", "head-vol");
388	if (NULL != man->vol)
389		print_text(h, man->vol);
390	print_stagq(h, tt);
391
392	print_otag(h, TAG_TD, "c", "head-rtitle");
393	print_text(h, title);
394	print_tagq(h, t);
395	free(title);
396}
397
398static void
399man_root_post(MAN_ARGS)
400{
401	struct tag	*t, *tt;
402
403	t = print_otag(h, TAG_TABLE, "c", "foot");
404	tt = print_otag(h, TAG_TR, "");
405
406	print_otag(h, TAG_TD, "c", "foot-date");
407	print_text(h, man->date);
408	print_stagq(h, tt);
409
410	print_otag(h, TAG_TD, "c", "foot-os");
411	if (man->os)
412		print_text(h, man->os);
413	print_tagq(h, t);
414}
415
416static int
417man_SH_pre(MAN_ARGS)
418{
419	char	*id;
420
421	if (n->type == ROFFT_HEAD) {
422		id = html_make_id(n);
423		print_otag(h, TAG_H1, "cTi", "Sh", id);
424		if (id != NULL)
425			print_otag(h, TAG_A, "chR", "selflink", id);
426		free(id);
427	}
428	return 1;
429}
430
431static int
432man_alt_pre(MAN_ARGS)
433{
434	const struct roff_node	*nn;
435	int		 i;
436	enum htmltag	 fp;
437	struct tag	*t;
438
439	for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
440		switch (n->tok) {
441		case MAN_BI:
442			fp = i % 2 ? TAG_I : TAG_B;
443			break;
444		case MAN_IB:
445			fp = i % 2 ? TAG_B : TAG_I;
446			break;
447		case MAN_RI:
448			fp = i % 2 ? TAG_I : TAG_MAX;
449			break;
450		case MAN_IR:
451			fp = i % 2 ? TAG_MAX : TAG_I;
452			break;
453		case MAN_BR:
454			fp = i % 2 ? TAG_MAX : TAG_B;
455			break;
456		case MAN_RB:
457			fp = i % 2 ? TAG_B : TAG_MAX;
458			break;
459		default:
460			abort();
461		}
462
463		if (i)
464			h->flags |= HTML_NOSPACE;
465
466		if (fp != TAG_MAX)
467			t = print_otag(h, fp, "");
468
469		print_text(h, nn->string);
470
471		if (fp != TAG_MAX)
472			print_tagq(h, t);
473	}
474	return 0;
475}
476
477static int
478man_SM_pre(MAN_ARGS)
479{
480	print_otag(h, TAG_SMALL, "");
481	if (MAN_SB == n->tok)
482		print_otag(h, TAG_B, "");
483	return 1;
484}
485
486static int
487man_SS_pre(MAN_ARGS)
488{
489	char	*id;
490
491	if (n->type == ROFFT_HEAD) {
492		id = html_make_id(n);
493		print_otag(h, TAG_H2, "cTi", "Ss", id);
494		if (id != NULL)
495			print_otag(h, TAG_A, "chR", "selflink", id);
496		free(id);
497	}
498	return 1;
499}
500
501static int
502man_PP_pre(MAN_ARGS)
503{
504
505	if (n->type == ROFFT_HEAD)
506		return 0;
507	else if (n->type == ROFFT_BLOCK)
508		print_bvspace(h, n);
509
510	return 1;
511}
512
513static int
514man_IP_pre(MAN_ARGS)
515{
516	const struct roff_node	*nn;
517
518	if (n->type == ROFFT_BODY) {
519		print_otag(h, TAG_DD, "c", "It-tag");
520		return 1;
521	} else if (n->type != ROFFT_HEAD) {
522		print_otag(h, TAG_DL, "c", "Bl-tag");
523		return 1;
524	}
525
526	/* FIXME: width specification. */
527
528	print_otag(h, TAG_DT, "c", "It-tag");
529
530	/* For IP, only print the first header element. */
531
532	if (MAN_IP == n->tok && n->child)
533		print_man_node(man, n->child, h);
534
535	/* For TP, only print next-line header elements. */
536
537	if (MAN_TP == n->tok) {
538		nn = n->child;
539		while (NULL != nn && 0 == (NODE_LINE & nn->flags))
540			nn = nn->next;
541		while (NULL != nn) {
542			print_man_node(man, nn, h);
543			nn = nn->next;
544		}
545	}
546
547	return 0;
548}
549
550static int
551man_HP_pre(MAN_ARGS)
552{
553	struct roffsu	 sum, sui;
554	const struct roff_node *np;
555
556	if (n->type == ROFFT_HEAD)
557		return 0;
558	else if (n->type != ROFFT_BLOCK)
559		return 1;
560
561	np = n->head->child;
562
563	if (np == NULL || !a2width(np, &sum))
564		SCALE_HS_INIT(&sum, INDENT);
565
566	sui.unit = sum.unit;
567	sui.scale = -sum.scale;
568
569	print_bvspace(h, n);
570	print_otag(h, TAG_DIV, "csului", "Pp", &sum, &sui);
571	return 1;
572}
573
574static int
575man_OP_pre(MAN_ARGS)
576{
577	struct tag	*tt;
578
579	print_text(h, "[");
580	h->flags |= HTML_NOSPACE;
581	tt = print_otag(h, TAG_SPAN, "c", "Op");
582
583	if (NULL != (n = n->child)) {
584		print_otag(h, TAG_B, "");
585		print_text(h, n->string);
586	}
587
588	print_stagq(h, tt);
589
590	if (NULL != n && NULL != n->next) {
591		print_otag(h, TAG_I, "");
592		print_text(h, n->next->string);
593	}
594
595	print_stagq(h, tt);
596	h->flags |= HTML_NOSPACE;
597	print_text(h, "]");
598	return 0;
599}
600
601static int
602man_B_pre(MAN_ARGS)
603{
604	print_otag(h, TAG_B, "");
605	return 1;
606}
607
608static int
609man_I_pre(MAN_ARGS)
610{
611	print_otag(h, TAG_I, "");
612	return 1;
613}
614
615static int
616man_in_pre(MAN_ARGS)
617{
618	print_otag(h, TAG_BR, "");
619	return 0;
620}
621
622static int
623man_ign_pre(MAN_ARGS)
624{
625
626	return 0;
627}
628
629static int
630man_RS_pre(MAN_ARGS)
631{
632	struct roffsu	 su;
633
634	if (n->type == ROFFT_HEAD)
635		return 0;
636	else if (n->type == ROFFT_BODY)
637		return 1;
638
639	SCALE_HS_INIT(&su, INDENT);
640	if (n->head->child)
641		a2width(n->head->child, &su);
642
643	print_otag(h, TAG_DIV, "sul", &su);
644	return 1;
645}
646
647static int
648man_UR_pre(MAN_ARGS)
649{
650	char *cp;
651	n = n->child;
652	assert(n->type == ROFFT_HEAD);
653	if (n->child != NULL) {
654		assert(n->child->type == ROFFT_TEXT);
655		if (n->tok == MAN_MT) {
656			mandoc_asprintf(&cp, "mailto:%s", n->child->string);
657			print_otag(h, TAG_A, "cTh", "Mt", cp);
658			free(cp);
659		} else
660			print_otag(h, TAG_A, "cTh", "Lk", n->child->string);
661	}
662
663	assert(n->next->type == ROFFT_BODY);
664	if (n->next->child != NULL)
665		n = n->next;
666
667	print_man_nodelist(man, n->child, h);
668
669	return 0;
670}
671