da6880a1c4f7b555ce3d55e5a7bdc43b12a5f7fd
[dragonfly.git] / contrib / mdocml / man_html.c
1 /*      $Id: man_html.c,v 1.62 2011/01/07 13:20:58 kristaps 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 <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #include "mandoc.h"
30 #include "out.h"
31 #include "html.h"
32 #include "man.h"
33 #include "main.h"
34
35 /* TODO: preserve ident widths. */
36 /* FIXME: have PD set the default vspace width. */
37
38 #define INDENT            5
39 #define HALFINDENT        3
40
41 #define MAN_ARGS          const struct man_meta *m, \
42                           const struct man_node *n, \
43                           struct mhtml *mh, \
44                           struct html *h
45
46 struct  mhtml {
47         int               fl;
48 #define MANH_LITERAL     (1 << 0) /* literal context */
49 };
50
51 struct  htmlman {
52         int             (*pre)(MAN_ARGS);
53         int             (*post)(MAN_ARGS);
54 };
55
56 static  void              print_man(MAN_ARGS);
57 static  void              print_man_head(MAN_ARGS);
58 static  void              print_man_nodelist(MAN_ARGS);
59 static  void              print_man_node(MAN_ARGS);
60
61 static  int               a2width(const struct man_node *,
62                                 struct roffsu *);
63
64 static  int               man_alt_pre(MAN_ARGS);
65 static  int               man_br_pre(MAN_ARGS);
66 static  int               man_ign_pre(MAN_ARGS);
67 static  int               man_in_pre(MAN_ARGS);
68 static  int               man_literal_pre(MAN_ARGS);
69 static  void              man_root_post(MAN_ARGS);
70 static  int               man_root_pre(MAN_ARGS);
71 static  int               man_B_pre(MAN_ARGS);
72 static  int               man_HP_pre(MAN_ARGS);
73 static  int               man_I_pre(MAN_ARGS);
74 static  int               man_IP_pre(MAN_ARGS);
75 static  int               man_PP_pre(MAN_ARGS);
76 static  int               man_RS_pre(MAN_ARGS);
77 static  int               man_SH_pre(MAN_ARGS);
78 static  int               man_SM_pre(MAN_ARGS);
79 static  int               man_SS_pre(MAN_ARGS);
80
81 static  const struct htmlman mans[MAN_MAX] = {
82         { man_br_pre, NULL }, /* br */
83         { NULL, NULL }, /* TH */
84         { man_SH_pre, NULL }, /* SH */
85         { man_SS_pre, NULL }, /* SS */
86         { man_IP_pre, NULL }, /* TP */
87         { man_PP_pre, NULL }, /* LP */
88         { man_PP_pre, NULL }, /* PP */
89         { man_PP_pre, NULL }, /* P */
90         { man_IP_pre, NULL }, /* IP */
91         { man_HP_pre, NULL }, /* HP */ 
92         { man_SM_pre, NULL }, /* SM */
93         { man_SM_pre, NULL }, /* SB */
94         { man_alt_pre, NULL }, /* BI */
95         { man_alt_pre, NULL }, /* IB */
96         { man_alt_pre, NULL }, /* BR */
97         { man_alt_pre, NULL }, /* RB */
98         { NULL, NULL }, /* R */
99         { man_B_pre, NULL }, /* B */
100         { man_I_pre, NULL }, /* I */
101         { man_alt_pre, NULL }, /* IR */
102         { man_alt_pre, NULL }, /* RI */
103         { NULL, NULL }, /* na */
104         { man_br_pre, NULL }, /* sp */
105         { man_literal_pre, NULL }, /* nf */
106         { man_literal_pre, NULL }, /* fi */
107         { NULL, NULL }, /* RE */
108         { man_RS_pre, NULL }, /* RS */
109         { man_ign_pre, NULL }, /* DT */
110         { man_ign_pre, NULL }, /* UC */
111         { man_ign_pre, NULL }, /* PD */
112         { man_ign_pre, NULL }, /* AT */
113         { man_in_pre, NULL }, /* in */
114         { man_ign_pre, NULL }, /* ft */
115 };
116
117
118 void
119 html_man(void *arg, const struct man *m)
120 {
121         struct html     *h;
122         struct tag      *t;
123         struct mhtml     mh;
124
125         h = (struct html *)arg;
126
127         print_gen_decls(h);
128
129         memset(&mh, 0, sizeof(struct mhtml));
130
131         t = print_otag(h, TAG_HTML, 0, NULL);
132         print_man(man_meta(m), man_node(m), &mh, h);
133         print_tagq(h, t);
134
135         printf("\n");
136 }
137
138
139 static void
140 print_man(MAN_ARGS) 
141 {
142         struct tag      *t;
143
144         t = print_otag(h, TAG_HEAD, 0, NULL);
145         print_man_head(m, n, mh, h);
146         print_tagq(h, t);
147
148         t = print_otag(h, TAG_BODY, 0, NULL);
149         print_man_nodelist(m, n, mh, h);
150         print_tagq(h, t);
151 }
152
153
154 /* ARGSUSED */
155 static void
156 print_man_head(MAN_ARGS)
157 {
158
159         print_gen_head(h);
160         bufinit(h);
161         buffmt(h, "%s(%s)", m->title, m->msec);
162
163         print_otag(h, TAG_TITLE, 0, NULL);
164         print_text(h, h->buf);
165 }
166
167
168 static void
169 print_man_nodelist(MAN_ARGS)
170 {
171
172         print_man_node(m, n, mh, h);
173         if (n->next)
174                 print_man_nodelist(m, n->next, mh, h);
175 }
176
177
178 static void
179 print_man_node(MAN_ARGS)
180 {
181         int              child;
182         struct tag      *t;
183
184         child = 1;
185         t = h->tags.head;
186
187         bufinit(h);
188
189         /*
190          * FIXME: embedded elements within next-line scopes (e.g., `br'
191          * within an empty `B') will cause formatting to be forgotten
192          * due to scope closing out.
193          */
194
195         switch (n->type) {
196         case (MAN_ROOT):
197                 child = man_root_pre(m, n, mh, h);
198                 break;
199         case (MAN_TEXT):
200                 print_text(h, n->string);
201                 if (MANH_LITERAL & mh->fl)
202                         print_otag(h, TAG_BR, 0, NULL);
203                 return;
204         case (MAN_TBL):
205                 print_tbl(h, n->span);
206                 break;
207         default:
208                 /* 
209                  * Close out scope of font prior to opening a macro
210                  * scope.  Assert that the metafont is on the top of the
211                  * stack (it's never nested).
212                  */
213                 if (HTMLFONT_NONE != h->metac) {
214                         h->metal = h->metac;
215                         h->metac = HTMLFONT_NONE;
216                 }
217                 if (mans[n->tok].pre)
218                         child = (*mans[n->tok].pre)(m, n, mh, h);
219                 break;
220         }
221
222         if (child && n->child)
223                 print_man_nodelist(m, n->child, mh, h);
224
225         /* This will automatically close out any font scope. */
226         print_stagq(h, t);
227
228         bufinit(h);
229
230         switch (n->type) {
231         case (MAN_ROOT):
232                 man_root_post(m, n, mh, h);
233                 break;
234         case (MAN_TBL):
235                 break;
236         default:
237                 if (mans[n->tok].post)
238                         (*mans[n->tok].post)(m, n, mh, h);
239                 break;
240         }
241 }
242
243
244 static int
245 a2width(const struct man_node *n, struct roffsu *su)
246 {
247
248         if (MAN_TEXT != n->type)
249                 return(0);
250         if (a2roffsu(n->string, su, SCALE_BU))
251                 return(1);
252
253         return(0);
254 }
255
256
257 /* ARGSUSED */
258 static int
259 man_root_pre(MAN_ARGS)
260 {
261         struct htmlpair  tag[3];
262         struct tag      *t, *tt;
263         char             b[BUFSIZ], title[BUFSIZ];
264
265         b[0] = 0;
266         if (m->vol)
267                 (void)strlcat(b, m->vol, BUFSIZ);
268
269         snprintf(title, BUFSIZ - 1, "%s(%s)", m->title, m->msec);
270
271         PAIR_SUMMARY_INIT(&tag[0], "Document Header");
272         PAIR_CLASS_INIT(&tag[1], "head");
273         if (NULL == h->style) {
274                 PAIR_INIT(&tag[2], ATTR_WIDTH, "100%");
275                 t = print_otag(h, TAG_TABLE, 3, tag);
276                 PAIR_INIT(&tag[0], ATTR_WIDTH, "30%");
277                 print_otag(h, TAG_COL, 1, tag);
278                 print_otag(h, TAG_COL, 1, tag);
279                 print_otag(h, TAG_COL, 1, tag);
280         } else
281                 t = print_otag(h, TAG_TABLE, 2, tag);
282
283         print_otag(h, TAG_TBODY, 0, NULL);
284
285         tt = print_otag(h, TAG_TR, 0, NULL);
286
287         PAIR_CLASS_INIT(&tag[0], "head-ltitle");
288         print_otag(h, TAG_TD, 1, tag);
289
290         print_text(h, title);
291         print_stagq(h, tt);
292
293         PAIR_CLASS_INIT(&tag[0], "head-vol");
294         if (NULL == h->style) {
295                 PAIR_INIT(&tag[1], ATTR_ALIGN, "center");
296                 print_otag(h, TAG_TD, 2, tag);
297         } else 
298                 print_otag(h, TAG_TD, 1, tag);
299
300         print_text(h, b);
301         print_stagq(h, tt);
302
303         PAIR_CLASS_INIT(&tag[0], "head-rtitle");
304         if (NULL == h->style) {
305                 PAIR_INIT(&tag[1], ATTR_ALIGN, "right");
306                 print_otag(h, TAG_TD, 2, tag);
307         } else 
308                 print_otag(h, TAG_TD, 1, tag);
309
310         print_text(h, title);
311         print_tagq(h, t);
312         return(1);
313 }
314
315
316 /* ARGSUSED */
317 static void
318 man_root_post(MAN_ARGS)
319 {
320         struct htmlpair  tag[3];
321         struct tag      *t, *tt;
322         char             b[DATESIZ];
323
324         if (m->rawdate)
325                 strlcpy(b, m->rawdate, DATESIZ);
326         else
327                 time2a(m->date, b, DATESIZ);
328
329         PAIR_SUMMARY_INIT(&tag[0], "Document Footer");
330         PAIR_CLASS_INIT(&tag[1], "foot");
331         if (NULL == h->style) {
332                 PAIR_INIT(&tag[2], ATTR_WIDTH, "100%");
333                 t = print_otag(h, TAG_TABLE, 3, tag);
334                 PAIR_INIT(&tag[0], ATTR_WIDTH, "50%");
335                 print_otag(h, TAG_COL, 1, tag);
336                 print_otag(h, TAG_COL, 1, tag);
337         } else
338                 t = print_otag(h, TAG_TABLE, 2, tag);
339
340         tt = print_otag(h, TAG_TR, 0, NULL);
341
342         PAIR_CLASS_INIT(&tag[0], "foot-date");
343         print_otag(h, TAG_TD, 1, tag);
344
345         print_text(h, b);
346         print_stagq(h, tt);
347
348         PAIR_CLASS_INIT(&tag[0], "foot-os");
349         if (NULL == h->style) {
350                 PAIR_INIT(&tag[1], ATTR_ALIGN, "right");
351                 print_otag(h, TAG_TD, 2, tag);
352         } else 
353                 print_otag(h, TAG_TD, 1, tag);
354
355         if (m->source)
356                 print_text(h, m->source);
357         print_tagq(h, t);
358 }
359
360
361
362 /* ARGSUSED */
363 static int
364 man_br_pre(MAN_ARGS)
365 {
366         struct roffsu    su;
367         struct htmlpair  tag;
368
369         SCALE_VS_INIT(&su, 1);
370
371         if (MAN_sp == n->tok) {
372                 if (n->child)
373                         a2roffsu(n->child->string, &su, SCALE_VS);
374         } else
375                 su.scale = 0;
376
377         bufcat_su(h, "height", &su);
378         PAIR_STYLE_INIT(&tag, h);
379         print_otag(h, TAG_DIV, 1, &tag);
380
381         /* So the div isn't empty: */
382         print_text(h, "\\~");
383
384         return(0);
385 }
386
387
388 /* ARGSUSED */
389 static int
390 man_SH_pre(MAN_ARGS)
391 {
392         struct htmlpair  tag;
393
394         if (MAN_BLOCK == n->type) {
395                 PAIR_CLASS_INIT(&tag, "section");
396                 print_otag(h, TAG_DIV, 1, &tag);
397                 return(1);
398         } else if (MAN_BODY == n->type)
399                 return(1);
400
401         print_otag(h, TAG_H1, 0, NULL);
402         return(1);
403 }
404
405
406 /* ARGSUSED */
407 static int
408 man_alt_pre(MAN_ARGS)
409 {
410         const struct man_node   *nn;
411         int              i;
412         enum htmltag     fp;
413         struct tag      *t;
414
415         for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
416                 t = NULL;
417                 switch (n->tok) {
418                 case (MAN_BI):
419                         fp = i % 2 ? TAG_I : TAG_B;
420                         break;
421                 case (MAN_IB):
422                         fp = i % 2 ? TAG_B : TAG_I;
423                         break;
424                 case (MAN_RI):
425                         fp = i % 2 ? TAG_I : TAG_MAX;
426                         break;
427                 case (MAN_IR):
428                         fp = i % 2 ? TAG_MAX : TAG_I;
429                         break;
430                 case (MAN_BR):
431                         fp = i % 2 ? TAG_MAX : TAG_B;
432                         break;
433                 case (MAN_RB):
434                         fp = i % 2 ? TAG_B : TAG_MAX;
435                         break;
436                 default:
437                         abort();
438                         /* NOTREACHED */
439                 }
440
441                 if (i)
442                         h->flags |= HTML_NOSPACE;
443
444                 if (TAG_MAX != fp)
445                         t = print_otag(h, fp, 0, NULL);
446
447                 print_man_node(m, nn, mh, h);
448
449                 if (t)
450                         print_tagq(h, t);
451         }
452
453         return(0);
454 }
455
456
457 /* ARGSUSED */
458 static int
459 man_SM_pre(MAN_ARGS)
460 {
461         
462         print_otag(h, TAG_SMALL, 0, NULL);
463         if (MAN_SB == n->tok)
464                 print_otag(h, TAG_B, 0, NULL);
465         return(1);
466 }
467
468
469 /* ARGSUSED */
470 static int
471 man_SS_pre(MAN_ARGS)
472 {
473         struct htmlpair  tag;
474
475         if (MAN_BLOCK == n->type) {
476                 PAIR_CLASS_INIT(&tag, "subsection");
477                 print_otag(h, TAG_DIV, 1, &tag);
478                 return(1);
479         } else if (MAN_BODY == n->type)
480                 return(1);
481
482         print_otag(h, TAG_H2, 0, NULL);
483         return(1);
484 }
485
486
487 /* ARGSUSED */
488 static int
489 man_PP_pre(MAN_ARGS)
490 {
491
492         if (MAN_HEAD == n->type)
493                 return(0);
494         else if (MAN_BODY == n->type && n->prev)
495                 print_otag(h, TAG_P, 0, NULL);
496
497         return(1);
498 }
499
500
501 /* ARGSUSED */
502 static int
503 man_IP_pre(MAN_ARGS)
504 {
505         struct roffsu            su;
506         struct htmlpair          tag;
507         const struct man_node   *nn;
508
509         /*
510          * This scattering of 1-BU margins and pads is to make sure that
511          * when text overruns its box, the subsequent text isn't flush
512          * up against it.  However, the rest of the right-hand box must
513          * also be adjusted in consideration of this 1-BU space.
514          */
515
516         if (MAN_BODY == n->type) { 
517                 print_otag(h, TAG_TD, 0, NULL);
518                 return(1);
519         }
520
521         nn = MAN_BLOCK == n->type ? 
522                 n->head->child : n->parent->head->child;
523
524         SCALE_HS_INIT(&su, INDENT);
525
526         /* Width is the second token. */
527
528         if (MAN_IP == n->tok && NULL != nn)
529                 if (NULL != (nn = nn->next))
530                         a2width(nn, &su);
531
532         /* Width is the first token. */
533
534         if (MAN_TP == n->tok && NULL != nn) {
535                 /* Skip past non-text children. */
536                 while (nn && MAN_TEXT != nn->type)
537                         nn = nn->next;
538                 if (nn)
539                         a2width(nn, &su);
540         }
541
542         if (MAN_BLOCK == n->type) {
543                 print_otag(h, TAG_P, 0, NULL);
544                 print_otag(h, TAG_TABLE, 0, NULL);
545                 bufcat_su(h, "width", &su);
546                 PAIR_STYLE_INIT(&tag, h);
547                 print_otag(h, TAG_COL, 1, &tag);
548                 print_otag(h, TAG_COL, 0, NULL);
549                 print_otag(h, TAG_TBODY, 0, NULL);
550                 print_otag(h, TAG_TR, 0, NULL);
551                 return(1);
552         } 
553
554         print_otag(h, TAG_TD, 0, NULL);
555
556         /* For IP, only print the first header element. */
557
558         if (MAN_IP == n->tok && n->child)
559                 print_man_node(m, n->child, mh, h);
560
561         /* For TP, only print next-line header elements. */
562
563         if (MAN_TP == n->tok)
564                 for (nn = n->child; nn; nn = nn->next)
565                         if (nn->line > n->line)
566                                 print_man_node(m, nn, mh, h);
567
568         return(0);
569 }
570
571
572 /* ARGSUSED */
573 static int
574 man_HP_pre(MAN_ARGS)
575 {
576         struct htmlpair  tag;
577         struct roffsu    su;
578         const struct man_node *np;
579
580         np = MAN_BLOCK == n->type ? 
581                 n->head->child : 
582                 n->parent->head->child;
583
584         if (NULL == np || ! a2width(np, &su))
585                 SCALE_HS_INIT(&su, INDENT);
586
587         if (MAN_HEAD == n->type) {
588                 print_otag(h, TAG_TD, 0, NULL);
589                 return(0);
590         } else if (MAN_BLOCK == n->type) {
591                 print_otag(h, TAG_P, 0, NULL);
592                 print_otag(h, TAG_TABLE, 0, NULL);
593                 bufcat_su(h, "width", &su);
594                 PAIR_STYLE_INIT(&tag, h);
595                 print_otag(h, TAG_COL, 1, &tag);
596                 print_otag(h, TAG_COL, 0, NULL);
597                 print_otag(h, TAG_TBODY, 0, NULL);
598                 print_otag(h, TAG_TR, 0, NULL);
599                 return(1);
600         }
601
602         su.scale = -su.scale;
603         bufcat_su(h, "text-indent", &su);
604         PAIR_STYLE_INIT(&tag, h);
605         print_otag(h, TAG_TD, 1, &tag);
606         return(1);
607 }
608
609
610 /* ARGSUSED */
611 static int
612 man_B_pre(MAN_ARGS)
613 {
614
615         print_otag(h, TAG_B, 0, NULL);
616         return(1);
617 }
618
619
620 /* ARGSUSED */
621 static int
622 man_I_pre(MAN_ARGS)
623 {
624         
625         print_otag(h, TAG_I, 0, NULL);
626         return(1);
627 }
628
629
630 /* ARGSUSED */
631 static int
632 man_literal_pre(MAN_ARGS)
633 {
634
635         if (MAN_nf == n->tok) {
636                 print_otag(h, TAG_BR, 0, NULL);
637                 mh->fl |= MANH_LITERAL;
638         } else
639                 mh->fl &= ~MANH_LITERAL;
640
641         return(1);
642 }
643
644
645 /* ARGSUSED */
646 static int
647 man_in_pre(MAN_ARGS)
648 {
649
650         print_otag(h, TAG_BR, 0, NULL);
651         return(0);
652 }
653
654
655 /* ARGSUSED */
656 static int
657 man_ign_pre(MAN_ARGS)
658 {
659
660         return(0);
661 }
662
663
664 /* ARGSUSED */
665 static int
666 man_RS_pre(MAN_ARGS)
667 {
668         struct htmlpair  tag;
669         struct roffsu    su;
670
671         if (MAN_HEAD == n->type)
672                 return(0);
673         else if (MAN_BODY == n->type)
674                 return(1);
675
676         SCALE_HS_INIT(&su, INDENT);
677         if (n->head->child)
678                 a2width(n->head->child, &su);
679
680         bufcat_su(h, "margin-left", &su);
681         PAIR_STYLE_INIT(&tag, h);
682         print_otag(h, TAG_DIV, 1, &tag);
683         return(1);
684 }