Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/mandoc/man_html.c	Lines:	104	251	41.4 %
Date:	2017-11-13	Branches:	51	177	28.8 %


/*	$OpenBSD: man_html.c,v 1.98 2017/06/25 07:23:53 bentley Exp $ */
/*
 * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
 * Copyright (c) 2013, 2014, 2015, 2017 Ingo Schwarze <schwarze@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#include <sys/types.h>

#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "mandoc_aux.h"
#include "mandoc.h"
#include "roff.h"
#include "man.h"
#include "out.h"
#include "html.h"
#include "main.h"

/* FIXME: have PD set the default vspace width. */

#define	INDENT		  5

#define	MAN_ARGS	  const struct roff_meta *man, \
			  const struct roff_node *n, \
			  struct html *h

struct	htmlman {
	int		(*pre)(MAN_ARGS);
	int		(*post)(MAN_ARGS);
};

static	void		  print_bvspace(struct html *,
				const struct roff_node *);
static	void		  print_man_head(MAN_ARGS);
static	void		  print_man_nodelist(MAN_ARGS);
static	void		  print_man_node(MAN_ARGS);
static	int		  fillmode(struct html *, int);
static	int		  a2width(const struct roff_node *,
				struct roffsu *);
static	int		  man_B_pre(MAN_ARGS);
static	int		  man_HP_pre(MAN_ARGS);
static	int		  man_IP_pre(MAN_ARGS);
static	int		  man_I_pre(MAN_ARGS);
static	int		  man_OP_pre(MAN_ARGS);
static	int		  man_PP_pre(MAN_ARGS);
static	int		  man_RS_pre(MAN_ARGS);
static	int		  man_SH_pre(MAN_ARGS);
static	int		  man_SM_pre(MAN_ARGS);
static	int		  man_SS_pre(MAN_ARGS);
static	int		  man_UR_pre(MAN_ARGS);
static	int		  man_alt_pre(MAN_ARGS);
static	int		  man_ign_pre(MAN_ARGS);
static	int		  man_in_pre(MAN_ARGS);
static	void		  man_root_post(MAN_ARGS);
static	void		  man_root_pre(MAN_ARGS);

static	const struct htmlman __mans[MAN_MAX - MAN_TH] = {
	{ NULL, NULL }, /* TH */
	{ man_SH_pre, NULL }, /* SH */
	{ man_SS_pre, NULL }, /* SS */
	{ man_IP_pre, NULL }, /* TP */
	{ man_PP_pre, NULL }, /* LP */
	{ man_PP_pre, NULL }, /* PP */
	{ man_PP_pre, NULL }, /* P */
	{ man_IP_pre, NULL }, /* IP */
	{ man_HP_pre, NULL }, /* HP */
	{ man_SM_pre, NULL }, /* SM */
	{ man_SM_pre, NULL }, /* SB */
	{ man_alt_pre, NULL }, /* BI */
	{ man_alt_pre, NULL }, /* IB */
	{ man_alt_pre, NULL }, /* BR */
	{ man_alt_pre, NULL }, /* RB */
	{ NULL, NULL }, /* R */
	{ man_B_pre, NULL }, /* B */
	{ man_I_pre, NULL }, /* I */
	{ man_alt_pre, NULL }, /* IR */
	{ man_alt_pre, NULL }, /* RI */
	{ NULL, NULL }, /* nf */
	{ NULL, NULL }, /* fi */
	{ NULL, NULL }, /* RE */
	{ man_RS_pre, NULL }, /* RS */
	{ man_ign_pre, NULL }, /* DT */
	{ man_ign_pre, NULL }, /* UC */
	{ man_ign_pre, NULL }, /* PD */
	{ man_ign_pre, NULL }, /* AT */
	{ man_in_pre, NULL }, /* in */
	{ man_OP_pre, NULL }, /* OP */
	{ NULL, NULL }, /* EX */
	{ NULL, NULL }, /* EE */
	{ man_UR_pre, NULL }, /* UR */
	{ NULL, NULL }, /* UE */
	{ man_UR_pre, NULL }, /* MT */
	{ NULL, NULL }, /* ME */
};
static	const struct htmlman *const mans = __mans - MAN_TH;


/*
 * Printing leading vertical space before a block.
 * This is used for the paragraph macros.
 * The rules are pretty simple, since there's very little nesting going
 * on here.  Basically, if we're the first within another block (SS/SH),
 * then don't emit vertical space.  If we are (RS), then do.  If not the
 * first, print it.
 */
