===================================================================
RCS file: /cvs/mandoc/html.c,v
retrieving revision 1.29
retrieving revision 1.196
diff -u -p -r1.29 -r1.196
--- mandoc/html.c	2009/09/16 09:41:24	1.29
+++ mandoc/html.c	2017/01/18 19:22:21	1.196
@@ -1,638 +1,797 @@
-/*	$Id: html.c,v 1.29 2009/09/16 09:41:24 kristaps Exp $ */
+/*	$Id: html.c,v 1.196 2017/01/18 19:22:21 schwarze Exp $ */
 /*
- * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
+ * Copyright (c) 2008-2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2011-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 AUTHOR DISCLAIMS ALL WARRANTIES
+ * 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 AUTHOR BE LIABLE FOR
+ * 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 "config.h"
+
+#include <sys/types.h>
+
 #include <assert.h>
-#include <err.h>
+#include <ctype.h>
+#include <stdarg.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 
-#include "mdoc.h"
-#include "man.h"
+#include "mandoc.h"
+#include "mandoc_aux.h"
+#include "out.h"
+#include "html.h"
+#include "manconf.h"
+#include "main.h"
 
-#define	DOCTYPE		"-//W3C//DTD HTML 4.01//EN"
-#define	DTD		"http://www.w3.org/TR/html4/strict.dtd"
-
-enum	htmltag {
-	TAG_HTML,
-	TAG_HEAD,
-	TAG_BODY,
-	TAG_META,
-	TAG_TITLE,
-	TAG_DIV,
-	TAG_H1,
-	TAG_H2,
-	TAG_P,
-	TAG_SPAN,
-	TAG_LINK,
-	TAG_MAX
-};
-
-enum	htmlattr {
-	ATTR_HTTPEQUIV,
-	ATTR_CONTENT,
-	ATTR_NAME,
-	ATTR_REL,
-	ATTR_HREF,
-	ATTR_TYPE,
-	ATTR_MEDIA,
-	ATTR_CLASS,
-	ATTR_MAX
-};
-
 struct	htmldata {
-	char		 *name;
+	const char	 *name;
 	int		  flags;
-#define	HTML_BLOCK	 (1 << 0)
+#define	HTML_NOSTACK	 (1 << 0)
+#define	HTML_AUTOCLOSE	 (1 << 1)
+#define	HTML_NLBEFORE	 (1 << 2)
+#define	HTML_NLBEGIN	 (1 << 3)
+#define	HTML_NLEND	 (1 << 4)
+#define	HTML_NLAFTER	 (1 << 5)
+#define	HTML_NLAROUND	 (HTML_NLBEFORE | HTML_NLAFTER)
+#define	HTML_NLINSIDE	 (HTML_NLBEGIN | HTML_NLEND)
+#define	HTML_NLALL	 (HTML_NLAROUND | HTML_NLINSIDE)
+#define	HTML_INDENT	 (1 << 6)
+#define	HTML_NOINDENT	 (1 << 7)
 };
 
 static	const struct htmldata htmltags[TAG_MAX] = {
-	{"html",	HTML_BLOCK}, /* TAG_HTML */
-	{"head",	HTML_BLOCK}, /* TAG_HEAD */
-	{"body",	HTML_BLOCK}, /* TAG_BODY */
-	{"meta",	HTML_BLOCK}, /* TAG_META */
-	{"title",	HTML_BLOCK}, /* TAG_TITLE */
-	{"div",		HTML_BLOCK}, /* TAG_DIV */
-	{"h1",		0}, /* TAG_H1 */
-	{"h2",		0}, /* TAG_H2 */
-	{"p",		HTML_BLOCK}, /* TAG_P */
-	{"span",	0}, /* TAG_SPAN */
-	{"link",	HTML_BLOCK}, /* TAG_LINK */
+	{"html",	HTML_NLALL},
+	{"head",	HTML_NLALL | HTML_INDENT},
+	{"body",	HTML_NLALL},
+	{"meta",	HTML_NOSTACK | HTML_AUTOCLOSE | HTML_NLALL},
+	{"title",	HTML_NLAROUND},
+	{"div",		HTML_NLAROUND},
+	{"h1",		HTML_NLAROUND},
+	{"h2",		HTML_NLAROUND},
+	{"span",	0},
+	{"link",	HTML_NOSTACK | HTML_AUTOCLOSE | HTML_NLALL},
+	{"br",		HTML_NOSTACK | HTML_AUTOCLOSE | HTML_NLALL},
+	{"a",		0},
+	{"table",	HTML_NLALL | HTML_INDENT},
+	{"tbody",	HTML_NLALL | HTML_INDENT},
+	{"col",		HTML_NOSTACK | HTML_AUTOCLOSE | HTML_NLALL},
+	{"tr",		HTML_NLALL | HTML_INDENT},
+	{"td",		HTML_NLAROUND},
+	{"li",		HTML_NLAROUND | HTML_INDENT},
+	{"ul",		HTML_NLALL | HTML_INDENT},
+	{"ol",		HTML_NLALL | HTML_INDENT},
+	{"dl",		HTML_NLALL | HTML_INDENT},
+	{"dt",		HTML_NLAROUND},
+	{"dd",		HTML_NLAROUND | HTML_INDENT},
+	{"blockquote",	HTML_NLALL | HTML_INDENT},
+	{"pre",		HTML_NLALL | HTML_NOINDENT},
+	{"b",		0},
+	{"i",		0},
+	{"code",	0},
+	{"small",	0},
+	{"style",	HTML_NLALL | HTML_INDENT},
+	{"math",	HTML_NLALL | HTML_INDENT},
+	{"mrow",	0},
+	{"mi",		0},
+	{"mo",		0},
+	{"msup",	0},
+	{"msub",	0},
+	{"msubsup",	0},
+	{"mfrac",	0},
+	{"msqrt",	0},
+	{"mfenced",	0},
+	{"mtable",	0},
+	{"mtr",		0},
+	{"mtd",		0},
+	{"munderover",	0},
+	{"munder",	0},
+	{"mover",	0},
 };
 
