]> git.cameronkatri.com Git - mandoc.git/blob - html.c
git.ckatri.com / mandoc.git / blob
? search:


08e2086c05ecd04a424d9c2bc232a975e2ef34ae
[mandoc.git] / html.c
1 /* $Id: html.c,v 1.145 2011/05/18 23:59:08 kristaps Exp $ */
2 /*
3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2011 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 AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #endif
21
22 #include <sys/types.h>
23
24 #include <assert.h>
25 #include <ctype.h>
26 #include <stdarg.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.h"
34 #include "libmandoc.h"
35 #include "out.h"
36 #include "html.h"
37 #include "main.h"
38
39 struct htmldata {
40 const char *name;
41 int flags;
42 #define HTML_CLRLINE (1 << 0)
43 #define HTML_NOSTACK (1 << 1)
44 #define HTML_AUTOCLOSE (1 << 2) /* Tag has auto-closure. */
45 };
46
47 static const struct htmldata htmltags[TAG_MAX] = {
48 {"html", HTML_CLRLINE}, /* TAG_HTML */
49 {"head", HTML_CLRLINE}, /* TAG_HEAD */
50 {"body", HTML_CLRLINE}, /* TAG_BODY */
51 {"meta", HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_META */
52 {"title", HTML_CLRLINE}, /* TAG_TITLE */
53 {"div", HTML_CLRLINE}, /* TAG_DIV */
54 {"h1", 0}, /* TAG_H1 */
55 {"h2", 0}, /* TAG_H2 */
56 {"span", 0}, /* TAG_SPAN */
57 {"link", HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_LINK */
58 {"br", HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_BR */
59 {"a", 0}, /* TAG_A */
60 {"table", HTML_CLRLINE}, /* TAG_TABLE */
61 {"tbody", HTML_CLRLINE}, /* TAG_TBODY */
62 {"col", HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_COL */
63 {"tr", HTML_CLRLINE}, /* TAG_TR */
64 {"td", HTML_CLRLINE}, /* TAG_TD */
65 {"li", HTML_CLRLINE}, /* TAG_LI */
66 {"ul", HTML_CLRLINE}, /* TAG_UL */
67 {"ol", HTML_CLRLINE}, /* TAG_OL */
68 {"dl", HTML_CLRLINE}, /* TAG_DL */
69 {"dt", HTML_CLRLINE}, /* TAG_DT */
70 {"dd", HTML_CLRLINE}, /* TAG_DD */
71 {"blockquote", HTML_CLRLINE}, /* TAG_BLOCKQUOTE */
72 {"p", HTML_CLRLINE | HTML_NOSTACK | HTML_AUTOCLOSE}, /* TAG_P */
73 {"pre", HTML_CLRLINE }, /* TAG_PRE */
74 {"b", 0 }, /* TAG_B */
75 {"i", 0 }, /* TAG_I */
76 {"code", 0 }, /* TAG_CODE */
77 {"small", 0 }, /* TAG_SMALL */
78 };
79
80 static const char *const htmlattrs[ATTR_MAX] = {
81 "http-equiv", /* ATTR_HTTPEQUIV */
82 "content", /* ATTR_CONTENT */
83 "name", /* ATTR_NAME */
84 "rel", /* ATTR_REL */
85 "href", /* ATTR_HREF */
86 "type", /* ATTR_TYPE */
87 "media", /* ATTR_MEDIA */
88 "class", /* ATTR_CLASS */
89 "style", /* ATTR_STYLE */
90 "width", /* ATTR_WIDTH */
91 "id", /* ATTR_ID */
92 "summary", /* ATTR_SUMMARY */
93 "align", /* ATTR_ALIGN */
94 "colspan", /* ATTR_COLSPAN */
95 };
96
97 static const char *const roffscales[SCALE_MAX] = {
98 "cm", /* SCALE_CM */
99 "in", /* SCALE_IN */
100 "pc", /* SCALE_PC */
101 "pt", /* SCALE_PT */
102 "em", /* SCALE_EM */
103 "em", /* SCALE_MM */
104 "ex", /* SCALE_EN */
105 "ex", /* SCALE_BU */
106 "em", /* SCALE_VS */
107 "ex", /* SCALE_FS */
108 };
109
110 static void bufncat(struct html *, const char *, size_t);
111 static void print_spec(struct html *, const char *, size_t);
112 static void print_res(struct html *, const char *, size_t);
113 static void print_ctag(struct html *, enum htmltag);
114 static int print_encode(struct html *, const char *, int);
115 static void print_metaf(struct html *, enum mandoc_esc);
116 static void print_attr(struct html *, const char *, const char *);
117 static void *ml_alloc(char *, enum htmltype);
118
119 static void *
120 ml_alloc(char *outopts, enum htmltype type)
121 {
122 struct html *h;
123 const char *toks[4];
124 char *v;
125
126 toks[0] = "style";
127 toks[1] = "man";
128 toks[2] = "includes";
129 toks[3] = NULL;
130
131 h = mandoc_calloc(1, sizeof(struct html));
132
133 h->type = type;
134 h->tags.head = NULL;
135 h->symtab = mchars_alloc();
136
137 while (outopts && *outopts)
138 switch (getsubopt(&outopts, UNCONST(toks), &v)) {
139 case (0):
140 h->style = v;
141 break;
142 case (1):
143 h->base_man = v;
144 break;
145 case (2):
146 h->base_includes = v;
147 break;
148 default:
149 break;
150 }
151
152 return(h);
153 }
154
155 void *
156 html_alloc(char *outopts)
157 {
158
159 return(ml_alloc(outopts, HTML_HTML_4_01_STRICT));
160 }
161
162
163 void *
164 xhtml_alloc(char *outopts)
165 {
166
167 return(ml_alloc(outopts, HTML_XHTML_1_0_STRICT));
168 }
169
170
171 void
172 html_free(void *p)
173 {
174 struct tag *tag;
175 struct html *h;
176
177 h = (struct html *)p;
178
179 while ((tag = h->tags.head) != NULL) {
180 h->tags.head = tag->next;
181 free(tag);
182 }
183
184 if (h->symtab)
185 mchars_free(h->symtab);
186
187 free(h);
188 }
189
190
191 void
192 print_gen_head(struct html *h)
193 {
194 struct htmlpair tag[4];
195
196 tag[0].key = ATTR_HTTPEQUIV;
197 tag[0].val = "Content-Type";
198 tag[1].key = ATTR_CONTENT;
199 tag[1].val = "text/html; charset=utf-8";
200 print_otag(h, TAG_META, 2, tag);
201
202 tag[0].key = ATTR_NAME;
203 tag[0].val = "resource-type";
204 tag[1].key = ATTR_CONTENT;
205 tag[1].val = "document";
206 print_otag(h, TAG_META, 2, tag);
207
208 if (h->style) {
209 tag[0].key = ATTR_REL;
210 tag[0].val = "stylesheet";
211 tag[1].key = ATTR_HREF;
212 tag[1].val = h->style;
213 tag[2].key = ATTR_TYPE;
214 tag[2].val = "text/css";
215 tag[3].key = ATTR_MEDIA;
216 tag[3].val = "all";
217 print_otag(h, TAG_LINK, 4, tag);
218 }
219 }
220
221 static void
222 print_spec(struct html *h, const char *p, size_t len)
223 {
224 int cp;
225 const char *rhs;
226 size_t sz;
227
228 if ((cp = mchars_spec2cp(h->symtab, p, len)) > 0) {
229 printf("&#%d;", cp);
230 return;
231 } else if (-1 == cp && 1 == len) {
232 fwrite(p, 1, len, stdout);
233 return;
234 } else if (-1 == cp)
235 return;
236
237 if (NULL != (rhs = mchars_spec2str(h->symtab, p, len, &sz)))
238 fwrite(rhs, 1, sz, stdout);
239 }
240
241
242 static void
243 print_res(struct html *h, const char *p, size_t len)
244 {
245 int cp;
246 const char *rhs;
247 size_t sz;
248
249 if ((cp = mchars_res2cp(h->symtab, p, len)) > 0) {
250 printf("&#%d;", cp);
251 return;
252 } else if (-1 == cp)
253 return;
254
255 if (NULL != (rhs = mchars_res2str(h->symtab, p, len, &sz)))
256 fwrite(rhs, 1, sz, stdout);
257 }
258
259
260 static void
261 print_metaf(struct html *h, enum mandoc_esc deco)
262 {
263 enum htmlfont font;
264
265 switch (deco) {
266 case (ESCAPE_FONTPREV):
267 font = h->metal;
268 break;
269 case (ESCAPE_FONTITALIC):
270 font = HTMLFONT_ITALIC;
271 break;
272 case (ESCAPE_FONTBOLD):
273 font = HTMLFONT_BOLD;
274 break;
275 case (ESCAPE_FONT):
276 /* FALLTHROUGH */
277 case (ESCAPE_FONTROMAN):
278 font = HTMLFONT_NONE;
279 break;
280 default:
281 abort();
282 /* NOTREACHED */
283 }
284
285 if (h->metaf) {
286 print_tagq(h, h->metaf);
287 h->metaf = NULL;
288 }
289
290 h->metal = h->metac;
291 h->metac = font;
292
293 if (HTMLFONT_NONE != font)
294 h->metaf = HTMLFONT_BOLD == font ?
295 print_otag(h, TAG_B, 0, NULL) :
296 print_otag(h, TAG_I, 0, NULL);
297 }
298
299 int
300 html_strlen(const char *cp)
301 {
302 int ssz, sz;
303 const char *seq, *p;
304
305 /*
306 * Account for escaped sequences within string length
307 * calculations. This follows the logic in term_strlen() as we
308 * must calculate the width of produced strings.
309 * Assume that characters are always width of "1". This is
310 * hacky, but it gets the job done for approximation of widths.
311 */
312
313 sz = 0;
314 while (NULL != (p = strchr(cp, '\\'))) {
315 sz += (int)(p - cp);
316 ++cp;
317 switch (mandoc_escape(&cp, &seq, &ssz)) {
318 case (ESCAPE_ERROR):
319 return(sz);
320 case (ESCAPE_UNICODE):
321 /* FALLTHROUGH */
322 case (ESCAPE_NUMBERED):
323 /* FALLTHROUGH */
324 case (ESCAPE_PREDEF):
325 /* FALLTHROUGH */
326 case (ESCAPE_SPECIAL):
327 sz++;
328 break;
329 default:
330 break;
331 }
332 }
333
334 assert(sz >= 0);
335 return(sz + strlen(cp));
336 }
337
338 static int
339 print_encode(struct html *h, const char *p, int norecurse)
340 {
341 size_t sz;
342 int c, len, nospace;
343 const char *seq;
344 enum mandoc_esc esc;
345 static const char rejs[6] = { '\\', '<', '>', '&', ASCII_HYPH, '\0' };
346
347 nospace = 0;
348
349 while ('\0' != *p) {
350 sz = strcspn(p, rejs);
351
352 fwrite(p, 1, sz, stdout);
353 p += (int)sz;
354
355 if ('\0' == *p)
356 break;
357
358 switch (*p++) {
359 case ('<'):
360 printf("&lt;");
361 continue;
362 case ('>'):
363 printf("&gt;");
364 continue;
365 case ('&'):
366 printf("&amp;");
367 continue;
368 case (ASCII_HYPH):
369 putchar('-');
370 continue;
371 default:
372 break;
373 }
374
375 esc = mandoc_escape(&p, &seq, &len);
376 if (ESCAPE_ERROR == esc)
377 break;
378
379 switch (esc) {
380 case (ESCAPE_UNICODE):
381 /* Skip passed "u" header. */
382 c = mchars_num2uc(seq + 1, len - 1);
383 if ('\0' != c)
384 printf("&#x%x;", c);
385 break;
386 case (ESCAPE_NUMBERED):
387 c = mchars_num2char(seq, len);
388 if ('\0' != c)
389 putchar(c);
390 break;
391 case (ESCAPE_PREDEF):
392 print_res(h, seq, len);
393 break;
394 case (ESCAPE_SPECIAL):
395 print_spec(h, seq, len);
396 break;
397 case (ESCAPE_FONT):
398 /* FALLTHROUGH */
399 case (ESCAPE_FONTPREV):
400 /* FALLTHROUGH */
401 case (ESCAPE_FONTBOLD):
402 /* FALLTHROUGH */
403 case (ESCAPE_FONTITALIC):
404 /* FALLTHROUGH */
405 case (ESCAPE_FONTROMAN):
406 if (norecurse)
407 break;
408 print_metaf(h, esc);
409 break;
410 case (ESCAPE_NOSPACE):
411 if ('\0' == *p)
412 nospace = 1;
413 break;
414 default:
415 break;
416 }
417 }
418
419 return(nospace);
420 }
421
422
423 static void
424 print_attr(struct html *h, const char *key, const char *val)
425 {
426 printf(" %s=\"", key);
427 (void)print_encode(h, val, 1);
428 putchar('\"');
429 }
430
431
432 struct tag *
433 print_otag(struct html *h, enum htmltag tag,
434 int sz, const struct htmlpair *p)
435 {
436 int i;
437 struct tag *t;
438
439 /* Push this tags onto the stack of open scopes. */
440
441 if ( ! (HTML_NOSTACK & htmltags[tag].flags)) {
442 t = mandoc_malloc(sizeof(struct tag));
443 t->tag = tag;
444 t->next = h->tags.head;
445 h->tags.head = t;
446 } else
447 t = NULL;
448
449 if ( ! (HTML_NOSPACE & h->flags))
450 if ( ! (HTML_CLRLINE & htmltags[tag].flags)) {
451 /* Manage keeps! */
452 if ( ! (HTML_KEEP & h->flags)) {
453 if (HTML_PREKEEP & h->flags)
454 h->flags |= HTML_KEEP;
455 putchar(' ');
456 } else
457 printf("&#160;");
458 }
459
460 if ( ! (h->flags & HTML_NONOSPACE))
461 h->flags &= ~HTML_NOSPACE;
462 else
463 h->flags |= HTML_NOSPACE;
464
465 /* Print out the tag name and attributes. */
466
467 printf("<%s", htmltags[tag].name);
468 for (i = 0; i < sz; i++)
469 print_attr(h, htmlattrs[p[i].key], p[i].val);
470
471 /* Add non-overridable attributes. */
472
473 if (TAG_HTML == tag && HTML_XHTML_1_0_STRICT == h->type) {
474 print_attr(h, "xmlns", "http://www.w3.org/1999/xhtml");
475 print_attr(h, "xml:lang", "en");
476 print_attr(h, "lang", "en");
477 }
478
479 /* Accommodate for XML "well-formed" singleton escaping. */
480
481 if (HTML_AUTOCLOSE & htmltags[tag].flags)
482 switch (h->type) {
483 case (HTML_XHTML_1_0_STRICT):
484 putchar('/');
485 break;
486 default:
487 break;
488 }
489
490 putchar('>');
491
492 h->flags |= HTML_NOSPACE;
493
494 if ((HTML_AUTOCLOSE | HTML_CLRLINE) & htmltags[tag].flags)
495 putchar('\n');
496
497 return(t);
498 }
499
500
501 static void
502 print_ctag(struct html *h, enum htmltag tag)
503 {
504
505 printf("</%s>", htmltags[tag].name);
506 if (HTML_CLRLINE & htmltags[tag].flags) {
507 h->flags |= HTML_NOSPACE;
508 putchar('\n');
509 }
510 }
511
512 void
513 print_gen_decls(struct html *h)
514 {
515 const char *doctype;
516 const char *dtd;
517 const char *name;
518
519 switch (h->type) {
520 case (HTML_HTML_4_01_STRICT):
521 name = "HTML";
522 doctype = "-//W3C//DTD HTML 4.01//EN";
523 dtd = "http://www.w3.org/TR/html4/strict.dtd";
524 break;
525 default:
526 puts("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
527 name = "html";
528 doctype = "-//W3C//DTD XHTML 1.0 Strict//EN";
529 dtd = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd";
530 break;
531 }
532
533 printf("<!DOCTYPE %s PUBLIC \"%s\" \"%s\">\n",
534 name, doctype, dtd);
535 }
536
537 void
538 print_text(struct html *h, const char *word)
539 {
540
541 if ( ! (HTML_NOSPACE & h->flags)) {
542 /* Manage keeps! */
543 if ( ! (HTML_KEEP & h->flags)) {
544 if (HTML_PREKEEP & h->flags)
545 h->flags |= HTML_KEEP;
546 putchar(' ');
547 } else
548 printf("&#160;");
549 }
550
551 assert(NULL == h->metaf);
552 if (HTMLFONT_NONE != h->metac)
553 h->metaf = HTMLFONT_BOLD == h->metac ?
554 print_otag(h, TAG_B, 0, NULL) :
555 print_otag(h, TAG_I, 0, NULL);
556
557 assert(word);
558 if ( ! print_encode(h, word, 0))
559 if ( ! (h->flags & HTML_NONOSPACE))
560 h->flags &= ~HTML_NOSPACE;
561
562 if (h->metaf) {
563 print_tagq(h, h->metaf);
564 h->metaf = NULL;
565 }
566
567 h->flags &= ~HTML_IGNDELIM;
568 }
569
570
571 void
572 print_tagq(struct html *h, const struct tag *until)
573 {
574 struct tag *tag;
575
576 while ((tag = h->tags.head) != NULL) {
577 /*
578 * Remember to close out and nullify the current
579 * meta-font and table, if applicable.
580 */
581 if (tag == h->metaf)
582 h->metaf = NULL;
583 if (tag == h->tblt)
584 h->tblt = NULL;
585 print_ctag(h, tag->tag);
586 h->tags.head = tag->next;
587 free(tag);
588 if (until && tag == until)
589 return;
590 }
591 }
592
593
594 void
595 print_stagq(struct html *h, const struct tag *suntil)
596 {
597 struct tag *tag;
598
599 while ((tag = h->tags.head) != NULL) {
600 if (suntil && tag == suntil)
601 return;
602 /*
603 * Remember to close out and nullify the current
604 * meta-font and table, if applicable.
605 */
606 if (tag == h->metaf)
607 h->metaf = NULL;
608 if (tag == h->tblt)
609 h->tblt = NULL;
610 print_ctag(h, tag->tag);
611 h->tags.head = tag->next;
612 free(tag);
613 }
614 }
615
616 void
617 bufinit(struct html *h)
618 {
619
620 h->buf[0] = '\0';
621 h->buflen = 0;
622 }
623
624 void
625 bufcat_style(struct html *h, const char *key, const char *val)
626 {
627
628 bufcat(h, key);
629 bufcat(h, ":");
630 bufcat(h, val);
631 bufcat(h, ";");
632 }
633
634 void
635 bufcat(struct html *h, const char *p)
636 {
637
638 h->buflen = strlcat(h->buf, p, BUFSIZ);
639 assert(h->buflen < BUFSIZ);
640 h->buflen--;
641 }
642
643 void
644 bufcat_fmt(struct html *h, const char *fmt, ...)
645 {
646 va_list ap;
647
648 va_start(ap, fmt);
649 (void)vsnprintf(h->buf + (int)h->buflen,
650 BUFSIZ - h->buflen - 1, fmt, ap);
651 va_end(ap);
652 h->buflen = strlen(h->buf);
653 }
654
655 static void
656 bufncat(struct html *h, const char *p, size_t sz)
657 {
658
659 assert(h->buflen + sz + 1 < BUFSIZ);
660 strncat(h->buf, p, sz);
661 h->buflen += sz;
662 }
663
664 void
665 buffmt_includes(struct html *h, const char *name)
666 {
667 const char *p, *pp;
668
669 pp = h->base_includes;
670
671 bufinit(h);
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 void
689 buffmt_man(struct html *h,
690 const char *name, const char *sec)
691 {
692 const char *p, *pp;
693
694 pp = h->base_man;
695
696 bufinit(h);
697 while (NULL != (p = strchr(pp, '%'))) {
698 bufncat(h, pp, (size_t)(p - pp));
699 switch (*(p + 1)) {
700 case('S'):
701 bufcat(h, sec ? sec : "1");
702 break;
703 case('N'):
704 bufcat_fmt(h, name);
705 break;
706 default:
707 bufncat(h, p, 2);
708 break;
709 }
710 pp = p + 2;
711 }
712 if (pp)
713 bufcat(h, pp);
714 }
715
716 void
717 bufcat_su(struct html *h, const char *p, const struct roffsu *su)
718 {
719 double v;
720
721 v = su->scale;
722 if (SCALE_MM == su->unit && 0.0 == (v /= 100.0))
723 v = 1.0;
724
725 bufcat_fmt(h, "%s: %.2f%s;", p, v, roffscales[su->unit]);
726 }
727
728 void
729 bufcat_id(struct html *h, const char *src)
730 {
731
732 /* Cf. <http://www.w3.org/TR/html4/types.html#h-6.2>. */
733
734 while ('\0' != *src)
735 bufcat_fmt(h, "%.2x", *src++);
736 }
A git conversion mirror of mandoc.bsd.lv