static void
print_bvspace(struct html *h, const struct roff_node *n)
{

	if (n->body && n->body->child)
		if (n->body->child->type == ROFFT_TBL)
			return;

	if (n->parent->type == ROFFT_ROOT || n->parent->tok != MAN_RS)
		if (NULL == n->prev)
			return;

	print_paragraph(h);
}

void
html_man(void *arg, const struct roff_man *man)
{
	struct html	*h;
	struct tag	*t;

	h = (struct html *)arg;

	if ((h->oflags & HTML_FRAGMENT) == 0) {
		print_gen_decls(h);
		print_otag(h, TAG_HTML, "");
		t = print_otag(h, TAG_HEAD, "");
		print_man_head(&man->meta, man->first, h);
		print_tagq(h, t);
		print_otag(h, TAG_BODY, "");
	}

	man_root_pre(&man->meta, man->first, h);
	t = print_otag(h, TAG_DIV, "c", "manual-text");
	print_man_nodelist(&man->meta, man->first->child, h);
	print_tagq(h, t);
	man_root_post(&man->meta, man->first, h);
	print_tagq(h, NULL);
}

static void
print_man_head(MAN_ARGS)
{
	char	*cp;

	print_gen_head(h);
	mandoc_asprintf(&cp, "%s(%s)", man->title, man->msec);
	print_otag(h, TAG_TITLE, "");
	print_text(h, cp);
	free(cp);
}

static void
print_man_nodelist(MAN_ARGS)
{

	while (n != NULL) {
		print_man_node(man, n, h);
		n = n->next;
	}
}

static void
print_man_node(MAN_ARGS)
{
	static int	 want_fillmode = MAN_fi;
	static int	 save_fillmode;

	struct tag	*t;
	int		 child;

	/*
	 * Handle fill mode switch requests up front,
	 * they would just cause trouble in the subsequent code.
	 */

	switch (n->tok) {
	case MAN_nf:
	case MAN_EX:
		want_fillmode = MAN_nf;
		return;
	case MAN_fi:
	case MAN_EE:
		want_fillmode = MAN_fi;
		if (fillmode(h, 0) == MAN_fi)
			print_otag(h, TAG_BR, "");
		return;
	default:
		break;
	}

	/* Set up fill mode for the upcoming node. */

	switch (n->type) {
	case ROFFT_BLOCK:
		save_fillmode = 0;
		/* Some block macros suspend or cancel .nf. */
		switch (n->tok) {
		case MAN_TP:  /* Tagged paragraphs		*/
		case MAN_IP:  /* temporarily disable .nf	*/
		case MAN_HP:  /* for the head.			*/
			save_fillmode = want_fillmode;
			/* FALLTHROUGH */
		case MAN_SH:  /* Section headers		*/
		case MAN_SS:  /* permanently cancel .nf.	*/
			want_fillmode = MAN_fi;
			/* FALLTHROUGH */
		case MAN_PP:  /* These have no head.		*/
		case MAN_LP:  /* They will simply		*/
		case MAN_P:   /* reopen .nf in the body.	*/
		case MAN_RS:
		case MAN_UR:
		case MAN_MT:
			fillmode(h, MAN_fi);
			break;
		default:
			break;
		}
		break;
	case ROFFT_TBL:
		fillmode(h, MAN_fi);
		break;
	case ROFFT_ELEM:
		/*
		 * Some in-line macros produce tags and/or text
		 * in the handler, so they require fill mode to be
		 * configured up front just like for text nodes.
		 * For the others, keep the traditional approach
		 * of doing the same, for now.
		 */
		fillmode(h, want_fillmode);
		break;
	case ROFFT_TEXT:
		if (fillmode(h, want_fillmode) == MAN_fi &&
		    want_fillmode == MAN_fi &&
		    n->flags & NODE_LINE && *n->string == ' ' &&
		    (h->flags & HTML_NONEWLINE) == 0)
			print_otag(h, TAG_BR, "");
		if (*n->string != '\0')
			break;
		print_paragraph(h);
		return;
	default:
		break;
	}

	/* Produce output for this node. */

	child = 1;
	switch (n->type) {
	case ROFFT_TEXT:
		t = h->tag;
		print_text(h, n->string);
		break;
	case ROFFT_EQN:
		t = h->tag;
		print_eqn(h, n->eqn);
		break;
	case ROFFT_TBL:
		/*
		 * This will take care of initialising all of the table
		 * state data for the first table, then tearing it down
		 * for the last one.
		 */
		print_tbl(h, n->span);
		return;
	default:
		/*
		 * Close out scope of font prior to opening a macro
		 * scope.
		 */
		if (HTMLFONT_NONE != h->metac) {
			h->metal = h->metac;
			h->metac = HTMLFONT_NONE;
		}

		/*
		 * Close out the current table, if it's open, and unset
		 * the "meta" table state.  This will be reopened on the
		 * next table element.
		 */
		if (h->tblt)
			print_tblclose(h);

		t = h->tag;
		if (n->tok < ROFF_MAX) {
			roff_html_pre(h, n);
			child = 0;
			break;
		}

		assert(n->tok >= MAN_TH && n->tok < MAN_MAX);
		if (mans[n->tok].pre)
			child = (*mans[n->tok].pre)(man, n, h);

		/* Some block macros resume .nf in the body. */
		if (save_fillmode && n->type == ROFFT_BODY)
			want_fillmode = save_fillmode;

		break;
	}

	if (child && n->child)
		print_man_nodelist(man, n->child, h);

	/* This will automatically close out any font scope. */
	print_stagq(h, t);

	if (fillmode(h, 0) == MAN_nf &&
	    n->next != NULL && n->next->flags & NODE_LINE)
		print_endline(h);
}