-static	const char	 *const htmlattrs[ATTR_MAX] = {
-	"http-equiv",
-	"content",
-	"name",
-	"rel",
-	"href",
-	"type",
-	"media",
-	"class"
+static	const char	*const roffscales[SCALE_MAX] = {
+	"cm", /* SCALE_CM */
+	"in", /* SCALE_IN */
+	"pc", /* SCALE_PC */
+	"pt", /* SCALE_PT */
+	"em", /* SCALE_EM */
+	"em", /* SCALE_MM */
+	"ex", /* SCALE_EN */
+	"ex", /* SCALE_BU */
+	"em", /* SCALE_VS */
+	"ex", /* SCALE_FS */
 };
 
-struct	htmlpair {
-	enum htmlattr	  key;
-	char		 *val;
-};
+static	void	 a2width(const char *, struct roffsu *);
+static	void	 html_endline(struct html *);
+static	void	 html_indent(struct html *);
+static	void	 print_ctag(struct html *, struct tag *);
+static	int	 print_escape(char);
+static	int	 print_encode(struct html *, const char *, const char *, int);
+static	void	 print_href(struct html *, const char *, const char *, int);
+static	void	 print_metaf(struct html *, enum mandoc_esc);
 
-struct	html {
-	int		  flags;
-#define	HTML_NOSPACE	 (1 << 0)
-};
 
-#define	MDOC_ARGS	  const struct mdoc_meta *m, \
-			  const struct mdoc_node *n, \
-			  struct html *h
-#define	MAN_ARGS	  const struct man_meta *m, \
-			  const struct man_node *n, \
-			  struct html *h
-struct	htmlmdoc {
-	int		(*pre)(MDOC_ARGS);
-	void		(*post)(MDOC_ARGS);
-};
+void *
+html_alloc(const struct manoutput *outopts)
+{
+	struct html	*h;
 
-static	void		  print_gen_doctype(struct html *);
-static	void		  print_gen_head(struct html *);
-static	void		  print_mdoc(MDOC_ARGS);
-static	void		  print_mdoc_head(MDOC_ARGS);
-static	void		  print_mdoc_node(MDOC_ARGS);
-static	void		  print_man(MAN_ARGS);
-static	void		  print_man_head(MAN_ARGS);
-static	void		  print_man_body(MAN_ARGS);
-static	void		  print_otag(struct html *, enum htmltag, 
-				int, const struct htmlpair *);
-static	void		  print_ctag(struct html *, enum htmltag);
-static	void		  print_encode(const char *);
-static	void		  print_text(struct html *, const char *);
-static	int		  mdoc_root_pre(MDOC_ARGS);
-static	void		  mdoc_root_post(MDOC_ARGS);
+	h = mandoc_calloc(1, sizeof(struct html));
 
-static	int		  mdoc_nd_pre(MDOC_ARGS);
-static	int		  mdoc_nm_pre(MDOC_ARGS);
-static	void		  mdoc_nm_post(MDOC_ARGS);
-static	int		  mdoc_pp_pre(MDOC_ARGS);
-static	int		  mdoc_sh_pre(MDOC_ARGS);
-static	void		  mdoc_sh_post(MDOC_ARGS);
-static	int		  mdoc_ss_pre(MDOC_ARGS);
-static	void		  mdoc_ss_post(MDOC_ARGS);
+	h->tags.head = NULL;
+	h->style = outopts->style;
+	h->base_man = outopts->man;
+	h->base_includes = outopts->includes;
+	if (outopts->fragment)
+		h->oflags |= HTML_FRAGMENT;
 
-static	const struct htmlmdoc mdocs[MDOC_MAX] = {
-	{NULL, NULL}, /* Ap */
-	{NULL, NULL}, /* Dd */
-	{NULL, NULL}, /* Dt */
-	{NULL, NULL}, /* Os */
-	{mdoc_sh_pre, mdoc_sh_post }, /* Sh */
-	{mdoc_ss_pre, mdoc_ss_post }, /* Ss */ 
-	{mdoc_pp_pre, NULL}, /* Pp */ 
-	{NULL, NULL}, /* D1 */
-	{NULL, NULL}, /* Dl */
-	{NULL, NULL}, /* Bd */
-	{NULL, NULL}, /* Ed */
-	{NULL, NULL}, /* Bl */
-	{NULL, NULL}, /* El */
-	{NULL, NULL}, /* It */
-	{NULL, NULL}, /* Ad */ 
-	{NULL, NULL}, /* An */
-	{NULL, NULL}, /* Ar */
-	{NULL, NULL}, /* Cd */
-	{NULL, NULL}, /* Cm */
-	{NULL, NULL}, /* Dv */ 
-	{NULL, NULL}, /* Er */ 
-	{NULL, NULL}, /* Ev */ 
-	{NULL, NULL}, /* Ex */
-	{NULL, NULL}, /* Fa */ 
-	{NULL, NULL}, /* Fd */ 
-	{NULL, NULL}, /* Fl */
-	{NULL, NULL}, /* Fn */ 
-	{NULL, NULL}, /* Ft */ 
-	{NULL, NULL}, /* Ic */ 
-	{NULL, NULL}, /* In */ 
-	{NULL, NULL}, /* Li */
-	{mdoc_nd_pre, NULL}, /* Nd */ 
-	{mdoc_nm_pre, mdoc_nm_post}, /* Nm */ 
-	{NULL, NULL}, /* Op */
-	{NULL, NULL}, /* Ot */
-	{NULL, NULL}, /* Pa */
-	{NULL, NULL}, /* Rv */
-	{NULL, NULL}, /* St */ 
-	{NULL, NULL}, /* Va */
-	{NULL, NULL}, /* Vt */ 
-	{NULL, NULL}, /* Xr */
-	{NULL, NULL}, /* %A */
-	{NULL, NULL}, /* %B */
-	{NULL, NULL}, /* %D */
-	{NULL, NULL}, /* %I */
-	{NULL, NULL}, /* %J */
-	{NULL, NULL}, /* %N */
-	{NULL, NULL}, /* %O */
-	{NULL, NULL}, /* %P */
-	{NULL, NULL}, /* %R */
-	{NULL, NULL}, /* %T */
-	{NULL, NULL}, /* %V */
-	{NULL, NULL}, /* Ac */
-	{NULL, NULL}, /* Ao */
-	{NULL, NULL}, /* Aq */
-	{NULL, NULL}, /* At */
-	{NULL, NULL}, /* Bc */
-	{NULL, NULL}, /* Bf */ 
-	{NULL, NULL}, /* Bo */
-	{NULL, NULL}, /* Bq */
-	{NULL, NULL}, /* Bsx */
-	{NULL, NULL}, /* Bx */
-	{NULL, NULL}, /* Db */
-	{NULL, NULL}, /* Dc */
-	{NULL, NULL}, /* Do */
-	{NULL, NULL}, /* Dq */
-	{NULL, NULL}, /* Ec */
-	{NULL, NULL}, /* Ef */
-	{NULL, NULL}, /* Em */ 
-	{NULL, NULL}, /* Eo */
-	{NULL, NULL}, /* Fx */
-	{NULL, NULL}, /* Ms */
-	{NULL, NULL}, /* No */
-	{NULL, NULL}, /* Ns */
-	{NULL, NULL}, /* Nx */
-	{NULL, NULL}, /* Ox */
-	{NULL, NULL}, /* Pc */
-	{NULL, NULL}, /* Pf */
-	{NULL, NULL}, /* Po */
-	{NULL, NULL}, /* Pq */
-	{NULL, NULL}, /* Qc */
-	{NULL, NULL}, /* Ql */
-	{NULL, NULL}, /* Qo */
-	{NULL, NULL}, /* Qq */
-	{NULL, NULL}, /* Re */
-	{NULL, NULL}, /* Rs */
-	{NULL, NULL}, /* Sc */
-	{NULL, NULL}, /* So */
-	{NULL, NULL}, /* Sq */
-	{NULL, NULL}, /* Sm */
-	{NULL, NULL}, /* Sx */
-	{NULL, NULL}, /* Sy */
-	{NULL, NULL}, /* Tn */
-	{NULL, NULL}, /* Ux */
-	{NULL, NULL}, /* Xc */
-	{NULL, NULL}, /* Xo */
-	{NULL, NULL}, /* Fo */ 
-	{NULL, NULL}, /* Fc */ 
-	{NULL, NULL}, /* Oo */
-	{NULL, NULL}, /* Oc */
-	{NULL, NULL}, /* Bk */
-	{NULL, NULL}, /* Ek */
-	{NULL, NULL}, /* Bt */
-	{NULL, NULL}, /* Hf */
-	{NULL, NULL}, /* Fr */
-	{NULL, NULL}, /* Ud */
-	{NULL, NULL}, /* Lb */
-	{NULL, NULL}, /* Lp */ 
-	{NULL, NULL}, /* Lk */ 
-	{NULL, NULL}, /* Mt */ 
-	{NULL, NULL}, /* Brq */ 
-	{NULL, NULL}, /* Bro */ 
-	{NULL, NULL}, /* Brc */ 
-	{NULL, NULL}, /* %C */ 
-	{NULL, NULL}, /* Es */ 
-	{NULL, NULL}, /* En */ 
-	{NULL, NULL}, /* Dx */ 
-	{NULL, NULL}, /* %Q */ 
-	{NULL, NULL}, /* br */
-	{NULL, NULL}, /* sp */ 
-};
+	return h;
+}
 
+void
+html_free(void *p)
+{
+	struct tag	*tag;
+	struct html	*h;
 
-int
-html_mdoc(void *arg, const struct mdoc *m)
+	h = (struct html *)p;
+
+	while ((tag = h->tags.head) != NULL) {
+		h->tags.head = tag->next;
+		free(tag);
+	}
+
+	free(h);
+}
+
+void
+print_gen_head(struct html *h)
 {
-	struct html 	*h;
+	struct tag	*t;
 
-	h = (struct html *)arg;
+	print_otag(h, TAG_META, "?", "charset", "utf-8");
 
-	print_gen_doctype(h);
-	print_otag(h, TAG_HTML, 0, NULL);
-	print_mdoc(mdoc_meta(m), mdoc_node(m), h);
-	print_ctag(h, TAG_HTML);
-	printf("\n");
-	return(1);
+	/*
+	 * Print a default style-sheet.
+	 */
+
+	t = print_otag(h, TAG_STYLE, "");
+	print_text(h, "table.head, table.foot { width: 100%; }");
+	html_endline(h);
+	print_text(h, "td.head-rtitle, td.foot-os { text-align: right; }");
+	html_endline(h);
+	print_text(h, "td.head-vol { text-align: center; }");
+	html_endline(h);
+	print_text(h, "table.foot td { width: 50%; }");
+	html_endline(h);
+	print_text(h, "table.head td { width: 33%; }");
+	html_endline(h);
+	print_text(h, "div.spacer { margin: 1em 0; }");
+	print_tagq(h, t);
+
+	if (h->style)
+		print_otag(h, TAG_LINK, "?h??", "rel", "stylesheet",
+		    h->style, "type", "text/css", "media", "all");
 }
 
+static void
+print_metaf(struct html *h, enum mandoc_esc deco)
+{
+	enum htmlfont	 font;
 
+	switch (deco) {
+	case ESCAPE_FONTPREV:
+		font = h->metal;
+		break;
+	case ESCAPE_FONTITALIC:
+		font = HTMLFONT_ITALIC;
+		break;
+	case ESCAPE_FONTBOLD:
+		font = HTMLFONT_BOLD;
+		break;
+	case ESCAPE_FONTBI:
+		font = HTMLFONT_BI;
+		break;
+	case ESCAPE_FONT:
+	case ESCAPE_FONTROMAN:
+		font = HTMLFONT_NONE;
+		break;
+	default:
+		abort();
+	}
+
+	if (h->metaf) {
+		print_tagq(h, h->metaf);
+		h->metaf = NULL;
+	}
+
+	h->metal = h->metac;
+	h->metac = font;
+
+	switch (font) {
+	case HTMLFONT_ITALIC:
+		h->metaf = print_otag(h, TAG_I, "");
+		break;
+	case HTMLFONT_BOLD:
+		h->metaf = print_otag(h, TAG_B, "");
+		break;
+	case HTMLFONT_BI:
+		h->metaf = print_otag(h, TAG_B, "");
+		print_otag(h, TAG_I, "");
+		break;
+	default:
+		break;
+	}
+}
+
 int
-html_man(void *arg, const struct man *m)
+html_strlen(const char *cp)
 {
-	struct html	*h;
+	size_t		 rsz;
+	int		 skip, sz;
 
-	h = (struct html *)arg;
+	/*
+	 * Account for escaped sequences within string length
+	 * calculations.  This follows the logic in term_strlen() as we
+	 * must calculate the width of produced strings.
+	 * Assume that characters are always width of "1".  This is
+	 * hacky, but it gets the job done for approximation of widths.
+	 */
 
-	print_gen_doctype(h);
-	print_otag(h, TAG_HTML, 0, NULL);
-	print_man(man_meta(m), man_node(m), h);
-	print_ctag(h, TAG_HTML);
-	printf("\n");
-	return(1);
+	sz = 0;
+	skip = 0;
+	while (1) {
+		rsz = strcspn(cp, "\\");
+		if (rsz) {
+			cp += rsz;
+			if (skip) {
+				skip = 0;
+				rsz--;
+			}
+			sz += rsz;
+		}
+		if ('\0' == *cp)
+			break;
+		cp++;
+		switch (mandoc_escape(&cp, NULL, NULL)) {
+		case ESCAPE_ERROR:
+			return sz;
+		case ESCAPE_UNICODE:
+		case ESCAPE_NUMBERED:
+		case ESCAPE_SPECIAL:
+		case ESCAPE_OVERSTRIKE:
+			if (skip)
+				skip = 0;
+			else
+				sz++;
+			break;
+		case ESCAPE_SKIPCHAR:
+			skip = 1;
+			break;
+		default:
+			break;
+		}
+	}
+	return sz;
 }
 
-
-void *
-html_alloc(void)
+static int
+print_escape(char c)
 {
 
-	return(calloc(1, sizeof(struct html)));
+	switch (c) {
+	case '<':
+		printf("&lt;");
+		break;
+	case '>':
+		printf("&gt;");
+		break;
+	case '&':
+		printf("&amp;");
+		break;
+	case '"':
+		printf("&quot;");
+		break;
+	case ASCII_NBRSP:
+		printf("&nbsp;");
+		break;
+	case ASCII_HYPH:
+		putchar('-');
+		break;
+	case ASCII_BREAK:
+		break;
+	default:
+		return 0;
+	}
+	return 1;
 }
 
-
-void
-html_free(void *p)
+static int
+print_encode(struct html *h, const char *p, const char *pend, int norecurse)
 {
+	size_t		 sz;
+	int		 c, len, nospace;
+	const char	*seq;
+	enum mandoc_esc	 esc;
+	static const char rejs[9] = { '\\', '<', '>', '&', '"',
+		ASCII_NBRSP, ASCII_HYPH, ASCII_BREAK, '\0' };
 
-	free(p);
-}
+	if (pend == NULL)
+		pend = strchr(p, '\0');
 
+	nospace = 0;
 
-static void
-print_mdoc(MDOC_ARGS)
-{
+	while (p < pend) {
+		if (HTML_SKIPCHAR & h->flags && '\\' != *p) {
+			h->flags &= ~HTML_SKIPCHAR;
+			p++;
+			continue;
+		}
 
-	print_otag(h, TAG_HEAD, 0, NULL);
-	print_mdoc_head(m, n, h);
-	print_ctag(h, TAG_HEAD);
-	print_otag(h, TAG_BODY, 0, NULL);
-	print_mdoc_node(m, n, h);
-	print_ctag(h, TAG_BODY);
-}
+		sz = strcspn(p, rejs);
+		if (p + sz > pend)
+			sz = pend - p;
 
+		fwrite(p, 1, sz, stdout);
+		p += (int)sz;
 
-static void
-print_gen_head(struct html *h)
-{
-	struct htmlpair	 meta0[2];
-	struct htmlpair	 meta1[2];
-	struct htmlpair	 link[4];
+		if (p >= pend)
+			break;
 
-	meta0[0].key = ATTR_HTTPEQUIV;
-	meta0[0].val = "Content-Type";
-	meta0[1].key = ATTR_CONTENT;
-	meta0[1].val = "text/html; charest-utf-8";
+		if (print_escape(*p++))
+			continue;
 
-	meta1[0].key = ATTR_NAME;
-	meta1[0].val = "resource-type";
-	meta1[1].key = ATTR_CONTENT;
-	meta1[1].val = "document";
+		esc = mandoc_escape(&p, &seq, &len);
+		if (ESCAPE_ERROR == esc)
+			break;
 
-	link[0].key = ATTR_REL;
-	link[0].val = "stylesheet";
-	link[1].key = ATTR_HREF;
-	link[1].val = "style.css";
-	link[2].key = ATTR_TYPE;
-	link[2].val = "text/css";
-	link[3].key = ATTR_MEDIA;
-	link[3].val = "all";
+		switch (esc) {
+		case ESCAPE_FONT:
+		case ESCAPE_FONTPREV:
+		case ESCAPE_FONTBOLD:
+		case ESCAPE_FONTITALIC:
+		case ESCAPE_FONTBI:
+		case ESCAPE_FONTROMAN:
+			if (0 == norecurse)
+				print_metaf(h, esc);
+			continue;
+		case ESCAPE_SKIPCHAR:
+			h->flags |= HTML_SKIPCHAR;
+			continue;
+		default:
+			break;
+		}
 
-	print_otag(h, TAG_META, 2, meta0);
-	print_otag(h, TAG_META, 2, meta1);
-	print_otag(h, TAG_LINK, 4, link);
-}
+		if (h->flags & HTML_SKIPCHAR) {
+			h->flags &= ~HTML_SKIPCHAR;
+			continue;
+		}
 
+		switch (esc) {
+		case ESCAPE_UNICODE:
+			/* Skip past "u" header. */
+			c = mchars_num2uc(seq + 1, len - 1);
+			break;
+		case ESCAPE_NUMBERED:
+			c = mchars_num2char(seq, len);
+			if (c < 0)
+				continue;
+			break;
+		case ESCAPE_SPECIAL:
+			c = mchars_spec2cp(seq, len);
+			if (c <= 0)
+				continue;
+			break;
+		case ESCAPE_NOSPACE:
+			if ('\0' == *p)
+				nospace = 1;
+			continue;
+		case ESCAPE_OVERSTRIKE:
+			if (len == 0)
+				continue;
+			c = seq[len - 1];
+			break;
+		default:
+			continue;
+		}
+		if ((c < 0x20 && c != 0x09) ||
+		    (c > 0x7E && c < 0xA0))
+			c = 0xFFFD;
+		if (c > 0x7E)
+			printf("&#%d;", c);
+		else if ( ! print_escape(c))
+			putchar(c);
+	}
 
+	return nospace;
+}
+
 static void
