contrib/mdocml/html.c

   1 /*      $Id: html.c,v 1.124 2010/12/27 21:41:05 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17 #ifdef HAVE_CONFIG_H
  18 #include "config.h"
  19 #endif
  20
  21 #include <sys/types.h>
  22
  23 #include <assert.h>
  24 #include <ctype.h>
  25 #include <stdarg.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.h"
  33 #include "out.h"
  34 #include "chars.h"
  35 #include "html.h"
  36 #include "main.h"
  37
  38 struct  htmldata {
  39         const char       *name;
  40         int               flags;
  41 #define HTML_CLRLINE     (1 << 0)
  42 #define HTML_NOSTACK     (1 << 1)
  43 #define HTML_AUTOCLOSE   (1 << 2) /* Tag has auto-closure. */
  44 };
  45
  46 static  const struct htmldata htmltags[TAG_MAX] = {
  47         {"html",        HTML_CLRLINE}, /* TAG_HTML */
  48         {"head",        HTML_CLRLINE}, /* TAG_HEAD */
  49         {"body",        HTML_CLRLINE}, /* TAG_BODY */
  50         {"meta",        HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_META */
  51         {"title",       HTML_CLRLINE}, /* TAG_TITLE */
  52         {"div",         HTML_CLRLINE}, /* TAG_DIV */
  53         {"h1",          0}, /* TAG_H1 */
  54         {"h2",          0}, /* TAG_H2 */
  55         {"span",        0}, /* TAG_SPAN */
  56         {"link",        HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_LINK */
  57         {"br",          HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_BR */
  58         {"a",           0}, /* TAG_A */
  59         {"table",       HTML_CLRLINE}, /* TAG_TABLE */
  60         {"tbody",       HTML_CLRLINE}, /* TAG_TBODY */
  61         {"col",         HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_COL */
  62         {"tr",          HTML_CLRLINE}, /* TAG_TR */
  63         {"td",          HTML_CLRLINE}, /* TAG_TD */
  64         {"li",          HTML_CLRLINE}, /* TAG_LI */
  65         {"ul",          HTML_CLRLINE}, /* TAG_UL */
  66         {"ol",          HTML_CLRLINE}, /* TAG_OL */
  67         {"dl",          HTML_CLRLINE}, /* TAG_DL */
  68         {"dt",          HTML_CLRLINE}, /* TAG_DT */
  69         {"dd",          HTML_CLRLINE}, /* TAG_DD */
  70         {"blockquote",  HTML_CLRLINE}, /* TAG_BLOCKQUOTE */
  71         {"p",           HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_P */
  72         {"pre",         HTML_CLRLINE }, /* TAG_PRE */
  73         {"b",           0 }, /* TAG_B */
  74         {"i",           0 }, /* TAG_I */
  75         {"code",        0 }, /* TAG_CODE */
  76         {"small",       0 }, /* TAG_SMALL */
  77 };
  78
  79 static  const char      *const htmlattrs[ATTR_MAX] = {
  80         "http-equiv", /* ATTR_HTTPEQUIV */
  81         "content", /* ATTR_CONTENT */
  82         "name", /* ATTR_NAME */
  83         "rel", /* ATTR_REL */
  84         "href", /* ATTR_HREF */
  85         "type", /* ATTR_TYPE */
  86         "media", /* ATTR_MEDIA */
  87         "class", /* ATTR_CLASS */
  88         "style", /* ATTR_STYLE */
  89         "width", /* ATTR_WIDTH */
  90         "id", /* ATTR_ID */
  91         "summary", /* ATTR_SUMMARY */
  92         "align", /* ATTR_ALIGN */
  93 };
  94
  95 static  void              print_spec(struct html *, enum roffdeco,
  96                                 const char *, size_t);
  97 static  void              print_res(struct html *, const char *, size_t);
  98 static  void              print_ctag(struct html *, enum htmltag);
  99 static  void              print_doctype(struct html *);
 100 static  void              print_xmltype(struct html *);
 101 static  int               print_encode(struct html *, const char *, int);
 102 static  void              print_metaf(struct html *, enum roffdeco);
 103 static  void              print_attr(struct html *,
 104                                 const char *, const char *);
 105 static  void             *ml_alloc(char *, enum htmltype);
 106
 107
 108 static void *
 109 ml_alloc(char *outopts, enum htmltype type)
 110 {
 111         struct html     *h;
 112         const char      *toks[4];
 113         char            *v;
 114
 115         toks[0] = "style";
 116         toks[1] = "man";
 117         toks[2] = "includes";
 118         toks[3] = NULL;
 119
 120         h = calloc(1, sizeof(struct html));
 121         if (NULL == h) {
 122                 perror(NULL);
 123                 exit((int)MANDOCLEVEL_SYSERR);
 124         }
 125
 126         h->type = type;
 127         h->tags.head = NULL;
 128         h->symtab = chars_init(CHARS_HTML);
 129
 130         while (outopts && *outopts)
 131                 switch (getsubopt(&outopts, UNCONST(toks), &v)) {
 132                 case (0):
 133                         h->style = v;
 134                         break;
 135                 case (1):
 136                         h->base_man = v;
 137                         break;
 138                 case (2):
 139                         h->base_includes = v;
 140                         break;
 141                 default:
 142                         break;
 143                 }
 144
 145         return(h);
 146 }
 147
 148 void *
 149 html_alloc(char *outopts)
 150 {
 151
 152         return(ml_alloc(outopts, HTML_HTML_4_01_STRICT));
 153 }
 154
 155
 156 void *
 157 xhtml_alloc(char *outopts)
 158 {
 159
 160         return(ml_alloc(outopts, HTML_XHTML_1_0_STRICT));
 161 }
 162
 163
 164 void
 165 html_free(void *p)
 166 {
 167         struct tag      *tag;
 168         struct html     *h;
 169
 170         h = (struct html *)p;
 171
 172         while ((tag = h->tags.head) != NULL) {
 173                 h->tags.head = tag->next;
 174                 free(tag);
 175         }
 176
 177         if (h->symtab)
 178                 chars_free(h->symtab);
 179
 180         free(h);
 181 }
 182
 183
 184 void
 185 print_gen_head(struct html *h)
 186 {
 187         struct htmlpair  tag[4];
 188
 189         tag[0].key = ATTR_HTTPEQUIV;
 190         tag[0].val = "Content-Type";
 191         tag[1].key = ATTR_CONTENT;
 192         tag[1].val = "text/html; charset=utf-8";
 193         print_otag(h, TAG_META, 2, tag);
 194
 195         tag[0].key = ATTR_NAME;
 196         tag[0].val = "resource-type";
 197         tag[1].key = ATTR_CONTENT;
 198         tag[1].val = "document";
 199         print_otag(h, TAG_META, 2, tag);
 200
 201         if (h->style) {
 202                 tag[0].key = ATTR_REL;
 203                 tag[0].val = "stylesheet";
 204                 tag[1].key = ATTR_HREF;
 205                 tag[1].val = h->style;
 206                 tag[2].key = ATTR_TYPE;
 207                 tag[2].val = "text/css";
 208                 tag[3].key = ATTR_MEDIA;
 209                 tag[3].val = "all";
 210                 print_otag(h, TAG_LINK, 4, tag);
 211         }
 212 }
 213
 214
 215 static void
 216 print_spec(struct html *h, enum roffdeco d, const char *p, size_t len)
 217 {
 218         int              cp;
 219         const char      *rhs;
 220         size_t           sz;
 221
 222         if ((cp = chars_spec2cp(h->symtab, p, len)) > 0) {
 223                 printf("&#%d;", cp);
 224                 return;
 225         } else if (-1 == cp && DECO_SSPECIAL == d) {
 226                 fwrite(p, 1, len, stdout);
 227                 return;
 228         } else if (-1 == cp)
 229                 return;
 230
 231         if (NULL != (rhs = chars_spec2str(h->symtab, p, len, &sz)))
 232                 fwrite(rhs, 1, sz, stdout);
 233 }
 234
 235
 236 static void
 237 print_res(struct html *h, const char *p, size_t len)
 238 {
 239         int              cp;
 240         const char      *rhs;
 241         size_t           sz;
 242
 243         if ((cp = chars_res2cp(h->symtab, p, len)) > 0) {
 244                 printf("&#%d;", cp);
 245                 return;
 246         } else if (-1 == cp)
 247                 return;
 248
 249         if (NULL != (rhs = chars_res2str(h->symtab, p, len, &sz)))
 250                 fwrite(rhs, 1, sz, stdout);
 251 }
 252
 253
 254 static void
 255 print_metaf(struct html *h, enum roffdeco deco)
 256 {
 257         enum htmlfont    font;
 258
 259         switch (deco) {
 260         case (DECO_PREVIOUS):
 261                 font = h->metal;
 262                 break;
 263         case (DECO_ITALIC):
 264                 font = HTMLFONT_ITALIC;
 265                 break;
 266         case (DECO_BOLD):
 267                 font = HTMLFONT_BOLD;
 268                 break;
 269         case (DECO_ROMAN):
 270                 font = HTMLFONT_NONE;
 271                 break;
 272         default:
 273                 abort();
 274                 /* NOTREACHED */
 275         }
 276
 277         if (h->metaf) {
 278                 print_tagq(h, h->metaf);
 279                 h->metaf = NULL;
 280         }
 281
 282         h->metal = h->metac;
 283         h->metac = font;
 284
 285         if (HTMLFONT_NONE != font)
 286                 h->metaf = HTMLFONT_BOLD == font ?
 287                         print_otag(h, TAG_B, 0, NULL) :
 288                         print_otag(h, TAG_I, 0, NULL);
 289 }
 290
 291
 292 static int
 293 print_encode(struct html *h, const char *p, int norecurse)
 294 {
 295         size_t           sz;
 296         int              len, nospace;
 297         const char      *seq;
 298         enum roffdeco    deco;
 299         static const char rejs[6] = { '\\', '<', '>', '&', ASCII_HYPH, '\0' };
 300
 301         nospace = 0;
 302
 303         for (; *p; p++) {
 304                 sz = strcspn(p, rejs);
 305
 306                 fwrite(p, 1, sz, stdout);
 307                 p += /* LINTED */
 308                         sz;
 309
 310                 if ('<' == *p) {
 311                         printf("&lt;");
 312                         continue;
 313                 } else if ('>' == *p) {
 314                         printf("&gt;");
 315                         continue;
 316                 } else if ('&' == *p) {
 317                         printf("&amp;");
 318                         continue;
 319                 } else if (ASCII_HYPH == *p) {
 320                         /*
 321                          * Note: "soft hyphens" aren't graphically
 322                          * displayed when not breaking the text; we want
 323                          * them to be displayed.
 324                          */
 325                         /*printf("&#173;");*/
 326                         putchar('-');
 327                         continue;
 328                 } else if ('\0' == *p)
 329                         break;
 330
 331                 seq = ++p;
 332                 len = a2roffdeco(&deco, &seq, &sz);
 333
 334                 switch (deco) {
 335                 case (DECO_RESERVED):
 336                         print_res(h, seq, sz);
 337                         break;
 338                 case (DECO_SSPECIAL):
 339                         /* FALLTHROUGH */
 340                 case (DECO_SPECIAL):
 341                         print_spec(h, deco, seq, sz);
 342                         break;
 343                 case (DECO_PREVIOUS):
 344                         /* FALLTHROUGH */
 345                 case (DECO_BOLD):
 346                         /* FALLTHROUGH */
 347                 case (DECO_ITALIC):
 348                         /* FALLTHROUGH */
 349                 case (DECO_ROMAN):
 350                         if (norecurse)
 351                                 break;
 352                         print_metaf(h, deco);
 353                         break;
 354                 default:
 355                         break;
 356                 }
 357
 358                 p += len - 1;
 359
 360                 if (DECO_NOSPACE == deco && '\0' == *(p + 1))
 361                         nospace = 1;
 362         }
 363
 364         return(nospace);
 365 }
 366
 367
 368 static void
 369 print_attr(struct html *h, const char *key, const char *val)
 370 {
 371         printf(" %s=\"", key);
 372         (void)print_encode(h, val, 1);
 373         putchar('\"');
 374 }
 375
 376
 377 struct tag *
 378 print_otag(struct html *h, enum htmltag tag,
 379                 int sz, const struct htmlpair *p)
 380 {
 381         int              i;
 382         struct tag      *t;
 383
 384         /* Push this tags onto the stack of open scopes. */
 385
 386         if ( ! (HTML_NOSTACK & htmltags[tag].flags)) {
 387                 t = malloc(sizeof(struct tag));
 388                 if (NULL == t) {
 389                         perror(NULL);
 390                         exit((int)MANDOCLEVEL_SYSERR);
 391                 }
 392                 t->tag = tag;
 393                 t->next = h->tags.head;
 394                 h->tags.head = t;
 395         } else
 396                 t = NULL;
 397
 398         if ( ! (HTML_NOSPACE & h->flags))
 399                 if ( ! (HTML_CLRLINE & htmltags[tag].flags)) {
 400                         /* Manage keeps! */
 401                         if ( ! (HTML_KEEP & h->flags)) {
 402                                 if (HTML_PREKEEP & h->flags)
 403                                         h->flags |= HTML_KEEP;
 404                                 putchar(' ');
 405                         } else
 406                                 printf("&#160;");
 407                 }
 408
 409         if ( ! (h->flags & HTML_NONOSPACE))
 410                 h->flags &= ~HTML_NOSPACE;
 411         else
 412                 h->flags |= HTML_NOSPACE;
 413
 414         /* Print out the tag name and attributes. */
 415
 416         printf("<%s", htmltags[tag].name);
 417         for (i = 0; i < sz; i++)
 418                 print_attr(h, htmlattrs[p[i].key], p[i].val);
 419
 420         /* Add non-overridable attributes. */
 421
 422         if (TAG_HTML == tag && HTML_XHTML_1_0_STRICT == h->type) {
 423                 print_attr(h, "xmlns", "http://www.w3.org/1999/xhtml");
 424                 print_attr(h, "xml:lang", "en");
 425                 print_attr(h, "lang", "en");
 426         }
 427
 428         /* Accomodate for XML "well-formed" singleton escaping. */
 429
 430         if (HTML_AUTOCLOSE & htmltags[tag].flags)
 431                 switch (h->type) {
 432                 case (HTML_XHTML_1_0_STRICT):
 433                         putchar('/');
 434                         break;
 435                 default:
 436                         break;
 437                 }
 438
 439         putchar('>');
 440
 441         h->flags |= HTML_NOSPACE;
 442
 443         if ((HTML_AUTOCLOSE | HTML_CLRLINE) & htmltags[tag].flags)
 444                 putchar('\n');
 445
 446         return(t);
 447 }
 448
 449
 450 static void
 451 print_ctag(struct html *h, enum htmltag tag)
 452 {
 453
 454         printf("</%s>", htmltags[tag].name);
 455         if (HTML_CLRLINE & htmltags[tag].flags) {
 456                 h->flags |= HTML_NOSPACE;
 457                 putchar('\n');
 458         }
 459 }
 460
 461
 462 void
 463 print_gen_decls(struct html *h)
 464 {
 465
 466         print_xmltype(h);
 467         print_doctype(h);
 468 }
 469
 470
 471 static void
 472 print_xmltype(struct html *h)
 473 {
 474
 475         if (HTML_XHTML_1_0_STRICT == h->type)
 476                 puts("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
 477 }
 478
 479
 480 static void
 481 print_doctype(struct html *h)
 482 {
 483         const char      *doctype;
 484         const char      *dtd;
 485         const char      *name;
 486
 487         switch (h->type) {
 488         case (HTML_HTML_4_01_STRICT):
 489                 name = "HTML";
 490                 doctype = "-//W3C//DTD HTML 4.01//EN";
 491                 dtd = "http://www.w3.org/TR/html4/strict.dtd";
 492                 break;
 493         default:
 494                 name = "html";
 495                 doctype = "-//W3C//DTD XHTML 1.0 Strict//EN";
 496                 dtd = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd";
 497                 break;
 498         }
 499
 500         printf("<!DOCTYPE %s PUBLIC \"%s\" \"%s\">\n",
 501                         name, doctype, dtd);
 502 }
 503
 504
 505 void
 506 print_text(struct html *h, const char *word)
 507 {
 508
 509         if (word[0] && '\0' == word[1])
 510                 switch (word[0]) {
 511                 case('.'):
 512                         /* FALLTHROUGH */
 513                 case(','):
 514                         /* FALLTHROUGH */
 515                 case(';'):
 516                         /* FALLTHROUGH */
 517                 case(':'):
 518                         /* FALLTHROUGH */
 519                 case('?'):
 520                         /* FALLTHROUGH */
 521                 case('!'):
 522                         /* FALLTHROUGH */
 523                 case(')'):
 524                         /* FALLTHROUGH */
 525                 case(']'):
 526                         if ( ! (HTML_IGNDELIM & h->flags))
 527                                 h->flags |= HTML_NOSPACE;
 528                         break;
 529                 default:
 530                         break;
 531                 }
 532
 533         if ( ! (HTML_NOSPACE & h->flags)) {
 534                 /* Manage keeps! */
 535                 if ( ! (HTML_KEEP & h->flags)) {
 536                         if (HTML_PREKEEP & h->flags)
 537                                 h->flags |= HTML_KEEP;
 538                         putchar(' ');
 539                 } else
 540                         printf("&#160;");
 541         }
 542
 543         assert(NULL == h->metaf);
 544         if (HTMLFONT_NONE != h->metac)
 545                 h->metaf = HTMLFONT_BOLD == h->metac ?
 546                         print_otag(h, TAG_B, 0, NULL) :
 547                         print_otag(h, TAG_I, 0, NULL);
 548
 549         assert(word);
 550         if ( ! print_encode(h, word, 0))
 551                 if ( ! (h->flags & HTML_NONOSPACE))
 552                         h->flags &= ~HTML_NOSPACE;
 553
 554         if (h->metaf) {
 555                 print_tagq(h, h->metaf);
 556                 h->metaf = NULL;
 557         }
 558
 559         h->flags &= ~HTML_IGNDELIM;
 560
 561         /*
 562          * Note that we don't process the pipe: the parser sees it as
 563          * punctuation, but we don't in terms of typography.
 564          */
 565         if (word[0] && '\0' == word[1])
 566                 switch (word[0]) {
 567                 case('('):
 568                         /* FALLTHROUGH */
 569                 case('['):
 570                         h->flags |= HTML_NOSPACE;
 571                         break;
 572                 default:
 573                         break;
 574                 }
 575 }
 576
 577
 578 void
 579 print_tagq(struct html *h, const struct tag *until)
 580 {
 581         struct tag      *tag;
 582
 583         while ((tag = h->tags.head) != NULL) {
 584                 if (tag == h->metaf)
 585                         h->metaf = NULL;
 586                 print_ctag(h, tag->tag);
 587                 h->tags.head = tag->next;
 588                 free(tag);
 589                 if (until && tag == until)
 590                         return;
 591         }
 592 }
 593
 594
 595 void
 596 print_stagq(struct html *h, const struct tag *suntil)
 597 {
 598         struct tag      *tag;
 599
 600         while ((tag = h->tags.head) != NULL) {
 601                 if (suntil && tag == suntil)
 602                         return;
 603                 if (tag == h->metaf)
 604                         h->metaf = NULL;
 605                 print_ctag(h, tag->tag);
 606                 h->tags.head = tag->next;
 607                 free(tag);
 608         }
 609 }
 610
 611
 612 void
 613 bufinit(struct html *h)
 614 {
 615
 616         h->buf[0] = '\0';
 617         h->buflen = 0;
 618 }
 619
 620
 621 void
 622 bufcat_style(struct html *h, const char *key, const char *val)
 623 {
 624
 625         bufcat(h, key);
 626         bufncat(h, ":", 1);
 627         bufcat(h, val);
 628         bufncat(h, ";", 1);
 629 }
 630
 631
 632 void
 633 bufcat(struct html *h, const char *p)
 634 {
 635
 636         bufncat(h, p, strlen(p));
 637 }
 638
 639
 640 void
 641 buffmt(struct html *h, const char *fmt, ...)
 642 {
 643         va_list          ap;
 644
 645         va_start(ap, fmt);
 646         (void)vsnprintf(h->buf + (int)h->buflen,
 647                         BUFSIZ - h->buflen - 1, fmt, ap);
 648         va_end(ap);
 649         h->buflen = strlen(h->buf);
 650 }
 651
 652
 653 void
 654 bufncat(struct html *h, const char *p, size_t sz)
 655 {
 656
 657         if (h->buflen + sz > BUFSIZ - 1)
 658                 sz = BUFSIZ - 1 - h->buflen;
 659
 660         (void)strncat(h->buf, p, sz);
 661         h->buflen += sz;
 662 }
 663
 664
 665 void
 666 buffmt_includes(struct html *h, const char *name)
 667 {
 668         const char      *p, *pp;
 669
 670         pp = h->base_includes;
 671
 672         while (NULL != (p = strchr(pp, '%'))) {
 673                 bufncat(h, pp, (size_t)(p - pp));
 674                 switch (*(p + 1)) {
 675                 case('I'):
 676                         bufcat(h, name);
 677                         break;
 678                 default:
 679                         bufncat(h, p, 2);
 680                         break;
 681                 }
 682                 pp = p + 2;
 683         }
 684         if (pp)
 685                 bufcat(h, pp);
 686 }
 687
 688
 689 void
 690 buffmt_man(struct html *h,
 691                 const char *name, const char *sec)
 692 {
 693         const char      *p, *pp;
 694
 695         pp = h->base_man;
 696
 697         /* LINTED */
 698         while (NULL != (p = strchr(pp, '%'))) {
 699                 bufncat(h, pp, (size_t)(p - pp));
 700                 switch (*(p + 1)) {
 701                 case('S'):
 702                         bufcat(h, sec ? sec : "1");
 703                         break;
 704                 case('N'):
 705                         buffmt(h, name);
 706                         break;
 707                 default:
 708                         bufncat(h, p, 2);
 709                         break;
 710                 }
 711                 pp = p + 2;
 712         }
 713         if (pp)
 714                 bufcat(h, pp);
 715 }
 716
 717
 718 void
 719 bufcat_su(struct html *h, const char *p, const struct roffsu *su)
 720 {
 721         double           v;
 722         const char      *u;
 723
 724         v = su->scale;
 725
 726         switch (su->unit) {
 727         case (SCALE_CM):
 728                 u = "cm";
 729                 break;
 730         case (SCALE_IN):
 731                 u = "in";
 732                 break;
 733         case (SCALE_PC):
 734                 u = "pc";
 735                 break;
 736         case (SCALE_PT):
 737                 u = "pt";
 738                 break;
 739         case (SCALE_EM):
 740                 u = "em";
 741                 break;
 742         case (SCALE_MM):
 743                 if (0 == (v /= 100))
 744                         v = 1;
 745                 u = "em";
 746                 break;
 747         case (SCALE_EN):
 748                 u = "ex";
 749                 break;
 750         case (SCALE_BU):
 751                 u = "ex";
 752                 break;
 753         case (SCALE_VS):
 754                 u = "em";
 755                 break;
 756         default:
 757                 u = "ex";
 758                 break;
 759         }
 760
 761         /*
 762          * XXX: the CSS spec isn't clear as to which types accept
 763          * integer or real numbers, so we just make them all decimals.
 764          */
 765         buffmt(h, "%s: %.2f%s;", p, v, u);
 766 }
 767
 768
 769 void
 770 html_idcat(char *dst, const char *src, int sz)
 771 {
 772         int              ssz;
 773
 774         assert(sz > 2);
 775
 776         /* Cf. <http://www.w3.org/TR/html4/types.html#h-6.2>. */
 777
 778         /* We can't start with a number (bah). */
 779
 780         if ('#' == *dst) {
 781                 dst++;
 782                 sz--;
 783         }
 784         if ('\0' == *dst) {
 785                 *dst++ = 'x';
 786                 *dst = '\0';
 787                 sz--;
 788         }
 789
 790         for ( ; *dst != '\0' && sz; dst++, sz--)
 791                 /* Jump to end. */ ;
 792
 793         for ( ; *src != '\0' && sz > 1; src++) {
 794                 ssz = snprintf(dst, (size_t)sz, "%.2x", *src);
 795                 sz -= ssz;
 796                 dst += ssz;
 797         }
 798 }