/*
 * MAN_nf switches to no-fill mode, MAN_fi to fill mode.
 * Other arguments do not switch.
 * The old mode is returned.
 */
static int
fillmode(struct html *h, int want)
{
	struct tag	*pre;
	int		 had;

	for (pre = h->tag; pre != NULL; pre = pre->next)
		if (pre->tag == TAG_PRE)
			break;

	had = pre == NULL ? MAN_fi : MAN_nf;

	if (want && want != had) {
		if (want == MAN_nf)
			print_otag(h, TAG_PRE, "");
		else
			print_tagq(h, pre);
	}
	return had;
}

static int
a2width(const struct roff_node *n, struct roffsu *su)
{
	if (n->type != ROFFT_TEXT)
		return 0;
	return a2roffsu(n->string, su, SCALE_EN) != NULL;
}

static void
man_root_pre(MAN_ARGS)
{
	struct tag	*t, *tt;
	char		*title;

	assert(man->title);
	assert(man->msec);
	mandoc_asprintf(&title, "%s(%s)", man->title, man->msec);

	t = print_otag(h, TAG_TABLE, "c", "head");
	tt = print_otag(h, TAG_TR, "");

	print_otag(h, TAG_TD, "c", "head-ltitle");
	print_text(h, title);
	print_stagq(h, tt);

	print_otag(h, TAG_TD, "c", "head-vol");
	if (NULL != man->vol)
		print_text(h, man->vol);
	print_stagq(h, tt);

	print_otag(h, TAG_TD, "c", "head-rtitle");
	print_text(h, title);
	print_tagq(h, t);
	free(title);
}

static void
man_root_post(MAN_ARGS)
{
	struct tag	*t, *tt;

	t = print_otag(h, TAG_TABLE, "c", "foot");
	tt = print_otag(h, TAG_TR, "");

	print_otag(h, TAG_TD, "c", "foot-date");
	print_text(h, man->date);
	print_stagq(h, tt);

	print_otag(h, TAG_TD, "c", "foot-os");
	if (man->os)
		print_text(h, man->os);
	print_tagq(h, t);
}

static int
man_SH_pre(MAN_ARGS)
{
	char	*id;

	if (n->type == ROFFT_HEAD) {
		id = html_make_id(n);
		print_otag(h, TAG_H1, "cTi", "Sh", id);
		if (id != NULL)
			print_otag(h, TAG_A, "chR", "selflink", id);
		free(id);
	}
	return 1;
}

static int
man_alt_pre(MAN_ARGS)
{
	const struct roff_node	*nn;
	int		 i;
	enum htmltag	 fp;
	struct tag	*t;

	for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
		switch (n->tok) {
		case MAN_BI:
			fp = i % 2 ? TAG_I : TAG_B;
			break;
		case MAN_IB:
			fp = i % 2 ? TAG_B : TAG_I;
			break;
		case MAN_RI:
			fp = i % 2 ? TAG_I : TAG_MAX;
			break;
		case MAN_IR:
			fp = i % 2 ? TAG_MAX : TAG_I;
			break;
		case MAN_BR:
			fp = i % 2 ? TAG_MAX : TAG_B;
			break;
		case MAN_RB:
			fp = i % 2 ? TAG_B : TAG_MAX;
			break;
		default:
			abort();
		}

		if (i)
			h->flags |= HTML_NOSPACE;

		if (fp != TAG_MAX)
			t = print_otag(h, fp, "");

		print_text(h, nn->string);

		if (fp != TAG_MAX)
			print_tagq(h, t);
	}
	return 0;
}