-print_mdoc_head(MDOC_ARGS)
+print_href(struct html *h, const char *name, const char *sec, int man)
 {
+	const char	*p, *pp;
 
-	print_gen_head(h);
-	print_otag(h, TAG_TITLE, 0, NULL);
-	print_encode(m->title);
-	print_ctag(h, TAG_TITLE);
+	pp = man ? h->base_man : h->base_includes;
+	while ((p = strchr(pp, '%')) != NULL) {
+		print_encode(h, pp, p, 1);
+		if (man && p[1] == 'S') {
+			if (sec == NULL)
+				putchar('1');
+			else
+				print_encode(h, sec, NULL, 1);
+		} else if ((man && p[1] == 'N') ||
+		    (man == 0 && p[1] == 'I'))
+			print_encode(h, name, NULL, 1);
+		else
+			print_encode(h, p, p + 2, 1);
+		pp = p + 2;
+	}
+	if (*pp != '\0')
+		print_encode(h, pp, NULL, 1);
 }
 
-
-static int
-mdoc_root_pre(MDOC_ARGS)
+struct tag *
+print_otag(struct html *h, enum htmltag tag, const char *fmt, ...)
 {
-	struct htmlpair	 div;
+	va_list		 ap;
+	struct roffsu	 mysu, *su;
+	struct tag	*t;
+	const char	*attr;
+	char		*s;
+	double		 v;
+	int		 i, have_style, tflags;
 
-	div.key = ATTR_CLASS;
-	div.val = "body";
+	tflags = htmltags[tag].flags;
 
-	print_otag(h, TAG_DIV, 1, &div);
-	return(1);
-}
+	/* Push this tags onto the stack of open scopes. */
 
