man_html.c

   1 /*      $Id: man_html.c,v 1.56 2010/12/22 09:51:27 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
 202                 if (MANH_LITERAL & mh->fl)
 203                         print_otag(h, TAG_BR, 0, NULL);
 204
 205                 return;
 206         default:
 207                 /*
 208                  * Close out scope of font prior to opening a macro
 209                  * scope.  Assert that the metafont is on the top of the
 210                  * stack (it's never nested).
 211                  */
 212                 if (h->metaf) {
 213                         assert(h->metaf == t);
 214                         print_tagq(h, h->metaf);
 215                         assert(NULL == h->metaf);
 216                         t = h->tags.head;
 217                 }
 218                 if (mans[n->tok].pre)
 219                         child = (*mans[n->tok].pre)(m, n, mh, h);
 220                 break;
 221         }
 222
 223         if (child && n->child)
 224                 print_man_nodelist(m, n->child, mh, h);
 225
 226         /* This will automatically close out any font scope. */
 227         print_stagq(h, t);
 228
 229         bufinit(h);
 230
 231         switch (n->type) {
 232         case (MAN_ROOT):
 233                 man_root_post(m, n, mh, h);
 234                 break;
 235         case (MAN_TEXT):
 236                 break;
 237         default:
 238                 if (mans[n->tok].post)
 239                         (*mans[n->tok].post)(m, n, mh, h);
 240                 break;
 241         }
 242 }
 243
 244
 245 static int
 246 a2width(const struct man_node *n, struct roffsu *su)
 247 {
 248
 249         if (MAN_TEXT != n->type)
 250                 return(0);
 251         if (a2roffsu(n->string, su, SCALE_BU))
 252                 return(1);
 253
 254         return(0);
 255 }
 256
 257
 258 /* ARGSUSED */
 259 static int
 260 man_root_pre(MAN_ARGS)
 261 {
 262         struct htmlpair  tag[3];
 263         struct tag      *t, *tt;
 264         char             b[BUFSIZ], title[BUFSIZ];
 265
 266         b[0] = 0;
 267         if (m->vol)
 268                 (void)strlcat(b, m->vol, BUFSIZ);
 269
 270         snprintf(title, BUFSIZ - 1, "%s(%s)", m->title, m->msec);
 271
 272         PAIR_SUMMARY_INIT(&tag[0], "Document Header");
 273         PAIR_CLASS_INIT(&tag[1], "head");
 274         if (NULL == h->style) {
 275                 PAIR_INIT(&tag[2], ATTR_WIDTH, "100%");
 276                 t = print_otag(h, TAG_TABLE, 3, tag);
 277                 PAIR_INIT(&tag[0], ATTR_WIDTH, "30%");
 278                 print_otag(h, TAG_COL, 1, tag);
 279                 print_otag(h, TAG_COL, 1, tag);
 280                 print_otag(h, TAG_COL, 1, tag);
 281         } else
 282                 t = print_otag(h, TAG_TABLE, 2, tag);
 283
 284         print_otag(h, TAG_TBODY, 0, NULL);
 285
 286         tt = print_otag(h, TAG_TR, 0, NULL);
 287
 288         PAIR_CLASS_INIT(&tag[0], "head-ltitle");
 289         print_otag(h, TAG_TD, 1, tag);
 290
 291         print_text(h, title);
 292         print_stagq(h, tt);
 293
 294         PAIR_CLASS_INIT(&tag[0], "head-vol");
 295         if (NULL == h->style) {
 296                 PAIR_INIT(&tag[1], ATTR_ALIGN, "center");
 297                 print_otag(h, TAG_TD, 2, tag);
 298         } else
 299                 print_otag(h, TAG_TD, 1, tag);
 300
 301         print_text(h, b);
 302         print_stagq(h, tt);
 303
 304         PAIR_CLASS_INIT(&tag[0], "head-rtitle");
 305         if (NULL == h->style) {
 306                 PAIR_INIT(&tag[1], ATTR_ALIGN, "right");
 307                 print_otag(h, TAG_TD, 2, tag);
 308         } else
 309                 print_otag(h, TAG_TD, 1, tag);
 310
 311         print_text(h, title);
 312         print_tagq(h, t);
 313         return(1);
 314 }
 315
 316
 317 /* ARGSUSED */
 318 static void
 319 man_root_post(MAN_ARGS)
 320 {
 321         struct htmlpair  tag[3];
 322         struct tag      *t, *tt;
 323         char             b[DATESIZ];
 324
 325         if (m->rawdate)
 326                 strlcpy(b, m->rawdate, DATESIZ);
 327         else
 328                 time2a(m->date, b, DATESIZ);
 329
 330         PAIR_SUMMARY_INIT(&tag[0], "Document Footer");
 331         PAIR_CLASS_INIT(&tag[1], "foot");
 332         if (NULL == h->style) {
 333                 PAIR_INIT(&tag[2], ATTR_WIDTH, "100%");
 334                 t = print_otag(h, TAG_TABLE, 3, tag);
 335                 PAIR_INIT(&tag[0], ATTR_WIDTH, "50%");
 336                 print_otag(h, TAG_COL, 1, tag);
 337                 print_otag(h, TAG_COL, 1, tag);
 338         } else
 339                 t = print_otag(h, TAG_TABLE, 2, tag);
 340
 341         tt = print_otag(h, TAG_TR, 0, NULL);
 342
 343         PAIR_CLASS_INIT(&tag[0], "foot-date");
 344         print_otag(h, TAG_TD, 1, tag);
 345
 346         print_text(h, b);
 347         print_stagq(h, tt);
 348
 349         PAIR_CLASS_INIT(&tag[0], "foot-os");
 350         if (NULL == h->style) {
 351                 PAIR_INIT(&tag[1], ATTR_ALIGN, "right");
 352                 print_otag(h, TAG_TD, 2, tag);
 353         } else
 354                 print_otag(h, TAG_TD, 1, tag);
 355
 356         if (m->source)
 357                 print_text(h, m->source);
 358         print_tagq(h, t);
 359 }
 360
 361
 362
 363 /* ARGSUSED */
 364 static int
 365 man_br_pre(MAN_ARGS)
 366 {
 367         struct roffsu    su;
 368         struct htmlpair  tag;
 369
 370         SCALE_VS_INIT(&su, 1);
 371
 372         if (MAN_sp == n->tok) {
 373                 if (n->child)
 374                         a2roffsu(n->child->string, &su, SCALE_VS);
 375         } else
 376                 su.scale = 0;
 377
 378         bufcat_su(h, "height", &su);
 379         PAIR_STYLE_INIT(&tag, h);
 380         print_otag(h, TAG_DIV, 1, &tag);
 381
 382         /* So the div isn't empty: */
 383         print_text(h, "\\~");
 384
 385         return(0);
 386 }
 387
 388
 389 /* ARGSUSED */
 390 static int
 391 man_SH_pre(MAN_ARGS)
 392 {
 393         struct htmlpair  tag;
 394
 395         if (MAN_BLOCK == n->type) {
 396                 PAIR_CLASS_INIT(&tag, "section");
 397                 print_otag(h, TAG_DIV, 1, &tag);
 398                 return(1);
 399         } else if (MAN_BODY == n->type)
 400                 return(1);
 401
 402         print_otag(h, TAG_H1, 0, NULL);
 403         return(1);
 404 }
 405
 406
 407 /* ARGSUSED */
 408 static int
 409 man_alt_pre(MAN_ARGS)
 410 {
 411         const struct man_node   *nn;
 412         struct tag              *t;
 413         int                      i;
 414         enum htmlfont            fp;
 415
 416         for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
 417                 switch (n->tok) {
 418                 case (MAN_BI):
 419                         fp = i % 2 ? HTMLFONT_ITALIC : HTMLFONT_BOLD;
 420                         break;
 421                 case (MAN_IB):
 422                         fp = i % 2 ? HTMLFONT_BOLD : HTMLFONT_ITALIC;
 423                         break;
 424                 case (MAN_RI):
 425                         fp = i % 2 ? HTMLFONT_ITALIC : HTMLFONT_NONE;
 426                         break;
 427                 case (MAN_IR):
 428                         fp = i % 2 ? HTMLFONT_NONE : HTMLFONT_ITALIC;
 429                         break;
 430                 case (MAN_BR):
 431                         fp = i % 2 ? HTMLFONT_NONE : HTMLFONT_BOLD;
 432                         break;
 433                 case (MAN_RB):
 434                         fp = i % 2 ? HTMLFONT_BOLD : HTMLFONT_NONE;
 435                         break;
 436                 default:
 437                         abort();
 438                         /* NOTREACHED */
 439                 }
 440
 441                 if (i)
 442                         h->flags |= HTML_NOSPACE;
 443
 444                 /*
 445                  * Open and close the scope with each argument, so that
 446                  * internal \f escapes, which are common, are also
 447                  * closed out with the scope.
 448                  */
 449                 t = print_ofont(h, fp);
 450                 print_man_node(m, nn, mh, h);
 451                 print_tagq(h, t);
 452         }
 453
 454         return(0);
 455 }
 456
 457
 458 /* ARGSUSED */
 459 static int
 460 man_SM_pre(MAN_ARGS)
 461 {
 462         struct htmlpair  tag;
 463
 464         /* FIXME: print_ofont(). */
 465         PAIR_CLASS_INIT(&tag, "small");
 466         print_otag(h, TAG_SPAN, 1, &tag);
 467         if (MAN_SB == n->tok)
 468                 print_ofont(h, HTMLFONT_BOLD);
 469         return(1);
 470 }
 471
 472
 473 /* ARGSUSED */
 474 static int
 475 man_SS_pre(MAN_ARGS)
 476 {
 477         struct htmlpair  tag;
 478
 479         if (MAN_BLOCK == n->type) {
 480                 PAIR_CLASS_INIT(&tag, "subsection");
 481                 print_otag(h, TAG_DIV, 1, &tag);
 482                 return(1);
 483         } else if (MAN_BODY == n->type)
 484                 return(1);
 485
 486         print_otag(h, TAG_H2, 0, NULL);
 487         return(1);
 488 }
 489
 490
 491 /* ARGSUSED */
 492 static int
 493 man_PP_pre(MAN_ARGS)
 494 {
 495
 496         if (MAN_HEAD == n->type)
 497                 return(0);
 498         else if (MAN_BODY == n->type && n->prev)
 499                 print_otag(h, TAG_P, 0, NULL);
 500
 501         return(1);
 502 }
 503
 504
 505 /* ARGSUSED */
 506 static int
 507 man_IP_pre(MAN_ARGS)
 508 {
 509         struct roffsu            su;
 510         struct htmlpair          tag;
 511         const struct man_node   *nn;
 512         int                      width;
 513
 514         /*
 515          * This scattering of 1-BU margins and pads is to make sure that
 516          * when text overruns its box, the subsequent text isn't flush
 517          * up against it.  However, the rest of the right-hand box must
 518          * also be adjusted in consideration of this 1-BU space.
 519          */
 520
 521         if (MAN_BODY == n->type) {
 522                 print_otag(h, TAG_TD, 0, NULL);
 523                 return(1);
 524         }
 525
 526         nn = MAN_BLOCK == n->type ?
 527                 n->head->child : n->parent->head->child;
 528
 529         SCALE_HS_INIT(&su, INDENT);
 530         width = 0;
 531
 532         /* Width is the last token. */
 533
 534         if (MAN_IP == n->tok && NULL != nn)
 535                 if (NULL != (nn = nn->next)) {
 536                         for ( ; nn->next; nn = nn->next)
 537                                 /* Do nothing. */ ;
 538                         width = a2width(nn, &su);
 539                 }
 540
 541         /* Width is the first token. */
 542
 543         if (MAN_TP == n->tok && NULL != nn) {
 544                 /* Skip past non-text children. */
 545                 while (nn && MAN_TEXT != nn->type)
 546                         nn = nn->next;
 547                 if (nn)
 548                         width = a2width(nn, &su);
 549         }
 550
 551         if (MAN_BLOCK == n->type) {
 552                 print_otag(h, TAG_P, 0, NULL);
 553                 print_otag(h, TAG_TABLE, 0, NULL);
 554                 bufcat_su(h, "width", &su);
 555                 PAIR_STYLE_INIT(&tag, h);
 556                 print_otag(h, TAG_COL, 1, &tag);
 557                 print_otag(h, TAG_COL, 0, NULL);
 558                 print_otag(h, TAG_TBODY, 0, NULL);
 559                 print_otag(h, TAG_TR, 0, NULL);
 560                 return(1);
 561         }
 562
 563         print_otag(h, TAG_TD, 0, NULL);
 564
 565         /*
 566          * Without a length string, we can print all of our children.
 567          */
 568
 569         if ( ! width)
 570                 return(1);
 571
 572         /*
 573          * When a length has been specified, we need to carefully print
 574          * our child context:  IP gets all children printed but the last
 575          * (the width), while TP gets all children printed but the first
 576          * (the width).
 577          */
 578
 579         if (MAN_IP == n->tok)
 580                 for (nn = n->child; nn->next; nn = nn->next)
 581                         print_man_node(m, nn, mh, h);
 582         if (MAN_TP == n->tok)
 583                 for (nn = n->child->next; nn; nn = nn->next)
 584                         print_man_node(m, nn, mh, h);
 585
 586         return(0);
 587 }
 588
 589
 590 /* ARGSUSED */
 591 static int
 592 man_HP_pre(MAN_ARGS)
 593 {
 594         struct htmlpair  tag;
 595         struct roffsu    su;
 596         const struct man_node *np;
 597
 598         np = MAN_BLOCK == n->type ?
 599                 n->head->child :
 600                 n->parent->head->child;
 601
 602         if (NULL == np || ! a2width(np, &su))
 603                 SCALE_HS_INIT(&su, INDENT);
 604
 605         if (MAN_HEAD == n->type) {
 606                 print_otag(h, TAG_TD, 0, NULL);
 607                 return(0);
 608         } else if (MAN_BLOCK == n->type) {
 609                 print_otag(h, TAG_P, 0, NULL);
 610                 print_otag(h, TAG_TABLE, 0, NULL);
 611                 bufcat_su(h, "width", &su);
 612                 PAIR_STYLE_INIT(&tag, h);
 613                 print_otag(h, TAG_COL, 1, &tag);
 614                 print_otag(h, TAG_COL, 0, NULL);
 615                 print_otag(h, TAG_TBODY, 0, NULL);
 616                 print_otag(h, TAG_TR, 0, NULL);
 617                 return(1);
 618         }
 619
 620         su.scale = -su.scale;
 621         bufcat_su(h, "text-indent", &su);
 622         PAIR_STYLE_INIT(&tag, h);
 623         print_otag(h, TAG_TD, 1, &tag);
 624         return(1);
 625 }
 626
 627
 628 /* ARGSUSED */
 629 static int
 630 man_B_pre(MAN_ARGS)
 631 {
 632
 633         print_ofont(h, HTMLFONT_BOLD);
 634         return(1);
 635 }
 636
 637
 638 /* ARGSUSED */
 639 static int
 640 man_I_pre(MAN_ARGS)
 641 {
 642
 643         print_ofont(h, HTMLFONT_ITALIC);
 644         return(1);
 645 }
 646
 647
 648 /* ARGSUSED */
 649 static int
 650 man_literal_pre(MAN_ARGS)
 651 {
 652
 653         if (MAN_nf == n->tok) {
 654                 print_otag(h, TAG_BR, 0, NULL);
 655                 mh->fl |= MANH_LITERAL;
 656         } else
 657                 mh->fl &= ~MANH_LITERAL;
 658
 659         return(1);
 660 }
 661
 662
 663 /* ARGSUSED */
 664 static int
 665 man_in_pre(MAN_ARGS)
 666 {
 667
 668         print_otag(h, TAG_BR, 0, NULL);
 669         return(0);
 670 }
 671
 672
 673 /* ARGSUSED */
 674 static int
 675 man_ign_pre(MAN_ARGS)
 676 {
 677
 678         return(0);
 679 }
 680
 681
 682 /* ARGSUSED */
 683 static int
 684 man_RS_pre(MAN_ARGS)
 685 {
 686         struct htmlpair  tag;
 687         struct roffsu    su;
 688
 689         if (MAN_HEAD == n->type)
 690                 return(0);
 691         else if (MAN_BODY == n->type)
 692                 return(1);
 693
 694         SCALE_HS_INIT(&su, INDENT);
 695         if (n->head->child)
 696                 a2width(n->head->child, &su);
 697
 698         bufcat_su(h, "margin-left", &su);
 699         PAIR_STYLE_INIT(&tag, h);
 700         print_otag(h, TAG_DIV, 1, &tag);
 701         return(1);
 702 }