=================================================================== RCS file: /cvs/mandoc/html.c,v retrieving revision 1.93 retrieving revision 1.164 diff -u -p -r1.93 -r1.164 --- mandoc/html.c 2010/01/29 14:39:37 1.93 +++ mandoc/html.c 2014/09/27 08:54:34 1.164 @@ -1,6 +1,7 @@ -/* $Id: html.c,v 1.93 2010/01/29 14:39:37 kristaps Exp $ */ +/* $Id: html.c,v 1.164 2014/09/27 08:54:34 kristaps Exp $ */ /* - * Copyright (c) 2008, 2009 Kristaps Dzonsons + * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons + * Copyright (c) 2011, 2012, 2013, 2014 Ingo Schwarze * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -14,9 +15,7 @@ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include @@ -29,13 +28,13 @@ #include #include +#include "mandoc.h" +#include "mandoc_aux.h" +#include "libmandoc.h" #include "out.h" -#include "chars.h" #include "html.h" #include "main.h" -#define UNCONST(a) ((void *)(uintptr_t)(const void *)(a)) - struct htmldata { const char *name; int flags; @@ -54,85 +53,102 @@ static const struct htmldata htmltags[TAG_MAX] = { {"h1", 0}, /* TAG_H1 */ {"h2", 0}, /* TAG_H2 */ {"span", 0}, /* TAG_SPAN */ - {"link", HTML_CLRLINE | HTML_NOSTACK}, /* TAG_LINK */ + {"link", HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_LINK */ {"br", HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_BR */ {"a", 0}, /* TAG_A */ {"table", HTML_CLRLINE}, /* TAG_TABLE */ + {"tbody", HTML_CLRLINE}, /* TAG_TBODY */ {"col", HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_COL */ {"tr", HTML_CLRLINE}, /* TAG_TR */ {"td", HTML_CLRLINE}, /* TAG_TD */ {"li", HTML_CLRLINE}, /* TAG_LI */ {"ul", HTML_CLRLINE}, /* TAG_UL */ {"ol", HTML_CLRLINE}, /* TAG_OL */ + {"dl", HTML_CLRLINE}, /* TAG_DL */ + {"dt", HTML_CLRLINE}, /* TAG_DT */ + {"dd", HTML_CLRLINE}, /* TAG_DD */ + {"blockquote", HTML_CLRLINE}, /* TAG_BLOCKQUOTE */ + {"p", HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_P */ + {"pre", HTML_CLRLINE }, /* TAG_PRE */ + {"b", 0 }, /* TAG_B */ + {"i", 0 }, /* TAG_I */ + {"code", 0 }, /* TAG_CODE */ + {"small", 0 }, /* TAG_SMALL */ }; -static const char *const htmlfonts[HTMLFONT_MAX] = { - "roman", - "bold", - "italic" +static const char *const htmlattrs[ATTR_MAX] = { + "http-equiv", /* ATTR_HTTPEQUIV */ + "content", /* ATTR_CONTENT */ + "name", /* ATTR_NAME */ + "rel", /* ATTR_REL */ + "href", /* ATTR_HREF */ + "type", /* ATTR_TYPE */ + "media", /* ATTR_MEDIA */ + "class", /* ATTR_CLASS */ + "style", /* ATTR_STYLE */ + "width", /* ATTR_WIDTH */ + "id", /* ATTR_ID */ + "summary", /* ATTR_SUMMARY */ + "align", /* ATTR_ALIGN */ + "colspan", /* ATTR_COLSPAN */ + "charset", /* ATTR_CHARSET */ }; -static const char *const htmlattrs[ATTR_MAX] = { - "http-equiv", - "content", - "name", - "rel", - "href", - "type", - "media", - "class", - "style", - "width", - "valign", - "target", - "id", - "summary", +static const char *const roffscales[SCALE_MAX] = { + "cm", /* SCALE_CM */ + "in", /* SCALE_IN */ + "pc", /* SCALE_PC */ + "pt", /* SCALE_PT */ + "em", /* SCALE_EM */ + "em", /* SCALE_MM */ + "ex", /* SCALE_EN */ + "ex", /* SCALE_BU */ + "em", /* SCALE_VS */ + "ex", /* SCALE_FS */ }; -static void print_spec(struct html *, const char *, size_t); -static void print_res(struct html *, const char *, size_t); -static void print_ctag(struct html *, enum htmltag); -static void print_doctype(struct html *); -static void print_xmltype(struct html *); -static int print_encode(struct html *, const char *, int); -static void print_metaf(struct html *, enum roffdeco); -static void *ml_alloc(char *, enum htmltype); +static void bufncat(struct html *, const char *, size_t); +static void print_ctag(struct html *, enum htmltag); +static int print_escape(char); +static int print_encode(struct html *, const char *, int); +static void print_metaf(struct html *, enum mandoc_esc); +static void print_attr(struct html *, const char *, const char *); +static void *ml_alloc(char *, enum htmltype); static void * ml_alloc(char *outopts, enum htmltype type) { struct html *h; - const char *toks[4]; + const char *toks[5]; char *v; toks[0] = "style"; toks[1] = "man"; toks[2] = "includes"; - toks[3] = NULL; + toks[3] = "fragment"; + toks[4] = NULL; - h = calloc(1, sizeof(struct html)); - if (NULL == h) { - perror(NULL); - exit(EXIT_FAILURE); - } + h = mandoc_calloc(1, sizeof(struct html)); h->type = type; h->tags.head = NULL; - h->ords.head = NULL; - h->symtab = chars_init(CHARS_HTML); + h->symtab = mchars_alloc(); while (outopts && *outopts) switch (getsubopt(&outopts, UNCONST(toks), &v)) { - case (0): + case 0: h->style = v; break; - case (1): + case 1: h->base_man = v; break; - case (2): + case 2: h->base_includes = v; break; + case 3: + h->oflags |= HTML_FRAGMENT; + break; default: break; } @@ -147,7 +163,6 @@ html_alloc(char *outopts) return(ml_alloc(outopts, HTML_HTML_4_01_STRICT)); } - void * xhtml_alloc(char *outopts) { @@ -155,50 +170,34 @@ xhtml_alloc(char *outopts) return(ml_alloc(outopts, HTML_XHTML_1_0_STRICT)); } - void html_free(void *p) { struct tag *tag; - struct ord *ord; struct html *h; h = (struct html *)p; - while ((ord = h->ords.head) != NULL) { - h->ords.head = ord->next; - free(ord); - } - while ((tag = h->tags.head) != NULL) { - h->tags.head = tag->next; + h->tags.head = tag->next; free(tag); } - + if (h->symtab) - chars_free(h->symtab); + mchars_free(h->symtab); free(h); } - void print_gen_head(struct html *h) { struct htmlpair tag[4]; - tag[0].key = ATTR_HTTPEQUIV; - tag[0].val = "Content-Type"; - tag[1].key = ATTR_CONTENT; - tag[1].val = "text/html; charset=utf-8"; - print_otag(h, TAG_META, 2, tag); + tag[0].key = ATTR_CHARSET; + tag[0].val = "utf-8"; + print_otag(h, TAG_META, 1, tag); - tag[0].key = ATTR_NAME; - tag[0].val = "resource-type"; - tag[1].key = ATTR_CONTENT; - tag[1].val = "document"; - print_otag(h, TAG_META, 2, tag); - if (h->style) { tag[0].key = ATTR_REL; tag[0].val = "stylesheet"; @@ -212,158 +211,253 @@ print_gen_head(struct html *h) } } - static void -print_spec(struct html *h, const char *p, size_t len) +print_metaf(struct html *h, enum mandoc_esc deco) { - const char *rhs; - size_t sz; + enum htmlfont font; - rhs = chars_a2ascii(h->symtab, p, len, &sz); + switch (deco) { + case ESCAPE_FONTPREV: + font = h->metal; + break; + case ESCAPE_FONTITALIC: + font = HTMLFONT_ITALIC; + break; + case ESCAPE_FONTBOLD: + font = HTMLFONT_BOLD; + break; + case ESCAPE_FONTBI: + font = HTMLFONT_BI; + break; + case ESCAPE_FONT: + /* FALLTHROUGH */ + case ESCAPE_FONTROMAN: + font = HTMLFONT_NONE; + break; + default: + abort(); + /* NOTREACHED */ + } - if (NULL == rhs) - return; - fwrite(rhs, 1, sz, stdout); -} + if (h->metaf) { + print_tagq(h, h->metaf); + h->metaf = NULL; + } + h->metal = h->metac; + h->metac = font; -static void -print_res(struct html *h, const char *p, size_t len) -{ - const char *rhs; - size_t sz; - - rhs = chars_a2res(h->symtab, p, len, &sz); - - if (NULL == rhs) - return; - fwrite(rhs, 1, sz, stdout); + switch (font) { + case HTMLFONT_ITALIC: + h->metaf = print_otag(h, TAG_I, 0, NULL); + break; + case HTMLFONT_BOLD: + h->metaf = print_otag(h, TAG_B, 0, NULL); + break; + case HTMLFONT_BI: + h->metaf = print_otag(h, TAG_B, 0, NULL); + print_otag(h, TAG_I, 0, NULL); + break; + default: + break; + } } - -struct tag * -print_ofont(struct html *h, enum htmlfont font) +int +html_strlen(const char *cp) { - struct htmlpair tag; + size_t rsz; + int skip, sz; - h->metal = h->metac; - h->metac = font; + /* + * Account for escaped sequences within string length + * calculations. This follows the logic in term_strlen() as we + * must calculate the width of produced strings. + * Assume that characters are always width of "1". This is + * hacky, but it gets the job done for approximation of widths. + */ - /* FIXME: DECO_ROMAN should just close out preexisting. */ - - if (h->metaf && h->tags.head == h->metaf) - print_tagq(h, h->metaf); - - PAIR_CLASS_INIT(&tag, htmlfonts[font]); - h->metaf = print_otag(h, TAG_SPAN, 1, &tag); - return(h->metaf); + sz = 0; + skip = 0; + while (1) { + rsz = strcspn(cp, "\\"); + if (rsz) { + cp += rsz; + if (skip) { + skip = 0; + rsz--; + } + sz += rsz; + } + if ('\0' == *cp) + break; + cp++; + switch (mandoc_escape(&cp, NULL, NULL)) { + case ESCAPE_ERROR: + return(sz); + case ESCAPE_UNICODE: + /* FALLTHROUGH */ + case ESCAPE_NUMBERED: + /* FALLTHROUGH */ + case ESCAPE_SPECIAL: + if (skip) + skip = 0; + else + sz++; + break; + case ESCAPE_SKIPCHAR: + skip = 1; + break; + default: + break; + } + } + return(sz); } - -static void -print_metaf(struct html *h, enum roffdeco deco) +static int +print_escape(char c) { - enum htmlfont font; - switch (deco) { - case (DECO_PREVIOUS): - font = h->metal; + switch (c) { + case '<': + printf("<"); break; - case (DECO_ITALIC): - font = HTMLFONT_ITALIC; + case '>': + printf(">"); break; - case (DECO_BOLD): - font = HTMLFONT_BOLD; + case '&': + printf("&"); break; - case (DECO_ROMAN): - font = HTMLFONT_NONE; + case '"': + printf("""); break; + case ASCII_NBRSP: + putchar('-'); + break; + case ASCII_HYPH: + putchar('-'); + /* FALLTHROUGH */ + case ASCII_BREAK: + break; default: - abort(); - /* NOTREACHED */ + return(0); } - - (void)print_ofont(h, font); + return(1); } - static int print_encode(struct html *h, const char *p, int norecurse) { size_t sz; - int len, nospace; + int c, len, nospace; const char *seq; - enum roffdeco deco; + enum mandoc_esc esc; + static const char rejs[9] = { '\\', '<', '>', '&', '"', + ASCII_NBRSP, ASCII_HYPH, ASCII_BREAK, '\0' }; nospace = 0; - for (; *p; p++) { - sz = strcspn(p, "\\<>&"); + while ('\0' != *p) { + if (HTML_SKIPCHAR & h->flags && '\\' != *p) { + h->flags &= ~HTML_SKIPCHAR; + p++; + continue; + } + sz = strcspn(p, rejs); + fwrite(p, 1, sz, stdout); - p += /* LINTED */ - sz; + p += (int)sz; - if ('<' == *p) { - printf("<"); - continue; - } else if ('>' == *p) { - printf(">"); - continue; - } else if ('&' == *p) { - printf("&"); - continue; - } else if ('\0' == *p) + if ('\0' == *p) break; - seq = ++p; - len = a2roffdeco(&deco, &seq, &sz); + if (print_escape(*p++)) + continue; - switch (deco) { - case (DECO_RESERVED): - print_res(h, seq, sz); + esc = mandoc_escape(&p, &seq, &len); + if (ESCAPE_ERROR == esc) break; - case (DECO_SPECIAL): - print_spec(h, seq, sz); - break; - case (DECO_PREVIOUS): + + switch (esc) { + case ESCAPE_FONT: /* FALLTHROUGH */ - case (DECO_BOLD): + case ESCAPE_FONTPREV: /* FALLTHROUGH */ - case (DECO_ITALIC): + case ESCAPE_FONTBOLD: /* FALLTHROUGH */ - case (DECO_ROMAN): - if (norecurse) - break; - print_metaf(h, deco); - break; + case ESCAPE_FONTITALIC: + /* FALLTHROUGH */ + case ESCAPE_FONTBI: + /* FALLTHROUGH */ + case ESCAPE_FONTROMAN: + if (0 == norecurse) + print_metaf(h, esc); + continue; + case ESCAPE_SKIPCHAR: + h->flags |= HTML_SKIPCHAR; + continue; default: break; } - p += len - 1; + if (h->flags & HTML_SKIPCHAR) { + h->flags &= ~HTML_SKIPCHAR; + continue; + } - if (DECO_NOSPACE == deco && '\0' == *(p + 1)) - nospace = 1; + switch (esc) { + case ESCAPE_UNICODE: + /* Skip past "u" header. */ + c = mchars_num2uc(seq + 1, len - 1); + if ('\0' != c) + printf("&#x%x;", c); + break; + case ESCAPE_NUMBERED: + c = mchars_num2char(seq, len); + if ( ! ('\0' == c || print_escape(c))) + putchar(c); + break; + case ESCAPE_SPECIAL: + c = mchars_spec2cp(h->symtab, seq, len); + if (c > 0) + printf("&#%d;", c); + else if (-1 == c && 1 == len && + !print_escape(*seq)) + putchar((int)*seq); + break; + case ESCAPE_NOSPACE: + if ('\0' == *p) + nospace = 1; + break; + default: + break; + } } return(nospace); } +static void +print_attr(struct html *h, const char *key, const char *val) +{ + printf(" %s=\"", key); + (void)print_encode(h, val, 1); + putchar('\"'); +} struct tag * -print_otag(struct html *h, enum htmltag tag, +print_otag(struct html *h, enum htmltag tag, int sz, const struct htmlpair *p) { int i; struct tag *t; + /* Push this tags onto the stack of open scopes. */ + if ( ! (HTML_NOSTACK & htmltags[tag].flags)) { - t = malloc(sizeof(struct tag)); - if (NULL == t) { - perror(NULL); - exit(EXIT_FAILURE); - } + t = mandoc_malloc(sizeof(struct tag)); t->tag = tag; t->next = h->tags.head; h->tags.head = t; @@ -371,20 +465,32 @@ print_otag(struct html *h, enum htmltag tag, t = NULL; if ( ! (HTML_NOSPACE & h->flags)) - if ( ! (HTML_CLRLINE & htmltags[tag].flags)) - putchar(' '); + if ( ! (HTML_CLRLINE & htmltags[tag].flags)) { + /* Manage keeps! */ + if ( ! (HTML_KEEP & h->flags)) { + if (HTML_PREKEEP & h->flags) + h->flags |= HTML_KEEP; + putchar(' '); + } else + printf(" "); + } + if ( ! (h->flags & HTML_NONOSPACE)) + h->flags &= ~HTML_NOSPACE; + else + h->flags |= HTML_NOSPACE; + + /* Print out the tag name and attributes. */ + printf("<%s", htmltags[tag].name); - for (i = 0; i < sz; i++) { - printf(" %s=\"", htmlattrs[p[i].key]); - assert(p->val); - (void)print_encode(h, p[i].val, 1); - putchar('\"'); - } + for (i = 0; i < sz; i++) + print_attr(h, htmlattrs[p[i].key], p[i].val); + /* Accommodate for XML "well-formed" singleton escaping. */ + if (HTML_AUTOCLOSE & htmltags[tag].flags) switch (h->type) { - case (HTML_XHTML_1_0_STRICT): + case HTML_XHTML_1_0_STRICT: putchar('/'); break; default: @@ -394,133 +500,90 @@ print_otag(struct html *h, enum htmltag tag, putchar('>'); h->flags |= HTML_NOSPACE; + + if ((HTML_AUTOCLOSE | HTML_CLRLINE) & htmltags[tag].flags) + putchar('\n'); + return(t); } - static void print_ctag(struct html *h, enum htmltag tag) { - + printf("", htmltags[tag].name); if (HTML_CLRLINE & htmltags[tag].flags) { h->flags |= HTML_NOSPACE; putchar('\n'); - } + } } - void print_gen_decls(struct html *h) { - print_xmltype(h); - print_doctype(h); + puts(""); } - -static void -print_xmltype(struct html *h) +void +print_text(struct html *h, const char *word) { - const char *decl; - switch (h->type) { - case (HTML_XHTML_1_0_STRICT): - decl = ""; - break; - default: - decl = NULL; - break; + if ( ! (HTML_NOSPACE & h->flags)) { + /* Manage keeps! */ + if ( ! (HTML_KEEP & h->flags)) { + if (HTML_PREKEEP & h->flags) + h->flags |= HTML_KEEP; + putchar(' '); + } else + printf(" "); } - if (NULL == decl) - return; - - printf("%s\n", decl); -} - - -static void -print_doctype(struct html *h) -{ - const char *doctype; - const char *dtd; - - switch (h->type) { - case (HTML_HTML_4_01_STRICT): - doctype = "-//W3C//DTD HTML 4.01//EN"; - dtd = "http://www.w3.org/TR/html4/strict.dtd"; + assert(NULL == h->metaf); + switch (h->metac) { + case HTMLFONT_ITALIC: + h->metaf = print_otag(h, TAG_I, 0, NULL); break; + case HTMLFONT_BOLD: + h->metaf = print_otag(h, TAG_B, 0, NULL); + break; + case HTMLFONT_BI: + h->metaf = print_otag(h, TAG_B, 0, NULL); + print_otag(h, TAG_I, 0, NULL); + break; default: - doctype = "-//W3C//DTD XHTML 1.0 Strict//EN"; - dtd = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"; break; } - printf("\n", doctype, dtd); -} + assert(word); + if ( ! print_encode(h, word, 0)) { + if ( ! (h->flags & HTML_NONOSPACE)) + h->flags &= ~HTML_NOSPACE; + } else + h->flags |= HTML_NOSPACE; + if (h->metaf) { + print_tagq(h, h->metaf); + h->metaf = NULL; + } -void -print_text(struct html *h, const char *p) -{ - - if (*p && 0 == *(p + 1)) - switch (*p) { - case('.'): - /* FALLTHROUGH */ - case(','): - /* FALLTHROUGH */ - case(';'): - /* FALLTHROUGH */ - case(':'): - /* FALLTHROUGH */ - case('?'): - /* FALLTHROUGH */ - case('!'): - /* FALLTHROUGH */ - case(')'): - /* FALLTHROUGH */ - case(']'): - /* FALLTHROUGH */ - case('}'): - if ( ! (HTML_IGNDELIM & h->flags)) - h->flags |= HTML_NOSPACE; - break; - default: - break; - } - - if ( ! (h->flags & HTML_NOSPACE)) - putchar(' '); - - assert(p); - if ( ! print_encode(h, p, 0)) - h->flags &= ~HTML_NOSPACE; - - if (*p && 0 == *(p + 1)) - switch (*p) { - case('('): - /* FALLTHROUGH */ - case('['): - /* FALLTHROUGH */ - case('{'): - h->flags |= HTML_NOSPACE; - break; - default: - break; - } + h->flags &= ~HTML_IGNDELIM; } - void print_tagq(struct html *h, const struct tag *until) { struct tag *tag; while ((tag = h->tags.head) != NULL) { + /* + * Remember to close out and nullify the current + * meta-font and table, if applicable. + */ if (tag == h->metaf) h->metaf = NULL; + if (tag == h->tblt) + h->tblt = NULL; print_ctag(h, tag->tag); h->tags.head = tag->next; free(tag); @@ -529,7 +592,6 @@ print_tagq(struct html *h, const struct tag *until) } } - void print_stagq(struct html *h, const struct tag *suntil) { @@ -538,15 +600,20 @@ print_stagq(struct html *h, const struct tag *suntil) while ((tag = h->tags.head) != NULL) { if (suntil && tag == suntil) return; + /* + * Remember to close out and nullify the current + * meta-font and table, if applicable. + */ if (tag == h->metaf) h->metaf = NULL; + if (tag == h->tblt) + h->tblt = NULL; print_ctag(h, tag->tag); h->tags.head = tag->next; free(tag); } } - void bufinit(struct html *h) { @@ -555,62 +622,63 @@ bufinit(struct html *h) h->buflen = 0; } - void bufcat_style(struct html *h, const char *key, const char *val) { bufcat(h, key); - bufncat(h, ":", 1); + bufcat(h, ":"); bufcat(h, val); - bufncat(h, ";", 1); + bufcat(h, ";"); } - void bufcat(struct html *h, const char *p) { - bufncat(h, p, strlen(p)); + /* + * XXX This is broken and not easy to fix. + * When using the -Oincludes option, buffmt_includes() + * may pass in strings overrunning BUFSIZ, causing a crash. + */ + + h->buflen = strlcat(h->buf, p, BUFSIZ); + assert(h->buflen < BUFSIZ); } - void -buffmt(struct html *h, const char *fmt, ...) +bufcat_fmt(struct html *h, const char *fmt, ...) { va_list ap; va_start(ap, fmt); - (void)vsnprintf(h->buf + (int)h->buflen, - BUFSIZ - h->buflen - 1, fmt, ap); + (void)vsnprintf(h->buf + (int)h->buflen, + BUFSIZ - h->buflen - 1, fmt, ap); va_end(ap); h->buflen = strlen(h->buf); } - -void +static void bufncat(struct html *h, const char *p, size_t sz) { - if (h->buflen + sz > BUFSIZ - 1) - sz = BUFSIZ - 1 - h->buflen; - - (void)strncat(h->buf, p, sz); + assert(h->buflen + sz + 1 < BUFSIZ); + strncat(h->buf, p, sz); h->buflen += sz; } - void buffmt_includes(struct html *h, const char *name) { const char *p, *pp; pp = h->base_includes; - + + bufinit(h); while (NULL != (p = strchr(pp, '%'))) { bufncat(h, pp, (size_t)(p - pp)); switch (*(p + 1)) { - case('I'): + case'I': bufcat(h, name); break; default: @@ -623,24 +691,22 @@ buffmt_includes(struct html *h, const char *name) bufcat(h, pp); } - void -buffmt_man(struct html *h, - const char *name, const char *sec) +buffmt_man(struct html *h, const char *name, const char *sec) { const char *p, *pp; pp = h->base_man; - - /* LINTED */ + + bufinit(h); while (NULL != (p = strchr(pp, '%'))) { bufncat(h, pp, (size_t)(p - pp)); switch (*(p + 1)) { - case('S'): + case 'S': bufcat(h, sec ? sec : "1"); break; - case('N'): - buffmt(h, name); + case 'N': + bufcat_fmt(h, "%s", name); break; default: bufncat(h, p, 2); @@ -652,81 +718,26 @@ buffmt_man(struct html *h, bufcat(h, pp); } - void bufcat_su(struct html *h, const char *p, const struct roffsu *su) { double v; - const char *u; v = su->scale; + if (SCALE_MM == su->unit && 0.0 == (v /= 100.0)) + v = 1.0; + else if (SCALE_BU == su->unit) + v /= 24.0; - switch (su->unit) { - case (SCALE_CM): - u = "cm"; - break; - case (SCALE_IN): - u = "in"; - break; - case (SCALE_PC): - u = "pc"; - break; - case (SCALE_PT): - u = "pt"; - break; - case (SCALE_EM): - u = "em"; - break; - case (SCALE_MM): - if (0 == (v /= 100)) - v = 1; - u = "em"; - break; - case (SCALE_EN): - u = "ex"; - break; - case (SCALE_BU): - u = "ex"; - break; - case (SCALE_VS): - u = "em"; - break; - default: - u = "ex"; - break; - } - - if (su->pt) - buffmt(h, "%s: %f%s;", p, v, u); - else - /* LINTED */ - buffmt(h, "%s: %d%s;", p, (int)v, u); + bufcat_fmt(h, "%s: %.2f%s;", p, v, roffscales[su->unit]); } - void -html_idcat(char *dst, const char *src, int sz) +bufcat_id(struct html *h, const char *src) { - int ssz; - assert(sz); - /* Cf. . */ - for ( ; *dst != '\0' && sz; dst++, sz--) - /* Jump to end. */ ; - - assert(sz > 2); - - /* We can't start with a number (bah). */ - - *dst++ = 'x'; - *dst = '\0'; - sz--; - - for ( ; *src != '\0' && sz > 1; src++) { - ssz = snprintf(dst, (size_t)sz, "%.2x", *src); - sz -= ssz; - dst += ssz; - } + while ('\0' != *src) + bufcat_fmt(h, "%.2x", *src++); }