+	if ((tflags & HTML_NOSTACK) == 0) {
+		t = mandoc_malloc(sizeof(struct tag));
+		t->tag = tag;
+		t->next = h->tags.head;
+		h->tags.head = t;
+	} else
+		t = NULL;
 
-static void
-mdoc_root_post(MDOC_ARGS)
-{
+	if (tflags & HTML_NLBEFORE)
+		html_endline(h);
+	if (h->flags & HTML_NLDONE)
+		html_indent(h);
+	else if ((h->flags & HTML_NOSPACE) == 0) {
+		if (h->flags & HTML_KEEP)
+			printf("&#160;");
+		else {
+			if (h->flags & HTML_PREKEEP)
+				h->flags |= HTML_KEEP;
+			putchar(' ');
+		}
+	}
 
-	print_ctag(h, TAG_DIV);
-}
+	if ( ! (h->flags & HTML_NONOSPACE))
+		h->flags &= ~HTML_NOSPACE;
+	else
+		h->flags |= HTML_NOSPACE;
 
+	/* Print out the tag name and attributes. */
 
-static int
-mdoc_ss_pre(MDOC_ARGS)
-{
+	printf("<%s", htmltags[tag].name);
 
-	if (MDOC_BODY == n->type)
-		print_otag(h, TAG_P, 0, NULL);
-	if (MDOC_HEAD == n->type)
-		print_otag(h, TAG_H2, 0, NULL);
-	return(1);
-}
+	va_start(ap, fmt);
 
