xref: /freebsd/contrib/mandoc/html.c (revision b88cc53d4ddda4486683ee2121f131b10ed21c30) 
1 /*	$Id: html.c,v 1.254 2019/03/03 13:02:11 schwarze Exp $ */
2 /*
3  * Copyright (c) 2008-2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
4  * Copyright (c) 2011-2015, 2017-2019 Ingo Schwarze <schwarze@openbsd.org>
5  *
6  * Permission to use, copy, modify, and distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18 #include "config.h"
19 
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 
23 #include <assert.h>
24 #include <ctype.h>
25 #include <stdarg.h>
26 #include <stddef.h>
27 #include <stdio.h>
28 #include <stdint.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <unistd.h>
32 
33 #include "mandoc_aux.h"
34 #include "mandoc_ohash.h"
35 #include "mandoc.h"
36 #include "roff.h"
37 #include "out.h"
38 #include "html.h"
39 #include "manconf.h"
40 #include "main.h"
41 
42 struct	htmldata {
43 	const char	 *name;
44 	int		  flags;
45 #define	HTML_NOSTACK	 (1 << 0)
46 #define	HTML_AUTOCLOSE	 (1 << 1)
47 #define	HTML_NLBEFORE	 (1 << 2)
48 #define	HTML_NLBEGIN	 (1 << 3)
49 #define	HTML_NLEND	 (1 << 4)
50 #define	HTML_NLAFTER	 (1 << 5)
51 #define	HTML_NLAROUND	 (HTML_NLBEFORE | HTML_NLAFTER)
52 #define	HTML_NLINSIDE	 (HTML_NLBEGIN | HTML_NLEND)
53 #define	HTML_NLALL	 (HTML_NLAROUND | HTML_NLINSIDE)
54 #define	HTML_INDENT	 (1 << 6)
55 #define	HTML_NOINDENT	 (1 << 7)
56 };
57 
58 static	const struct htmldata htmltags[TAG_MAX] = {
59 	{"html",	HTML_NLALL},
60 	{"head",	HTML_NLALL | HTML_INDENT},
61 	{"body",	HTML_NLALL},
62 	{"meta",	HTML_NOSTACK | HTML_AUTOCLOSE | HTML_NLALL},
63 	{"title",	HTML_NLAROUND},
64 	{"div",		HTML_NLAROUND},
65 	{"div",		0},
66 	{"section",	HTML_NLALL},
67 	{"h1",		HTML_NLAROUND},
68 	{"h2",		HTML_NLAROUND},
69 	{"span",	0},
70 	{"link",	HTML_NOSTACK | HTML_AUTOCLOSE | HTML_NLALL},
71 	{"br",		HTML_NOSTACK | HTML_AUTOCLOSE | HTML_NLALL},
72 	{"a",		0},
73 	{"table",	HTML_NLALL | HTML_INDENT},
74 	{"tr",		HTML_NLALL | HTML_INDENT},
75 	{"td",		HTML_NLAROUND},
76 	{"li",		HTML_NLAROUND | HTML_INDENT},
77 	{"ul",		HTML_NLALL | HTML_INDENT},
78 	{"ol",		HTML_NLALL | HTML_INDENT},
79 	{"dl",		HTML_NLALL | HTML_INDENT},
80 	{"dt",		HTML_NLAROUND},
81 	{"dd",		HTML_NLAROUND | HTML_INDENT},
82 	{"p",		HTML_NLAROUND | HTML_INDENT},
83 	{"pre",		HTML_NLALL | HTML_NOINDENT},
84 	{"var",		0},
85 	{"cite",	0},
86 	{"b",		0},
87 	{"i",		0},
88 	{"code",	0},
89 	{"small",	0},
90 	{"style",	HTML_NLALL | HTML_INDENT},
91 	{"math",	HTML_NLALL | HTML_INDENT},
92 	{"mrow",	0},
93 	{"mi",		0},
94 	{"mn",		0},
95 	{"mo",		0},
96 	{"msup",	0},
97 	{"msub",	0},
98 	{"msubsup",	0},
99 	{"mfrac",	0},
100 	{"msqrt",	0},
101 	{"mfenced",	0},
102 	{"mtable",	0},
103 	{"mtr",		0},
104 	{"mtd",		0},
105 	{"munderover",	0},
106 	{"munder",	0},
107 	{"mover",	0},
108 };
109 
110 /* Avoid duplicate HTML id= attributes. */
111 static	struct ohash	 id_unique;
112 
113 static	void	 html_reset_internal(struct html *);
114 static	void	 print_byte(struct html *, char);
115 static	void	 print_endword(struct html *);
116 static	void	 print_indent(struct html *);
117 static	void	 print_word(struct html *, const char *);
118 
119 static	void	 print_ctag(struct html *, struct tag *);
120 static	int	 print_escape(struct html *, char);
121 static	int	 print_encode(struct html *, const char *, const char *, int);
122 static	void	 print_href(struct html *, const char *, const char *, int);
123 
124 
125 void *
126 html_alloc(const struct manoutput *outopts)
127 {
128 	struct html	*h;
129 
130 	h = mandoc_calloc(1, sizeof(struct html));
131 
132 	h->tag = NULL;
133 	h->style = outopts->style;
134 	if ((h->base_man1 = outopts->man) == NULL)
135 		h->base_man2 = NULL;
136 	else if ((h->base_man2 = strchr(h->base_man1, ';')) != NULL)
137 		*h->base_man2++ = '\0';
138 	h->base_includes = outopts->includes;
139 	if (outopts->fragment)
140 		h->oflags |= HTML_FRAGMENT;
141 	if (outopts->toc)
142 		h->oflags |= HTML_TOC;
143 
144 	mandoc_ohash_init(&id_unique, 4, 0);
145 
146 	return h;
147 }
148 
149 static void
150 html_reset_internal(struct html *h)
151 {
152 	struct tag	*tag;
153 	char		*cp;
154 	unsigned int	 slot;
155 
156 	while ((tag = h->tag) != NULL) {
157 		h->tag = tag->next;
158 		free(tag);
159 	}
160 	cp = ohash_first(&id_unique, &slot);
161 	while (cp != NULL) {
162 		free(cp);
163 		cp = ohash_next(&id_unique, &slot);
164 	}
165 	ohash_delete(&id_unique);
166 }
167 
168 void
169 html_reset(void *p)
170 {
171 	html_reset_internal(p);
172 	mandoc_ohash_init(&id_unique, 4, 0);
173 }
174 
175 void
176 html_free(void *p)
177 {
178 	html_reset_internal(p);
179 	free(p);
180 }
181 
182 void
183 print_gen_head(struct html *h)
184 {
185 	struct tag	*t;
186 
187 	print_otag(h, TAG_META, "?", "charset", "utf-8");
188 	if (h->style != NULL) {
189 		print_otag(h, TAG_LINK, "?h??", "rel", "stylesheet",
190 		    h->style, "type", "text/css", "media", "all");
191 		return;
192 	}
193 
194 	/*
195 	 * Print a minimal embedded style sheet.
196 	 */
197 
198 	t = print_otag(h, TAG_STYLE, "");
199 	print_text(h, "table.head, table.foot { width: 100%; }");
200 	print_endline(h);
201 	print_text(h, "td.head-rtitle, td.foot-os { text-align: right; }");
202 	print_endline(h);
203 	print_text(h, "td.head-vol { text-align: center; }");
204 	print_endline(h);
205 	print_text(h, "div.Pp { margin: 1ex 0ex; }");
206 	print_endline(h);
207 	print_text(h, "div.Nd, div.Bf, div.Op { display: inline; }");
208 	print_endline(h);
209 	print_text(h, "span.Pa, span.Ad { font-style: italic; }");
210 	print_endline(h);
211 	print_text(h, "span.Ms { font-weight: bold; }");
212 	print_endline(h);
213 	print_text(h, "dl.Bl-diag ");
214 	print_byte(h, '>');
215 	print_text(h, " dt { font-weight: bold; }");
216 	print_endline(h);
217 	print_text(h, "code.Nm, code.Fl, code.Cm, code.Ic, "
218 	    "code.In, code.Fd, code.Fn,");
219 	print_endline(h);
220 	print_text(h, "code.Cd { font-weight: bold; "
221 	    "font-family: inherit; }");
222 	print_tagq(h, t);
223 }
224 
225 void
226 print_metaf(struct html *h, enum mandoc_esc deco)
227 {
228 	enum htmlfont	 font;
229 
230 	switch (deco) {
231 	case ESCAPE_FONTPREV:
232 		font = h->metal;
233 		break;
234 	case ESCAPE_FONTITALIC:
235 		font = HTMLFONT_ITALIC;
236 		break;
237 	case ESCAPE_FONTBOLD:
238 		font = HTMLFONT_BOLD;
239 		break;
240 	case ESCAPE_FONTBI:
241 		font = HTMLFONT_BI;
242 		break;
243 	case ESCAPE_FONTCW:
244 		font = HTMLFONT_CW;
245 		break;
246 	case ESCAPE_FONT:
247 	case ESCAPE_FONTROMAN:
248 		font = HTMLFONT_NONE;
249 		break;
250 	default:
251 		return;
252 	}
253 
254 	if (h->metaf) {
255 		print_tagq(h, h->metaf);
256 		h->metaf = NULL;
257 	}
258 
259 	h->metal = h->metac;
260 	h->metac = font;
261 
262 	switch (font) {
263 	case HTMLFONT_ITALIC:
264 		h->metaf = print_otag(h, TAG_I, "");
265 		break;
266 	case HTMLFONT_BOLD:
267 		h->metaf = print_otag(h, TAG_B, "");
268 		break;
269 	case HTMLFONT_BI:
270 		h->metaf = print_otag(h, TAG_B, "");
271 		print_otag(h, TAG_I, "");
272 		break;
273 	case HTMLFONT_CW:
274 		h->metaf = print_otag(h, TAG_SPAN, "c", "Li");
275 		break;
276 	default:
277 		break;
278 	}
279 }
280 
281 void
282 html_close_paragraph(struct html *h)
283 {
284 	struct tag	*t;
285 
286 	for (t = h->tag; t != NULL && t->closed == 0; t = t->next) {
287 		switch(t->tag) {
288 		case TAG_P:
289 		case TAG_PRE:
290 			print_tagq(h, t);
291 			break;
292 		case TAG_A:
293 			print_tagq(h, t);
294 			continue;
295 		default:
296 			continue;
297 		}
298 		break;
299 	}
300 }
301 
302 /*
303  * ROFF_nf switches to no-fill mode, ROFF_fi to fill mode.
304  * TOKEN_NONE does not switch.  The old mode is returned.
305  */
306 enum roff_tok
307 html_fillmode(struct html *h, enum roff_tok want)
308 {
309 	struct tag	*t;
310 	enum roff_tok	 had;
311 
312 	for (t = h->tag; t != NULL; t = t->next)
313 		if (t->tag == TAG_PRE)
314 			break;
315 
316 	had = t == NULL ? ROFF_fi : ROFF_nf;
317 
318 	if (want != had) {
319 		switch (want) {
320 		case ROFF_fi:
321 			print_tagq(h, t);
322 			break;
323 		case ROFF_nf:
324 			html_close_paragraph(h);
325 			print_otag(h, TAG_PRE, "");
326 			break;
327 		case TOKEN_NONE:
328 			break;
329 		default:
330 			abort();
331 		}
332 	}
333 	return had;
334 }
335 
336 char *
337 html_make_id(const struct roff_node *n, int unique)
338 {
339 	const struct roff_node	*nch;
340 	char			*buf, *bufs, *cp;
341 	unsigned int		 slot;
342 	int			 suffix;
343 
344 	for (nch = n->child; nch != NULL; nch = nch->next)
345 		if (nch->type != ROFFT_TEXT)
346 			return NULL;
347 
348 	buf = NULL;
349 	deroff(&buf, n);
350 	if (buf == NULL)
351 		return NULL;
352 
353 	/*
354 	 * In ID attributes, only use ASCII characters that are
355 	 * permitted in URL-fragment strings according to the
356 	 * explicit list at:
357 	 * https://url.spec.whatwg.org/#url-fragment-string
358 	 */
359 
360 	for (cp = buf; *cp != '\0'; cp++)
361 		if (isalnum((unsigned char)*cp) == 0 &&
362 		    strchr("!$&'()*+,-./:;=?@_~", *cp) == NULL)
363 			*cp = '_';
364 
365 	if (unique == 0)
366 		return buf;
367 
368 	/* Avoid duplicate HTML id= attributes. */
369 
370 	bufs = NULL;
371 	suffix = 1;
372 	slot = ohash_qlookup(&id_unique, buf);
373 	cp = ohash_find(&id_unique, slot);
374 	if (cp != NULL) {
375 		while (cp != NULL) {
376 			free(bufs);
377 			if (++suffix > 127) {
378 				free(buf);
379 				return NULL;
380 			}
381 			mandoc_asprintf(&bufs, "%s_%d", buf, suffix);
382 			slot = ohash_qlookup(&id_unique, bufs);
383 			cp = ohash_find(&id_unique, slot);
384 		}
385 		free(buf);
386 		buf = bufs;
387 	}
388 	ohash_insert(&id_unique, slot, buf);
389 	return buf;
390 }
391 
392 static int
393 print_escape(struct html *h, char c)
394 {
395 
396 	switch (c) {
397 	case '<':
398 		print_word(h, "&lt;");
399 		break;
400 	case '>':
401 		print_word(h, "&gt;");
402 		break;
403 	case '&':
404 		print_word(h, "&amp;");
405 		break;
406 	case '"':
407 		print_word(h, "&quot;");
408 		break;
409 	case ASCII_NBRSP:
410 		print_word(h, "&nbsp;");
411 		break;
412 	case ASCII_HYPH:
413 		print_byte(h, '-');
414 		break;
415 	case ASCII_BREAK:
416 		break;
417 	default:
418 		return 0;
419 	}
420 	return 1;
421 }
422 
423 static int
424 print_encode(struct html *h, const char *p, const char *pend, int norecurse)
425 {
426 	char		 numbuf[16];
427 	const char	*seq;
428 	size_t		 sz;
429 	int		 c, len, breakline, nospace;
430 	enum mandoc_esc	 esc;
431 	static const char rejs[10] = { ' ', '\\', '<', '>', '&', '"',
432 		ASCII_NBRSP, ASCII_HYPH, ASCII_BREAK, '\0' };
433 
434 	if (pend == NULL)
435 		pend = strchr(p, '\0');
436 
437 	breakline = 0;
438 	nospace = 0;
439 
440 	while (p < pend) {
441 		if (HTML_SKIPCHAR & h->flags && '\\' != *p) {
442 			h->flags &= ~HTML_SKIPCHAR;
443 			p++;
444 			continue;
445 		}
446 
447 		for (sz = strcspn(p, rejs); sz-- && p < pend; p++)
448 			print_byte(h, *p);
449 
450 		if (breakline &&
451 		    (p >= pend || *p == ' ' || *p == ASCII_NBRSP)) {
452 			print_otag(h, TAG_BR, "");
453 			breakline = 0;
454 			while (p < pend && (*p == ' ' || *p == ASCII_NBRSP))
455 				p++;
456 			continue;
457 		}
458 
459 		if (p >= pend)
460 			break;
461 
462 		if (*p == ' ') {
463 			print_endword(h);
464 			p++;
465 			continue;
466 		}
467 
468 		if (print_escape(h, *p++))
469 			continue;
470 
471 		esc = mandoc_escape(&p, &seq, &len);
472 		switch (esc) {
473 		case ESCAPE_FONT:
474 		case ESCAPE_FONTPREV:
475 		case ESCAPE_FONTBOLD:
476 		case ESCAPE_FONTITALIC:
477 		case ESCAPE_FONTBI:
478 		case ESCAPE_FONTCW:
479 		case ESCAPE_FONTROMAN:
480 			if (0 == norecurse) {
481 				h->flags |= HTML_NOSPACE;
482 				print_metaf(h, esc);
483 				h->flags &= ~HTML_NOSPACE;
484 			}
485 			continue;
486 		case ESCAPE_SKIPCHAR:
487 			h->flags |= HTML_SKIPCHAR;
488 			continue;
489 		case ESCAPE_ERROR:
490 			continue;
491 		default:
492 			break;
493 		}
494 
495 		if (h->flags & HTML_SKIPCHAR) {
496 			h->flags &= ~HTML_SKIPCHAR;
497 			continue;
498 		}
499 
500 		switch (esc) {
501 		case ESCAPE_UNICODE:
502 			/* Skip past "u" header. */
503 			c = mchars_num2uc(seq + 1, len - 1);
504 			break;
505 		case ESCAPE_NUMBERED:
506 			c = mchars_num2char(seq, len);
507 			if (c < 0)
508 				continue;
509 			break;
510 		case ESCAPE_SPECIAL:
511 			c = mchars_spec2cp(seq, len);
512 			if (c <= 0)
513 				continue;
514 			break;
515 		case ESCAPE_UNDEF:
516 			c = *seq;
517 			break;
518 		case ESCAPE_DEVICE:
519 			print_word(h, "html");
520 			continue;
521 		case ESCAPE_BREAK:
522 			breakline = 1;
523 			continue;
524 		case ESCAPE_NOSPACE:
525 			if ('\0' == *p)
526 				nospace = 1;
527 			continue;
528 		case ESCAPE_OVERSTRIKE:
529 			if (len == 0)
530 				continue;
531 			c = seq[len - 1];
532 			break;
533 		default:
534 			continue;
535 		}
536 		if ((c < 0x20 && c != 0x09) ||
537 		    (c > 0x7E && c < 0xA0))
538 			c = 0xFFFD;
539 		if (c > 0x7E) {
540 			(void)snprintf(numbuf, sizeof(numbuf), "&#x%.4X;", c);
541 			print_word(h, numbuf);
542 		} else if (print_escape(h, c) == 0)
543 			print_byte(h, c);
544 	}
545 
546 	return nospace;
547 }
548 
549 static void
550 print_href(struct html *h, const char *name, const char *sec, int man)
551 {
552 	struct stat	 sb;
553 	const char	*p, *pp;
554 	char		*filename;
555 
556 	if (man) {
557 		pp = h->base_man1;
558 		if (h->base_man2 != NULL) {
559 			mandoc_asprintf(&filename, "%s.%s", name, sec);
560 			if (stat(filename, &sb) == -1)
561 				pp = h->base_man2;
562 			free(filename);
563 		}
564 	} else
565 		pp = h->base_includes;
566 
567 	while ((p = strchr(pp, '%')) != NULL) {
568 		print_encode(h, pp, p, 1);
569 		if (man && p[1] == 'S') {
570 			if (sec == NULL)
571 				print_byte(h, '1');
572 			else
573 				print_encode(h, sec, NULL, 1);
574 		} else if ((man && p[1] == 'N') ||
575 		    (man == 0 && p[1] == 'I'))
576 			print_encode(h, name, NULL, 1);
577 		else
578 			print_encode(h, p, p + 2, 1);
579 		pp = p + 2;
580 	}
581 	if (*pp != '\0')
582 		print_encode(h, pp, NULL, 1);
583 }
584 
585 struct tag *
586 print_otag(struct html *h, enum htmltag tag, const char *fmt, ...)
587 {
588 	va_list		 ap;
589 	struct tag	*t;
590 	const char	*attr;
591 	char		*arg1, *arg2;
592 	int		 style_written, tflags;
593 
594 	tflags = htmltags[tag].flags;
595 
596 	/* Push this tag onto the stack of open scopes. */
597 
598 	if ((tflags & HTML_NOSTACK) == 0) {
599 		t = mandoc_malloc(sizeof(struct tag));
600 		t->tag = tag;
601 		t->next = h->tag;
602 		t->refcnt = 0;
603 		t->closed = 0;
604 		h->tag = t;
605 	} else
606 		t = NULL;
607 
608 	if (tflags & HTML_NLBEFORE)
609 		print_endline(h);
610 	if (h->col == 0)
611 		print_indent(h);
612 	else if ((h->flags & HTML_NOSPACE) == 0) {
613 		if (h->flags & HTML_KEEP)
614 			print_word(h, "&#x00A0;");
615 		else {
616 			if (h->flags & HTML_PREKEEP)
617 				h->flags |= HTML_KEEP;
618 			print_endword(h);
619 		}
620 	}
621 
622 	if ( ! (h->flags & HTML_NONOSPACE))
623 		h->flags &= ~HTML_NOSPACE;
624 	else
625 		h->flags |= HTML_NOSPACE;
626 
627 	/* Print out the tag name and attributes. */
628 
629 	print_byte(h, '<');
630 	print_word(h, htmltags[tag].name);
631 
632 	va_start(ap, fmt);
633 
634 	while (*fmt != '\0' && *fmt != 's') {
635 
636 		/* Parse attributes and arguments. */
637 
638 		arg1 = va_arg(ap, char *);
639 		arg2 = NULL;
640 		switch (*fmt++) {
641 		case 'c':
642 			attr = "class";
643 			break;
644 		case 'h':
645 			attr = "href";
646 			break;
647 		case 'i':
648 			attr = "id";
649 			break;
650 		case '?':
651 			attr = arg1;
652 			arg1 = va_arg(ap, char *);
653 			break;
654 		default:
655 			abort();
656 		}
657 		if (*fmt == 'M')
658 			arg2 = va_arg(ap, char *);
659 		if (arg1 == NULL)
660 			continue;
661 
662 		/* Print the attributes. */
663 
664 		print_byte(h, ' ');
665 		print_word(h, attr);
666 		print_byte(h, '=');
667 		print_byte(h, '"');
668 		switch (*fmt) {
669 		case 'I':
670 			print_href(h, arg1, NULL, 0);
671 			fmt++;
672 			break;
673 		case 'M':
674 			print_href(h, arg1, arg2, 1);
675 			fmt++;
676 			break;
677 		case 'R':
678 			print_byte(h, '#');
679 			print_encode(h, arg1, NULL, 1);
680 			fmt++;
681 			break;
682 		default:
683 			print_encode(h, arg1, NULL, 1);
684 			break;
685 		}
686 		print_byte(h, '"');
687 	}
688 
689 	style_written = 0;
690 	while (*fmt++ == 's') {
691 		arg1 = va_arg(ap, char *);
692 		arg2 = va_arg(ap, char *);
693 		if (arg2 == NULL)
694 			continue;
695 		print_byte(h, ' ');
696 		if (style_written == 0) {
697 			print_word(h, "style=\"");
698 			style_written = 1;
699 		}
700 		print_word(h, arg1);
701 		print_byte(h, ':');
702 		print_byte(h, ' ');
703 		print_word(h, arg2);
704 		print_byte(h, ';');
705 	}
706 	if (style_written)
707 		print_byte(h, '"');
708 
709 	va_end(ap);
710 
711 	/* Accommodate for "well-formed" singleton escaping. */
712 
713 	if (HTML_AUTOCLOSE & htmltags[tag].flags)
714 		print_byte(h, '/');
715 
716 	print_byte(h, '>');
717 
718 	if (tflags & HTML_NLBEGIN)
719 		print_endline(h);
720 	else
721 		h->flags |= HTML_NOSPACE;
722 
723 	if (tflags & HTML_INDENT)
724 		h->indent++;
725 	if (tflags & HTML_NOINDENT)
726 		h->noindent++;
727 
728 	return t;
729 }
730 
731 static void
732 print_ctag(struct html *h, struct tag *tag)
733 {
734 	int	 tflags;
735 
736 	if (tag->closed == 0) {
737 		tag->closed = 1;
738 		if (tag == h->metaf)
739 			h->metaf = NULL;
740 		if (tag == h->tblt)
741 			h->tblt = NULL;
742 
743 		tflags = htmltags[tag->tag].flags;
744 		if (tflags & HTML_INDENT)
745 			h->indent--;
746 		if (tflags & HTML_NOINDENT)
747 			h->noindent--;
748 		if (tflags & HTML_NLEND)
749 			print_endline(h);
750 		print_indent(h);
751 		print_byte(h, '<');
752 		print_byte(h, '/');
753 		print_word(h, htmltags[tag->tag].name);
754 		print_byte(h, '>');
755 		if (tflags & HTML_NLAFTER)
756 			print_endline(h);
757 	}
758 	if (tag->refcnt == 0) {
759 		h->tag = tag->next;
760 		free(tag);
761 	}
762 }
763 
764 void
765 print_gen_decls(struct html *h)
766 {
767 	print_word(h, "<!DOCTYPE html>");
768 	print_endline(h);
769 }
770 
771 void
772 print_gen_comment(struct html *h, struct roff_node *n)
773 {
774 	int	 wantblank;
775 
776 	print_word(h, "<!-- This is an automatically generated file."
777 	    "  Do not edit.");
778 	h->indent = 1;
779 	wantblank = 0;
780 	while (n != NULL && n->type == ROFFT_COMMENT) {
781 		if (strstr(n->string, "-->") == NULL &&
782 		    (wantblank || *n->string != '\0')) {
783 			print_endline(h);
784 			print_indent(h);
785 			print_word(h, n->string);
786 			wantblank = *n->string != '\0';
787 		}
788 		n = n->next;
789 	}
790 	if (wantblank)
791 		print_endline(h);
792 	print_word(h, " -->");
793 	print_endline(h);
794 	h->indent = 0;
795 }
796 
797 void
798 print_text(struct html *h, const char *word)
799 {
800 	if (h->col && (h->flags & HTML_NOSPACE) == 0) {
801 		if ( ! (HTML_KEEP & h->flags)) {
802 			if (HTML_PREKEEP & h->flags)
803 				h->flags |= HTML_KEEP;
804 			print_endword(h);
805 		} else
806 			print_word(h, "&#x00A0;");
807 	}
808 
809 	assert(NULL == h->metaf);
810 	switch (h->metac) {
811 	case HTMLFONT_ITALIC:
812 		h->metaf = print_otag(h, TAG_I, "");
813 		break;
814 	case HTMLFONT_BOLD:
815 		h->metaf = print_otag(h, TAG_B, "");
816 		break;
817 	case HTMLFONT_BI:
818 		h->metaf = print_otag(h, TAG_B, "");
819 		print_otag(h, TAG_I, "");
820 		break;
821 	case HTMLFONT_CW:
822 		h->metaf = print_otag(h, TAG_SPAN, "c", "Li");
823 		break;
824 	default:
825 		print_indent(h);
826 		break;
827 	}
828 
829 	assert(word);
830 	if ( ! print_encode(h, word, NULL, 0)) {
831 		if ( ! (h->flags & HTML_NONOSPACE))
832 			h->flags &= ~HTML_NOSPACE;
833 		h->flags &= ~HTML_NONEWLINE;
834 	} else
835 		h->flags |= HTML_NOSPACE | HTML_NONEWLINE;
836 
837 	if (h->metaf) {
838 		print_tagq(h, h->metaf);
839 		h->metaf = NULL;
840 	}
841 
842 	h->flags &= ~HTML_IGNDELIM;
843 }
844 
845 void
846 print_tagq(struct html *h, const struct tag *until)
847 {
848 	struct tag	*this, *next;
849 
850 	for (this = h->tag; this != NULL; this = next) {
851 		next = this == until ? NULL : this->next;
852 		print_ctag(h, this);
853 	}
854 }
855 
856 /*
857  * Close out all open elements up to but excluding suntil.
858  * Note that a paragraph just inside stays open together with it
859  * because paragraphs include subsequent phrasing content.
860  */
861 void
862 print_stagq(struct html *h, const struct tag *suntil)
863 {
864 	struct tag	*this, *next;
865 
866 	for (this = h->tag; this != NULL; this = next) {
867 		next = this->next;
868 		if (this == suntil || (next == suntil &&
869 		    (this->tag == TAG_P || this->tag == TAG_PRE)))
870 			break;
871 		print_ctag(h, this);
872 	}
873 }
874 
875 
876 /***********************************************************************
877  * Low level output functions.
878  * They implement line breaking using a short static buffer.
879  ***********************************************************************/
880 
881 /*
882  * Buffer one HTML output byte.
883  * If the buffer is full, flush and deactivate it and start a new line.
884  * If the buffer is inactive, print directly.
885  */
886 static void
887 print_byte(struct html *h, char c)
888 {
889 	if ((h->flags & HTML_BUFFER) == 0) {
890 		putchar(c);
891 		h->col++;
892 		return;
893 	}
894 
895 	if (h->col + h->bufcol < sizeof(h->buf)) {
896 		h->buf[h->bufcol++] = c;
897 		return;
898 	}
899 
900 	putchar('\n');
901 	h->col = 0;
902 	print_indent(h);
903 	putchar(' ');
904 	putchar(' ');
905 	fwrite(h->buf, h->bufcol, 1, stdout);
906 	putchar(c);
907 	h->col = (h->indent + 1) * 2 + h->bufcol + 1;
908 	h->bufcol = 0;
909 	h->flags &= ~HTML_BUFFER;
910 }
911 
912 /*
913  * If something was printed on the current output line, end it.
914  * Not to be called right after print_indent().
915  */
916 void
917 print_endline(struct html *h)
918 {
919 	if (h->col == 0)
920 		return;
921 
922 	if (h->bufcol) {
923 		putchar(' ');
924 		fwrite(h->buf, h->bufcol, 1, stdout);
925 		h->bufcol = 0;
926 	}
927 	putchar('\n');
928 	h->col = 0;
929 	h->flags |= HTML_NOSPACE;
930 	h->flags &= ~HTML_BUFFER;
931 }
932 
933 /*
934  * Flush the HTML output buffer.
935  * If it is inactive, activate it.
936  */
937 static void
938 print_endword(struct html *h)
939 {
940 	if (h->noindent) {
941 		print_byte(h, ' ');
942 		return;
943 	}
944 
945 	if ((h->flags & HTML_BUFFER) == 0) {
946 		h->col++;
947 		h->flags |= HTML_BUFFER;
948 	} else if (h->bufcol) {
949 		putchar(' ');
950 		fwrite(h->buf, h->bufcol, 1, stdout);
951 		h->col += h->bufcol + 1;
952 	}
953 	h->bufcol = 0;
954 }
955 
956 /*
957  * If at the beginning of a new output line,
958  * perform indentation and mark the line as containing output.
959  * Make sure to really produce some output right afterwards,
960  * but do not use print_otag() for producing it.
961  */
962 static void
963 print_indent(struct html *h)
964 {
965 	size_t	 i;
966 
967 	if (h->col)
968 		return;
969 
970 	if (h->noindent == 0) {
971 		h->col = h->indent * 2;
972 		for (i = 0; i < h->col; i++)
973 			putchar(' ');
974 	}
975 	h->flags &= ~HTML_NOSPACE;
976 }
977 
978 /*
979  * Print or buffer some characters
980  * depending on the current HTML output buffer state.
981  */
982 static void
983 print_word(struct html *h, const char *cp)
984 {
985 	while (*cp != '\0')
986 		print_byte(h, *cp++);
987 }
988