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