+	have_style = 0;
+	while (*fmt != '\0') {
+		if (*fmt == 's') {
+			printf(" style=\"");
+			have_style = 1;
+			fmt++;
+			break;
+		}
+		s = va_arg(ap, char *);
+		switch (*fmt++) {
+		case 'c':
+			attr = "class";
+			break;
+		case 'h':
+			attr = "href";
+			break;
+		case 'i':
+			attr = "id";
+			break;
+		case '?':
+			attr = s;
+			s = va_arg(ap, char *);
+			break;
+		default:
+			abort();
+		}
+		printf(" %s=\"", attr);
+		switch (*fmt) {
+		case 'M':
+			print_href(h, s, va_arg(ap, char *), 1);
+			fmt++;
+			break;
+		case 'I':
+			print_href(h, s, NULL, 0);
+			fmt++;
+			break;
+		case 'R':
+			putchar('#');
+			fmt++;
+			/* FALLTHROUGH */
+		default:
+			print_encode(h, s, NULL, 1);
+			break;
+		}
+		putchar('"');
+	}
 
-static void
-mdoc_ss_post(MDOC_ARGS)
-{
+	/* Print out styles. */
 
-	if (MDOC_BODY == n->type)
-		print_ctag(h, TAG_P);
-	if (MDOC_HEAD == n->type)
-		print_ctag(h, TAG_H2);
-}
+	s = NULL;
+	su = &mysu;
+	while (*fmt != '\0') {
 
+		/* First letter: input argument type. */
 
-static int
-mdoc_pp_pre(MDOC_ARGS)
-{
+		switch (*fmt++) {
+		case 'h':
+			i = va_arg(ap, int);
+			SCALE_HS_INIT(su, i);
+			break;
+		case 's':
+			s = va_arg(ap, char *);
+			break;
+		case 'u':
+			su = va_arg(ap, struct roffsu *);
+			break;
+		case 'v':
+			i = va_arg(ap, int);
+			SCALE_VS_INIT(su, i);
+			break;
+		case 'w':
+			s = va_arg(ap, char *);
+			a2width(s, su);
+			break;
+		default:
+			abort();
+		}
 
-	print_otag(h, TAG_P, 0, NULL);
-	return(0);
-}
+		/* Second letter: style name. */
 
+		switch (*fmt++) {
+		case 'b':
+			attr = "margin-bottom";
+			break;
+		case 'h':
+			attr = "height";
+			break;
+		case 'i':
+			attr = "text-indent";
+			break;
+		case 'l':
+			attr = "margin-left";
+			break;
+		case 't':
+			attr = "margin-top";
+			break;
+		case 'w':
+			attr = "width";
+			break;
+		case 'W':
+			attr = "min-width";
+			break;
+		case '?':
+			printf("%s: %s;", s, va_arg(ap, char *));
+			continue;
+		default:
+			abort();
+		}
+		v = su->scale;
+		if (su->unit == SCALE_MM && (v /= 100.0) == 0.0)
+			v = 1.0;
+		else if (su->unit == SCALE_BU)
+			v /= 24.0;
+		printf("%s: %.2f%s;", attr, v, roffscales[su->unit]);
+	}
+	if (have_style)
+		putchar('"');
 
