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