static int
man_SM_pre(MAN_ARGS)
{
	print_otag(h, TAG_SMALL, "");
	if (MAN_SB == n->tok)
		print_otag(h, TAG_B, "");
	return 1;
}

static int
man_SS_pre(MAN_ARGS)
{
	char	*id;

	if (n->type == ROFFT_HEAD) {
		id = html_make_id(n);
		print_otag(h, TAG_H2, "cTi", "Ss", id);
		if (id != NULL)
			print_otag(h, TAG_A, "chR", "selflink", id);
		free(id);
	}
	return 1;
}

static int
man_PP_pre(MAN_ARGS)
{

	if (n->type == ROFFT_HEAD)
		return 0;
	else if (n->type == ROFFT_BLOCK)
		print_bvspace(h, n);

	return 1;
}

static int
man_IP_pre(MAN_ARGS)
{
	const struct roff_node	*nn;

	if (n->type == ROFFT_BODY) {
		print_otag(h, TAG_DD, "c", "It-tag");
		return 1;
	} else if (n->type != ROFFT_HEAD) {
		print_otag(h, TAG_DL, "c", "Bl-tag");
		return 1;
	}

	/* FIXME: width specification. */

	print_otag(h, TAG_DT, "c", "It-tag");

	/* For IP, only print the first header element. */

	if (MAN_IP == n->tok && n->child)
		print_man_node(man, n->child, h);

	/* For TP, only print next-line header elements. */

	if (MAN_TP == n->tok) {
		nn = n->child;
		while (NULL != nn && 0 == (NODE_LINE & nn->flags))
			nn = nn->next;
		while (NULL != nn) {
			print_man_node(man, nn, h);
			nn = nn->next;
		}
	}

	return 0;
}

static int
man_HP_pre(MAN_ARGS)
{
	struct roffsu	 sum, sui;
	const struct roff_node *np;

	if (n->type == ROFFT_HEAD)
		return 0;
	else if (n->type != ROFFT_BLOCK)
		return 1;

	np = n->head->child;

	if (np == NULL || !a2width(np, &sum))
		SCALE_HS_INIT(&sum, INDENT);

	sui.unit = sum.unit;
	sui.scale = -sum.scale;

	print_bvspace(h, n);
	print_otag(h, TAG_DIV, "csului", "Pp", &sum, &sui);
	return 1;
}

static int
man_OP_pre(MAN_ARGS)
{
	struct tag	*tt;

	print_text(h, "[");
	h->flags |= HTML_NOSPACE;
	tt = print_otag(h, TAG_SPAN, "c", "Op");

	if (NULL != (n = n->child)) {
		print_otag(h, TAG_B, "");
		print_text(h, n->string);
	}

	print_stagq(h, tt);

	if (NULL != n && NULL != n->next) {
		print_otag(h, TAG_I, "");
		print_text(h, n->next->string);
	}

	print_stagq(h, tt);
	h->flags |= HTML_NOSPACE;
	print_text(h, "]");
	return 0;
}

static int
man_B_pre(MAN_ARGS)
{
	print_otag(h, TAG_B, "");
	return 1;
}

static int
man_I_pre(MAN_ARGS)
{
	print_otag(h, TAG_I, "");
	return 1;
}

static int
man_in_pre(MAN_ARGS)
{
	print_otag(h, TAG_BR, "");
	return 0;
}

static int
man_ign_pre(MAN_ARGS)
{

	return 0;
}

static int
man_RS_pre(MAN_ARGS)
{
	struct roffsu	 su;

	if (n->type == ROFFT_HEAD)
		return 0;
	else if (n->type == ROFFT_BODY)
		return 1;

	SCALE_HS_INIT(&su, INDENT);
	if (n->head->child)
		a2width(n->head->child, &su);

	print_otag(h, TAG_DIV, "sul", &su);
	return 1;
}

static int
man_UR_pre(MAN_ARGS)
{
	char *cp;
	n = n->child;
	assert(n->type == ROFFT_HEAD);
	if (n->child != NULL) {
		assert(n->child->type == ROFFT_TEXT);
		if (n->tok == MAN_MT) {
			mandoc_asprintf(&cp, "mailto:%s", n->child->string);
			print_otag(h, TAG_A, "cTh", "Mt", cp);
			free(cp);
		} else
			print_otag(h, TAG_A, "cTh", "Lk", n->child->string);
	}

	assert(n->next->type == ROFFT_BODY);
	if (n->next->child != NULL)
		n = n->next;

	print_man_nodelist(man, n->child, h);

	return 0;
}


Generated by: GCOVR (Version 3.3)

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