-static int
-mdoc_nd_pre(MDOC_ARGS)
-{
+	va_end(ap);
 
-	if (MDOC_BODY == n->type)
-		print_text(h, "--");
-	return(1);
-}
+	/* Accommodate for "well-formed" singleton escaping. */
 
+	if (HTML_AUTOCLOSE & htmltags[tag].flags)
+		putchar('/');
 
-static int
-mdoc_nm_pre(MDOC_ARGS)
-{
-	struct htmlpair	class;
+	putchar('>');
 
-	class.key = ATTR_CLASS;
-	class.val = "name";
+	if (tflags & HTML_NLBEGIN)
+		html_endline(h);
+	else
+		h->flags |= HTML_NOSPACE;
 
-	print_otag(h, TAG_SPAN, 1, &class);
-	if (NULL == n->child)
-		print_text(h, m->name);
+	if (tflags & HTML_INDENT)
+		h->indent++;
+	if (tflags & HTML_NOINDENT)
+		h->noindent++;
 
-	return(1);
+	return t;
 }
 
-
 static void
-mdoc_nm_post(MDOC_ARGS)
+print_ctag(struct html *h, struct tag *tag)
 {
+	int	 tflags;
 
-	print_ctag(h, TAG_SPAN);
-}
+	/*
+	 * Remember to close out and nullify the current
+	 * meta-font and table, if applicable.
+	 */
+	if (tag == h->metaf)
+		h->metaf = NULL;
+	if (tag == h->tblt)
+		h->tblt = NULL;
 
