bin/mandoc/html.c

   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, "&lt;");
 320                 break;
 321         case '>':
 322                 print_word(h, "&gt;");
 323                 break;
 324         case '&':
 325                 print_word(h, "&amp;");
 326                 break;
 327         case '"':
 328                 print_word(h, "&quot;");
 329                 break;
 330         case ASCII_NBRSP:
 331                 print_word(h, "&nbsp;");
 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, "&#x00A0;");
 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, "&#x00A0;");
 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 }