html.c

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