contrib/mdocml/man_html.c

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