contrib/mdocml/man_html.c

   1 /*      $Id: man_html.c,v 1.120 2016/01/08 17:48:09 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2013, 2014, 2015 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 AUTHORS DISCLAIM ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS 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 #include "config.h"
  19
  20 #include <sys/types.h>
  21
  22 #include <assert.h>
  23 #include <ctype.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "mandoc_aux.h"
  29 #include "roff.h"
  30 #include "man.h"
  31 #include "out.h"
  32 #include "html.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
  40 #define MAN_ARGS          const struct roff_meta *man, \
  41                           const struct roff_node *n, \
  42                           struct mhtml *mh, \
  43                           struct html *h
  44
  45 struct  mhtml {
  46         int               fl;
  47 #define MANH_LITERAL     (1 << 0) /* literal context */
  48 };
  49
  50 struct  htmlman {
  51         int             (*pre)(MAN_ARGS);
  52         int             (*post)(MAN_ARGS);
  53 };
  54
  55 static  void              print_bvspace(struct html *,
  56                                 const struct roff_node *);
  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 static  int               a2width(const struct roff_node *,
  61                                 struct roffsu *);
  62 static  int               man_B_pre(MAN_ARGS);
  63 static  int               man_HP_pre(MAN_ARGS);
  64 static  int               man_IP_pre(MAN_ARGS);
  65 static  int               man_I_pre(MAN_ARGS);
  66 static  int               man_OP_pre(MAN_ARGS);
  67 static  int               man_PP_pre(MAN_ARGS);
  68 static  int               man_RS_pre(MAN_ARGS);
  69 static  int               man_SH_pre(MAN_ARGS);
  70 static  int               man_SM_pre(MAN_ARGS);
  71 static  int               man_SS_pre(MAN_ARGS);
  72 static  int               man_UR_pre(MAN_ARGS);
  73 static  int               man_alt_pre(MAN_ARGS);
  74 static  int               man_br_pre(MAN_ARGS);
  75 static  int               man_ign_pre(MAN_ARGS);
  76 static  int               man_in_pre(MAN_ARGS);
  77 static  int               man_literal_pre(MAN_ARGS);
  78 static  void              man_root_post(MAN_ARGS);
  79 static  void              man_root_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_br_pre, NULL }, /* sp */
 104         { man_literal_pre, NULL }, /* nf */
 105         { man_literal_pre, NULL }, /* fi */
 106         { NULL, NULL }, /* RE */
 107         { man_RS_pre, NULL }, /* RS */
 108         { man_ign_pre, NULL }, /* DT */
 109         { man_ign_pre, NULL }, /* UC */
 110         { man_ign_pre, NULL }, /* PD */
 111         { man_ign_pre, NULL }, /* AT */
 112         { man_in_pre, NULL }, /* in */
 113         { man_ign_pre, NULL }, /* ft */
 114         { man_OP_pre, NULL }, /* OP */
 115         { man_literal_pre, NULL }, /* EX */
 116         { man_literal_pre, NULL }, /* EE */
 117         { man_UR_pre, NULL }, /* UR */
 118         { NULL, NULL }, /* UE */
 119         { man_ign_pre, NULL }, /* ll */
 120 };
 121
 122
 123 /*
 124  * Printing leading vertical space before a block.
 125  * This is used for the paragraph macros.
 126  * The rules are pretty simple, since there's very little nesting going
 127  * on here.  Basically, if we're the first within another block (SS/SH),
 128  * then don't emit vertical space.  If we are (RS), then do.  If not the
 129  * first, print it.
 130  */
 131 static void
 132 print_bvspace(struct html *h, const struct roff_node *n)
 133 {
 134
 135         if (n->body && n->body->child)
 136                 if (n->body->child->type == ROFFT_TBL)
 137                         return;
 138
 139         if (n->parent->type == ROFFT_ROOT || n->parent->tok != MAN_RS)
 140                 if (NULL == n->prev)
 141                         return;
 142
 143         print_paragraph(h);
 144 }
 145
 146 void
 147 html_man(void *arg, const struct roff_man *man)
 148 {
 149         struct mhtml     mh;
 150         struct htmlpair  tag;
 151         struct html     *h;
 152         struct tag      *t, *tt;
 153
 154         memset(&mh, 0, sizeof(mh));
 155         PAIR_CLASS_INIT(&tag, "mandoc");
 156         h = (struct html *)arg;
 157
 158         if ( ! (HTML_FRAGMENT & h->oflags)) {
 159                 print_gen_decls(h);
 160                 t = print_otag(h, TAG_HTML, 0, NULL);
 161                 tt = print_otag(h, TAG_HEAD, 0, NULL);
 162                 print_man_head(&man->meta, man->first, &mh, h);
 163                 print_tagq(h, tt);
 164                 print_otag(h, TAG_BODY, 0, NULL);
 165                 print_otag(h, TAG_DIV, 1, &tag);
 166         } else
 167                 t = print_otag(h, TAG_DIV, 1, &tag);
 168
 169         print_man_nodelist(&man->meta, man->first, &mh, h);
 170         print_tagq(h, t);
 171         putchar('\n');
 172 }
 173
 174 static void
 175 print_man_head(MAN_ARGS)
 176 {
 177
 178         print_gen_head(h);
 179         assert(man->title);
 180         assert(man->msec);
 181         bufcat_fmt(h, "%s(%s)", man->title, man->msec);
 182         print_otag(h, TAG_TITLE, 0, NULL);
 183         print_text(h, h->buf);
 184 }
 185
 186 static void
 187 print_man_nodelist(MAN_ARGS)
 188 {
 189
 190         while (n != NULL) {
 191                 print_man_node(man, n, mh, h);
 192                 n = n->next;
 193         }
 194 }
 195
 196 static void
 197 print_man_node(MAN_ARGS)
 198 {
 199         int              child;
 200         struct tag      *t;
 201
 202         child = 1;
 203         t = h->tags.head;
 204
 205         switch (n->type) {
 206         case ROFFT_ROOT:
 207                 man_root_pre(man, n, mh, h);
 208                 break;
 209         case ROFFT_TEXT:
 210                 if ('\0' == *n->string) {
 211                         print_paragraph(h);
 212                         return;
 213                 }
 214                 if (n->flags & MAN_LINE && (*n->string == ' ' ||
 215                     (n->prev != NULL && mh->fl & MANH_LITERAL &&
 216                      ! (h->flags & HTML_NONEWLINE))))
 217                         print_otag(h, TAG_BR, 0, NULL);
 218                 print_text(h, n->string);
 219                 return;
 220         case ROFFT_EQN:
 221                 if (n->flags & MAN_LINE)
 222                         putchar('\n');
 223                 print_eqn(h, n->eqn);
 224                 break;
 225         case ROFFT_TBL:
 226                 /*
 227                  * This will take care of initialising all of the table
 228                  * state data for the first table, then tearing it down
 229                  * for the last one.
 230                  */
 231                 print_tbl(h, n->span);
 232                 return;
 233         default:
 234                 /*
 235                  * Close out scope of font prior to opening a macro
 236                  * scope.
 237                  */
 238                 if (HTMLFONT_NONE != h->metac) {
 239                         h->metal = h->metac;
 240                         h->metac = HTMLFONT_NONE;
 241                 }
 242
 243                 /*
 244                  * Close out the current table, if it's open, and unset
 245                  * the "meta" table state.  This will be reopened on the
 246                  * next table element.
 247                  */
 248                 if (h->tblt) {
 249                         print_tblclose(h);
 250                         t = h->tags.head;
 251                 }
 252                 if (mans[n->tok].pre)
 253                         child = (*mans[n->tok].pre)(man, n, mh, h);
 254                 break;
 255         }
 256
 257         if (child && n->child)
 258                 print_man_nodelist(man, n->child, mh, h);
 259
 260         /* This will automatically close out any font scope. */
 261         print_stagq(h, t);
 262
 263         switch (n->type) {
 264         case ROFFT_ROOT:
 265                 man_root_post(man, n, mh, h);
 266                 break;
 267         case ROFFT_EQN:
 268                 break;
 269         default:
 270                 if (mans[n->tok].post)
 271                         (*mans[n->tok].post)(man, n, mh, h);
 272                 break;
 273         }
 274 }
 275
 276 static int
 277 a2width(const struct roff_node *n, struct roffsu *su)
 278 {
 279
 280         if (n->type != ROFFT_TEXT)
 281                 return 0;
 282         if (a2roffsu(n->string, su, SCALE_EN))
 283                 return 1;
 284
 285         return 0;
 286 }
 287
 288 static void
 289 man_root_pre(MAN_ARGS)
 290 {
 291         struct htmlpair  tag;
 292         struct tag      *t, *tt;
 293         char            *title;
 294
 295         assert(man->title);
 296         assert(man->msec);
 297         mandoc_asprintf(&title, "%s(%s)", man->title, man->msec);
 298
 299         PAIR_CLASS_INIT(&tag, "head");
 300         t = print_otag(h, TAG_TABLE, 1, &tag);
 301
 302         print_otag(h, TAG_TBODY, 0, NULL);
 303
 304         tt = print_otag(h, TAG_TR, 0, NULL);
 305
 306         PAIR_CLASS_INIT(&tag, "head-ltitle");
 307         print_otag(h, TAG_TD, 1, &tag);
 308         print_text(h, title);
 309         print_stagq(h, tt);
 310
 311         PAIR_CLASS_INIT(&tag, "head-vol");
 312         print_otag(h, TAG_TD, 1, &tag);
 313         if (NULL != man->vol)
 314                 print_text(h, man->vol);
 315         print_stagq(h, tt);
 316
 317         PAIR_CLASS_INIT(&tag, "head-rtitle");
 318         print_otag(h, TAG_TD, 1, &tag);
 319         print_text(h, title);
 320         print_tagq(h, t);
 321         free(title);
 322 }
 323
 324 static void
 325 man_root_post(MAN_ARGS)
 326 {
 327         struct htmlpair  tag;
 328         struct tag      *t, *tt;
 329
 330         PAIR_CLASS_INIT(&tag, "foot");
 331         t = print_otag(h, TAG_TABLE, 1, &tag);
 332
 333         tt = print_otag(h, TAG_TR, 0, NULL);
 334
 335         PAIR_CLASS_INIT(&tag, "foot-date");
 336         print_otag(h, TAG_TD, 1, &tag);
 337
 338         assert(man->date);
 339         print_text(h, man->date);
 340         print_stagq(h, tt);
 341
 342         PAIR_CLASS_INIT(&tag, "foot-os");
 343         print_otag(h, TAG_TD, 1, &tag);
 344
 345         if (man->os)
 346                 print_text(h, man->os);
 347         print_tagq(h, t);
 348 }
 349
 350
 351 static int
 352 man_br_pre(MAN_ARGS)
 353 {
 354         struct roffsu    su;
 355         struct htmlpair  tag;
 356
 357         SCALE_VS_INIT(&su, 1);
 358
 359         if (MAN_sp == n->tok) {
 360                 if (NULL != (n = n->child))
 361                         if ( ! a2roffsu(n->string, &su, SCALE_VS))
 362                                 su.scale = 1.0;
 363         } else
 364                 su.scale = 0.0;
 365
 366         bufinit(h);
 367         bufcat_su(h, "height", &su);
 368         PAIR_STYLE_INIT(&tag, h);
 369         print_otag(h, TAG_DIV, 1, &tag);
 370
 371         /* So the div isn't empty: */
 372         print_text(h, "\\~");
 373
 374         return 0;
 375 }
 376
 377 static int
 378 man_SH_pre(MAN_ARGS)
 379 {
 380         struct htmlpair  tag;
 381
 382         if (n->type == ROFFT_BLOCK) {
 383                 mh->fl &= ~MANH_LITERAL;
 384                 PAIR_CLASS_INIT(&tag, "section");
 385                 print_otag(h, TAG_DIV, 1, &tag);
 386                 return 1;
 387         } else if (n->type == ROFFT_BODY)
 388                 return 1;
 389
 390         print_otag(h, TAG_H1, 0, NULL);
 391         return 1;
 392 }
 393
 394 static int
 395 man_alt_pre(MAN_ARGS)
 396 {
 397         const struct roff_node  *nn;
 398         int              i, savelit;
 399         enum htmltag     fp;
 400         struct tag      *t;
 401
 402         if ((savelit = mh->fl & MANH_LITERAL))
 403                 print_otag(h, TAG_BR, 0, NULL);
 404
 405         mh->fl &= ~MANH_LITERAL;
 406
 407         for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
 408                 t = NULL;
 409                 switch (n->tok) {
 410                 case MAN_BI:
 411                         fp = i % 2 ? TAG_I : TAG_B;
 412                         break;
 413                 case MAN_IB:
 414                         fp = i % 2 ? TAG_B : TAG_I;
 415                         break;
 416                 case MAN_RI:
 417                         fp = i % 2 ? TAG_I : TAG_MAX;
 418                         break;
 419                 case MAN_IR:
 420                         fp = i % 2 ? TAG_MAX : TAG_I;
 421                         break;
 422                 case MAN_BR:
 423                         fp = i % 2 ? TAG_MAX : TAG_B;
 424                         break;
 425                 case MAN_RB:
 426                         fp = i % 2 ? TAG_B : TAG_MAX;
 427                         break;
 428                 default:
 429                         abort();
 430                 }
 431
 432                 if (i)
 433                         h->flags |= HTML_NOSPACE;
 434
 435                 if (TAG_MAX != fp)
 436                         t = print_otag(h, fp, 0, NULL);
 437
 438                 print_man_node(man, nn, mh, h);
 439
 440                 if (t)
 441                         print_tagq(h, t);
 442         }
 443
 444         if (savelit)
 445                 mh->fl |= MANH_LITERAL;
 446
 447         return 0;
 448 }
 449
 450 static int
 451 man_SM_pre(MAN_ARGS)
 452 {
 453
 454         print_otag(h, TAG_SMALL, 0, NULL);
 455         if (MAN_SB == n->tok)
 456                 print_otag(h, TAG_B, 0, NULL);
 457         return 1;
 458 }
 459
 460 static int
 461 man_SS_pre(MAN_ARGS)
 462 {
 463         struct htmlpair  tag;
 464
 465         if (n->type == ROFFT_BLOCK) {
 466                 mh->fl &= ~MANH_LITERAL;
 467                 PAIR_CLASS_INIT(&tag, "subsection");
 468                 print_otag(h, TAG_DIV, 1, &tag);
 469                 return 1;
 470         } else if (n->type == ROFFT_BODY)
 471                 return 1;
 472
 473         print_otag(h, TAG_H2, 0, NULL);
 474         return 1;
 475 }
 476
 477 static int
 478 man_PP_pre(MAN_ARGS)
 479 {
 480
 481         if (n->type == ROFFT_HEAD)
 482                 return 0;
 483         else if (n->type == ROFFT_BLOCK)
 484                 print_bvspace(h, n);
 485
 486         return 1;
 487 }
 488
 489 static int
 490 man_IP_pre(MAN_ARGS)
 491 {
 492         const struct roff_node  *nn;
 493
 494         if (n->type == ROFFT_BODY) {
 495                 print_otag(h, TAG_DD, 0, NULL);
 496                 return 1;
 497         } else if (n->type != ROFFT_HEAD) {
 498                 print_otag(h, TAG_DL, 0, NULL);
 499                 return 1;
 500         }
 501
 502         /* FIXME: width specification. */
 503
 504         print_otag(h, TAG_DT, 0, NULL);
 505
 506         /* For IP, only print the first header element. */
 507
 508         if (MAN_IP == n->tok && n->child)
 509                 print_man_node(man, n->child, mh, h);
 510
 511         /* For TP, only print next-line header elements. */
 512
 513         if (MAN_TP == n->tok) {
 514                 nn = n->child;
 515                 while (NULL != nn && 0 == (MAN_LINE & nn->flags))
 516                         nn = nn->next;
 517                 while (NULL != nn) {
 518                         print_man_node(man, nn, mh, h);
 519                         nn = nn->next;
 520                 }
 521         }
 522
 523         return 0;
 524 }
 525
 526 static int
 527 man_HP_pre(MAN_ARGS)
 528 {
 529         struct htmlpair  tag[2];
 530         struct roffsu    su;
 531         const struct roff_node *np;
 532
 533         if (n->type == ROFFT_HEAD)
 534                 return 0;
 535         else if (n->type != ROFFT_BLOCK)
 536                 return 1;
 537
 538         np = n->head->child;
 539
 540         if (NULL == np || ! a2width(np, &su))
 541                 SCALE_HS_INIT(&su, INDENT);
 542
 543         bufinit(h);
 544
 545         print_bvspace(h, n);
 546         bufcat_su(h, "margin-left", &su);
 547         su.scale = -su.scale;
 548         bufcat_su(h, "text-indent", &su);
 549         PAIR_STYLE_INIT(&tag[0], h);
 550         PAIR_CLASS_INIT(&tag[1], "spacer");
 551         print_otag(h, TAG_DIV, 2, tag);
 552         return 1;
 553 }
 554
 555 static int
 556 man_OP_pre(MAN_ARGS)
 557 {
 558         struct tag      *tt;
 559         struct htmlpair  tag;
 560
 561         print_text(h, "[");
 562         h->flags |= HTML_NOSPACE;
 563         PAIR_CLASS_INIT(&tag, "opt");
 564         tt = print_otag(h, TAG_SPAN, 1, &tag);
 565
 566         if (NULL != (n = n->child)) {
 567                 print_otag(h, TAG_B, 0, NULL);
 568                 print_text(h, n->string);
 569         }
 570
 571         print_stagq(h, tt);
 572
 573         if (NULL != n && NULL != n->next) {
 574                 print_otag(h, TAG_I, 0, NULL);
 575                 print_text(h, n->next->string);
 576         }
 577
 578         print_stagq(h, tt);
 579         h->flags |= HTML_NOSPACE;
 580         print_text(h, "]");
 581         return 0;
 582 }
 583
 584 static int
 585 man_B_pre(MAN_ARGS)
 586 {
 587
 588         print_otag(h, TAG_B, 0, NULL);
 589         return 1;
 590 }
 591
 592 static int
 593 man_I_pre(MAN_ARGS)
 594 {
 595
 596         print_otag(h, TAG_I, 0, NULL);
 597         return 1;
 598 }
 599
 600 static int
 601 man_literal_pre(MAN_ARGS)
 602 {
 603
 604         if (MAN_fi == n->tok || MAN_EE == n->tok) {
 605                 print_otag(h, TAG_BR, 0, NULL);
 606                 mh->fl &= ~MANH_LITERAL;
 607         } else
 608                 mh->fl |= MANH_LITERAL;
 609
 610         return 0;
 611 }
 612
 613 static int
 614 man_in_pre(MAN_ARGS)
 615 {
 616
 617         print_otag(h, TAG_BR, 0, NULL);
 618         return 0;
 619 }
 620
 621 static int
 622 man_ign_pre(MAN_ARGS)
 623 {
 624
 625         return 0;
 626 }
 627
 628 static int
 629 man_RS_pre(MAN_ARGS)
 630 {
 631         struct htmlpair  tag;
 632         struct roffsu    su;
 633
 634         if (n->type == ROFFT_HEAD)
 635                 return 0;
 636         else if (n->type == ROFFT_BODY)
 637                 return 1;
 638
 639         SCALE_HS_INIT(&su, INDENT);
 640         if (n->head->child)
 641                 a2width(n->head->child, &su);
 642
 643         bufinit(h);
 644         bufcat_su(h, "margin-left", &su);
 645         PAIR_STYLE_INIT(&tag, h);
 646         print_otag(h, TAG_DIV, 1, &tag);
 647         return 1;
 648 }
 649
 650 static int
 651 man_UR_pre(MAN_ARGS)
 652 {
 653         struct htmlpair          tag[2];
 654
 655         n = n->child;
 656         assert(n->type == ROFFT_HEAD);
 657         if (n->child != NULL) {
 658                 assert(n->child->type == ROFFT_TEXT);
 659                 PAIR_CLASS_INIT(&tag[0], "link-ext");
 660                 PAIR_HREF_INIT(&tag[1], n->child->string);
 661                 print_otag(h, TAG_A, 2, tag);
 662         }
 663
 664         assert(n->next->type == ROFFT_BODY);
 665         if (n->next->child != NULL)
 666                 n = n->next;
 667
 668         print_man_nodelist(man, n->child, mh, h);
 669
 670         return 0;
 671 }