+	tflags = htmltags[tag->tag].flags;
 
-static int
-mdoc_sh_pre(MDOC_ARGS)
-{
+	if (tflags & HTML_INDENT)
+		h->indent--;
+	if (tflags & HTML_NOINDENT)
+		h->noindent--;
+	if (tflags & HTML_NLEND)
+		html_endline(h);
+	html_indent(h);
+	printf("</%s>", htmltags[tag->tag].name);
+	if (tflags & HTML_NLAFTER)
+		html_endline(h);
 
-	if (MDOC_BODY == n->type)
-		print_otag(h, TAG_P, 0, NULL);
-	if (MDOC_HEAD == n->type)
-		print_otag(h, TAG_H1, 0, NULL);
-	return(1);
+	h->tags.head = tag->next;
+	free(tag);
 }
 
-
-static void
-mdoc_sh_post(MDOC_ARGS)
+void
+print_gen_decls(struct html *h)
 {
 
-	if (MDOC_BODY == n->type)
-		print_ctag(h, TAG_P);
-	if (MDOC_HEAD == n->type)
-		print_ctag(h, TAG_H1);
+	puts("<!DOCTYPE html>");
+	h->flags |= HTML_NLDONE;
 }
 
-
-static void
-print_mdoc_node(MDOC_ARGS)
+void
+print_text(struct html *h, const char *word)
 {
-	int		 child;
+	if ((h->flags & (HTML_NLDONE | HTML_NOSPACE)) == 0) {
+		if ( ! (HTML_KEEP & h->flags)) {
+			if (HTML_PREKEEP & h->flags)
+				h->flags |= HTML_KEEP;
+			putchar(' ');
+		} else
+			printf("&#160;");
+	}
 
-	child = 1;
-
-	switch (n->type) {
-	case (MDOC_ROOT):
-		child = mdoc_root_pre(m, n, h);
+	assert(NULL == h->metaf);
+	switch (h->metac) {
+	case HTMLFONT_ITALIC:
+		h->metaf = print_otag(h, TAG_I, "");
 		break;
-	case (MDOC_TEXT):
-		print_text(h, n->string);
+	case HTMLFONT_BOLD:
+		h->metaf = print_otag(h, TAG_B, "");
 		break;
+	case HTMLFONT_BI:
+		h->metaf = print_otag(h, TAG_B, "");
+		print_otag(h, TAG_I, "");
+		break;
 	default:
-		if (mdocs[n->tok].pre)
-			child = (*mdocs[n->tok].pre)(m, n, h);
+		html_indent(h);
 		break;
 	}
 
-	if (child && n->child)
-		print_mdoc_node(m, n->child, h);
+	assert(word);
+	if ( ! print_encode(h, word, NULL, 0)) {
+		if ( ! (h->flags & HTML_NONOSPACE))
+			h->flags &= ~HTML_NOSPACE;
+		h->flags &= ~HTML_NONEWLINE;
+	} else
+		h->flags |= HTML_NOSPACE | HTML_NONEWLINE;
 
-	switch (n->type) {
-	case (MDOC_ROOT):
-		mdoc_root_post(m, n, h);
-		break;
-	case (MDOC_TEXT):
-		break;
-	default:
-		if (mdocs[n->tok].post)
-			(*mdocs[n->tok].post)(m, n, h);
-		break;
+	if (h->metaf) {
+		print_tagq(h, h->metaf);
+		h->metaf = NULL;
 	}
 
-	if (n->next)
-		print_mdoc_node(m, n->next, h);
+	h->flags &= ~HTML_IGNDELIM;
 }
 
-
-static void
-print_man(MAN_ARGS)
+void
+print_tagq(struct html *h, const struct tag *until)
 {
+	struct tag	*tag;
 
-	print_otag(h, TAG_HEAD, 0, NULL);
-	print_man_head(m, n, h);
-	print_ctag(h, TAG_HEAD);
-	print_otag(h, TAG_BODY, 0, NULL);
-	print_man_body(m, n, h);
-	print_ctag(h, TAG_BODY);
+	while ((tag = h->tags.head) != NULL) {
+		print_ctag(h, tag);
+		if (until && tag == until)
+			return;
+	}
 }
 
-
-static void
-print_man_head(MAN_ARGS)
+void
+print_stagq(struct html *h, const struct tag *suntil)
 {
+	struct tag	*tag;
 
-	print_gen_head(h);
-	print_otag(h, TAG_TITLE, 0, NULL);
-	print_encode(m->title);
-	print_ctag(h, TAG_TITLE);
+	while ((tag = h->tags.head) != NULL) {
+		if (suntil && tag == suntil)
+			return;
+		print_ctag(h, tag);
+	}
 }
 
-
-static void
-print_man_body(MAN_ARGS)
+void
+print_paragraph(struct html *h)
 {
-}
+	struct tag	*t;
 
-
-static void
-print_encode(const char *p)
-{
-
-	printf("%s", p); /* XXX */
+	t = print_otag(h, TAG_DIV, "c", "spacer");
+	print_tagq(h, t);
 }
 
-
+/*
+ * If something was printed on the current output line, end it.
+ * Not to be called right after html_indent().
+ */
 static void
-print_otag(struct html *h, enum htmltag tag, 
-		int sz, const struct htmlpair *p)
+html_endline(struct html *h)
 {
-	int		 i;
+	if (h->flags & HTML_NLDONE)
+		return;
 
-	if ( ! (HTML_NOSPACE & h->flags))
-		if ( ! (HTML_BLOCK & htmltags[tag].flags))
-			printf(" ");
-
-	printf("<%s", htmltags[tag].name);
-	for (i = 0; i < sz; i++) {
-		printf(" %s=\"", htmlattrs[p[i].key]);
-		assert(p->val);
-		print_encode(p[i].val);
-		printf("\"");
-	}
-	printf(">");
-
-	h->flags |= HTML_NOSPACE;
-
+	putchar('\n');
+	h->flags |= HTML_NLDONE | HTML_NOSPACE;
 }
 
-
-/* ARGSUSED */
+/*
+ * If at the beginning of a new output line,
+ * perform indentation and mark the line as containing output.
+ * Make sure to really produce some output right afterwards,
+ * but do not use print_otag() for producing it.
+ */
 static void
-print_ctag(struct html *h, enum htmltag tag)
+html_indent(struct html *h)
 {
-	
-	printf("</%s>", htmltags[tag].name);
-	if (HTML_BLOCK & htmltags[tag].flags)
-		h->flags |= HTML_NOSPACE;
-}
+	int	 i;
 
+	if ((h->flags & HTML_NLDONE) == 0)
+		return;
 
-/* ARGSUSED */
-static void
-print_gen_doctype(struct html *h)
-{
-	
-	printf("<!DOCTYPE HTML PUBLIC \"%s\" \"%s\">\n", DOCTYPE, DTD);
+	if (h->noindent == 0)
+		for (i = 0; i < h->indent * 2; i++)
+			putchar(' ');
+	h->flags &= ~(HTML_NLDONE | HTML_NOSPACE);
 }
 
-
+/*
+ * Calculate the scaling unit passed in a `-width' argument.  This uses
+ * either a native scaling unit (e.g., 1i, 2m) or the string length of
+ * the value.
+ */
 static void
-print_text(struct html *h, const char *p)
+a2width(const char *p, struct roffsu *su)
 {
-
-	if (*p && 0 == *(p + 1))
-		switch (*p) {
-		case('.'):
-			/* FALLTHROUGH */
-		case(','):
-			/* FALLTHROUGH */
-		case(';'):
-			/* FALLTHROUGH */
-		case(':'):
-			/* FALLTHROUGH */
-		case('?'):
-			/* FALLTHROUGH */
-		case('!'):
-			/* FALLTHROUGH */
-		case(')'):
-			/* FALLTHROUGH */
-		case(']'):
-			/* FALLTHROUGH */
-		case('}'):
-			h->flags |= HTML_NOSPACE;
-		default:
-			break;
-		}
-
-	if ( ! (h->flags & HTML_NOSPACE))
-		printf(" ");
-	h->flags &= ~HTML_NOSPACE;
-
-	if (p)
-		print_encode(p);
-
-	if (*p && 0 == *(p + 1))
-		switch (*p) {
-		case('('):
-			/* FALLTHROUGH */
-		case('['):
-			/* FALLTHROUGH */
-		case('{'):
-			h->flags |= HTML_NOSPACE;
-		default:
-			break;
-		}
+	if (a2roffsu(p, su, SCALE_MAX) < 2) {
+		su->unit = SCALE_EN;
+		su->scale = html_strlen(p);
+	} else if (su->scale < 0.0)
+		su->scale = 0.0;
 }