man_html.c

   1 /*      $Id: man_html.c,v 1.128 2017/01/20 23:51:00 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2013, 2014, 2015, 2017 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 html     *h;
 151         struct tag      *t;
 152
 153         memset(&mh, 0, sizeof(mh));
 154         h = (struct html *)arg;
 155
 156         if ((h->oflags & HTML_FRAGMENT) == 0) {
 157                 print_gen_decls(h);
 158                 print_otag(h, TAG_HTML, "");
 159                 t = print_otag(h, TAG_HEAD, "");
 160                 print_man_head(&man->meta, man->first, &mh, h);
 161                 print_tagq(h, t);
 162                 print_otag(h, TAG_BODY, "");
 163         }
 164
 165         man_root_pre(&man->meta, man->first, &mh, h);
 166         t = print_otag(h, TAG_DIV, "c", "manual-text");
 167         print_man_nodelist(&man->meta, man->first->child, &mh, h);
 168         print_tagq(h, t);
 169         man_root_post(&man->meta, man->first, &mh, h);
 170         print_tagq(h, NULL);
 171 }
 172
 173 static void
 174 print_man_head(MAN_ARGS)
 175 {
 176         char    *cp;
 177
 178         print_gen_head(h);
 179         mandoc_asprintf(&cp, "%s(%s)", man->title, man->msec);
 180         print_otag(h, TAG_TITLE, "");
 181         print_text(h, cp);
 182         free(cp);
 183 }
 184
 185 static void
 186 print_man_nodelist(MAN_ARGS)
 187 {
 188
 189         while (n != NULL) {
 190                 print_man_node(man, n, mh, h);
 191                 n = n->next;
 192         }
 193 }
 194
 195 static void
 196 print_man_node(MAN_ARGS)
 197 {
 198         int              child;
 199         struct tag      *t;
 200
 201         child = 1;
 202         t = h->tags.head;
 203
 204         switch (n->type) {
 205         case ROFFT_TEXT:
 206                 if ('\0' == *n->string) {
 207                         print_paragraph(h);
 208                         return;
 209                 }
 210                 if (n->flags & NODE_LINE && (*n->string == ' ' ||
 211                     (n->prev != NULL && mh->fl & MANH_LITERAL &&
 212                      ! (h->flags & HTML_NONEWLINE))))
 213                         print_otag(h, TAG_BR, "");
 214                 print_text(h, n->string);
 215                 return;
 216         case ROFFT_EQN:
 217                 print_eqn(h, n->eqn);
 218                 break;
 219         case ROFFT_TBL:
 220                 /*
 221                  * This will take care of initialising all of the table
 222                  * state data for the first table, then tearing it down
 223                  * for the last one.
 224                  */
 225                 print_tbl(h, n->span);
 226                 return;
 227         default:
 228                 /*
 229                  * Close out scope of font prior to opening a macro
 230                  * scope.
 231                  */
 232                 if (HTMLFONT_NONE != h->metac) {
 233                         h->metal = h->metac;
 234                         h->metac = HTMLFONT_NONE;
 235                 }
 236
 237                 /*
 238                  * Close out the current table, if it's open, and unset
 239                  * the "meta" table state.  This will be reopened on the
 240                  * next table element.
 241                  */
 242                 if (h->tblt) {
 243                         print_tblclose(h);
 244                         t = h->tags.head;
 245                 }
 246                 if (mans[n->tok].pre)
 247                         child = (*mans[n->tok].pre)(man, n, mh, h);
 248                 break;
 249         }
 250
 251         if (child && n->child)
 252                 print_man_nodelist(man, n->child, mh, h);
 253
 254         /* This will automatically close out any font scope. */
 255         print_stagq(h, t);
 256
 257         switch (n->type) {
 258         case ROFFT_EQN:
 259                 break;
 260         default:
 261                 if (mans[n->tok].post)
 262                         (*mans[n->tok].post)(man, n, mh, h);
 263                 break;
 264         }
 265 }
 266
 267 static int
 268 a2width(const struct roff_node *n, struct roffsu *su)
 269 {
 270
 271         if (n->type != ROFFT_TEXT)
 272                 return 0;
 273         if (a2roffsu(n->string, su, SCALE_EN))
 274                 return 1;
 275
 276         return 0;
 277 }
 278
 279 static void
 280 man_root_pre(MAN_ARGS)
 281 {
 282         struct tag      *t, *tt;
 283         char            *title;
 284
 285         assert(man->title);
 286         assert(man->msec);
 287         mandoc_asprintf(&title, "%s(%s)", man->title, man->msec);
 288
 289         t = print_otag(h, TAG_TABLE, "c", "head");
 290         print_otag(h, TAG_TBODY, "");
 291         tt = print_otag(h, TAG_TR, "");
 292
 293         print_otag(h, TAG_TD, "c", "head-ltitle");
 294         print_text(h, title);
 295         print_stagq(h, tt);
 296
 297         print_otag(h, TAG_TD, "c", "head-vol");
 298         if (NULL != man->vol)
 299                 print_text(h, man->vol);
 300         print_stagq(h, tt);
 301
 302         print_otag(h, TAG_TD, "c", "head-rtitle");
 303         print_text(h, title);
 304         print_tagq(h, t);
 305         free(title);
 306 }
 307
 308 static void
 309 man_root_post(MAN_ARGS)
 310 {
 311         struct tag      *t, *tt;
 312
 313         t = print_otag(h, TAG_TABLE, "c", "foot");
 314         tt = print_otag(h, TAG_TR, "");
 315
 316         print_otag(h, TAG_TD, "c", "foot-date");
 317         print_text(h, man->date);
 318         print_stagq(h, tt);
 319
 320         print_otag(h, TAG_TD, "c", "foot-os");
 321         if (man->os)
 322                 print_text(h, man->os);
 323         print_tagq(h, t);
 324 }
 325
 326
 327 static int
 328 man_br_pre(MAN_ARGS)
 329 {
 330         struct roffsu    su;
 331
 332         SCALE_VS_INIT(&su, 1);
 333
 334         if (MAN_sp == n->tok) {
 335                 if (NULL != (n = n->child))
 336                         if ( ! a2roffsu(n->string, &su, SCALE_VS))
 337                                 su.scale = 1.0;
 338         } else
 339                 su.scale = 0.0;
 340
 341         print_otag(h, TAG_DIV, "suh", &su);
 342
 343         /* So the div isn't empty: */
 344         print_text(h, "\\~");
 345
 346         return 0;
 347 }
 348
 349 static int
 350 man_SH_pre(MAN_ARGS)
 351 {
 352         if (n->type == ROFFT_BLOCK) {
 353                 mh->fl &= ~MANH_LITERAL;
 354                 return 1;
 355         } else if (n->type == ROFFT_BODY)
 356                 return 1;
 357
 358         print_otag(h, TAG_H1, "c", "Sh");
 359         return 1;
 360 }
 361
 362 static int
 363 man_alt_pre(MAN_ARGS)
 364 {
 365         const struct roff_node  *nn;
 366         int              i, savelit;
 367         enum htmltag     fp;
 368         struct tag      *t;
 369
 370         if ((savelit = mh->fl & MANH_LITERAL))
 371                 print_otag(h, TAG_BR, "");
 372
 373         mh->fl &= ~MANH_LITERAL;
 374
 375         for (i = 0, nn = n->child; nn; nn = nn->next, i++) {
 376                 t = NULL;
 377                 switch (n->tok) {
 378                 case MAN_BI:
 379                         fp = i % 2 ? TAG_I : TAG_B;
 380                         break;
 381                 case MAN_IB:
 382                         fp = i % 2 ? TAG_B : TAG_I;
 383                         break;
 384                 case MAN_RI:
 385                         fp = i % 2 ? TAG_I : TAG_MAX;
 386                         break;
 387                 case MAN_IR:
 388                         fp = i % 2 ? TAG_MAX : TAG_I;
 389                         break;
 390                 case MAN_BR:
 391                         fp = i % 2 ? TAG_MAX : TAG_B;
 392                         break;
 393                 case MAN_RB:
 394                         fp = i % 2 ? TAG_B : TAG_MAX;
 395                         break;
 396                 default:
 397                         abort();
 398                 }
 399
 400                 if (i)
 401                         h->flags |= HTML_NOSPACE;
 402
 403                 if (TAG_MAX != fp)
 404                         t = print_otag(h, fp, "");
 405
 406                 print_man_node(man, nn, mh, h);
 407
 408                 if (t)
 409                         print_tagq(h, t);
 410         }
 411
 412         if (savelit)
 413                 mh->fl |= MANH_LITERAL;
 414
 415         return 0;
 416 }
 417
 418 static int
 419 man_SM_pre(MAN_ARGS)
 420 {
 421         print_otag(h, TAG_SMALL, "");
 422         if (MAN_SB == n->tok)
 423                 print_otag(h, TAG_B, "");
 424         return 1;
 425 }
 426
 427 static int
 428 man_SS_pre(MAN_ARGS)
 429 {
 430         if (n->type == ROFFT_BLOCK) {
 431                 mh->fl &= ~MANH_LITERAL;
 432                 return 1;
 433         } else if (n->type == ROFFT_BODY)
 434                 return 1;
 435
 436         print_otag(h, TAG_H2, "c", "Ss");
 437         return 1;
 438 }
 439
 440 static int
 441 man_PP_pre(MAN_ARGS)
 442 {
 443
 444         if (n->type == ROFFT_HEAD)
 445                 return 0;
 446         else if (n->type == ROFFT_BLOCK)
 447                 print_bvspace(h, n);
 448
 449         return 1;
 450 }
 451
 452 static int
 453 man_IP_pre(MAN_ARGS)
 454 {
 455         const struct roff_node  *nn;
 456
 457         if (n->type == ROFFT_BODY) {
 458                 print_otag(h, TAG_DD, "");
 459                 return 1;
 460         } else if (n->type != ROFFT_HEAD) {
 461                 print_otag(h, TAG_DL, "");
 462                 return 1;
 463         }
 464
 465         /* FIXME: width specification. */
 466
 467         print_otag(h, TAG_DT, "");
 468
 469         /* For IP, only print the first header element. */
 470
 471         if (MAN_IP == n->tok && n->child)
 472                 print_man_node(man, n->child, mh, h);
 473
 474         /* For TP, only print next-line header elements. */
 475
 476         if (MAN_TP == n->tok) {
 477                 nn = n->child;
 478                 while (NULL != nn && 0 == (NODE_LINE & nn->flags))
 479                         nn = nn->next;
 480                 while (NULL != nn) {
 481                         print_man_node(man, nn, mh, h);
 482                         nn = nn->next;
 483                 }
 484         }
 485
 486         return 0;
 487 }
 488
 489 static int
 490 man_HP_pre(MAN_ARGS)
 491 {
 492         struct roffsu    sum, sui;
 493         const struct roff_node *np;
 494
 495         if (n->type == ROFFT_HEAD)
 496                 return 0;
 497         else if (n->type != ROFFT_BLOCK)
 498                 return 1;
 499
 500         np = n->head->child;
 501
 502         if (np == NULL || !a2width(np, &sum))
 503                 SCALE_HS_INIT(&sum, INDENT);
 504
 505         sui.unit = sum.unit;
 506         sui.scale = -sum.scale;
 507
 508         print_bvspace(h, n);
 509         print_otag(h, TAG_DIV, "csului", "Pp", &sum, &sui);
 510         return 1;
 511 }
 512
 513 static int
 514 man_OP_pre(MAN_ARGS)
 515 {
 516         struct tag      *tt;
 517
 518         print_text(h, "[");
 519         h->flags |= HTML_NOSPACE;
 520         tt = print_otag(h, TAG_SPAN, "c", "Op");
 521
 522         if (NULL != (n = n->child)) {
 523                 print_otag(h, TAG_B, "");
 524                 print_text(h, n->string);
 525         }
 526
 527         print_stagq(h, tt);
 528
 529         if (NULL != n && NULL != n->next) {
 530                 print_otag(h, TAG_I, "");
 531                 print_text(h, n->next->string);
 532         }
 533
 534         print_stagq(h, tt);
 535         h->flags |= HTML_NOSPACE;
 536         print_text(h, "]");
 537         return 0;
 538 }
 539
 540 static int
 541 man_B_pre(MAN_ARGS)
 542 {
 543         print_otag(h, TAG_B, "");
 544         return 1;
 545 }
 546
 547 static int
 548 man_I_pre(MAN_ARGS)
 549 {
 550         print_otag(h, TAG_I, "");
 551         return 1;
 552 }
 553
 554 static int
 555 man_literal_pre(MAN_ARGS)
 556 {
 557
 558         if (MAN_fi == n->tok || MAN_EE == n->tok) {
 559                 print_otag(h, TAG_BR, "");
 560                 mh->fl &= ~MANH_LITERAL;
 561         } else
 562                 mh->fl |= MANH_LITERAL;
 563
 564         return 0;
 565 }
 566
 567 static int
 568 man_in_pre(MAN_ARGS)
 569 {
 570         print_otag(h, TAG_BR, "");
 571         return 0;
 572 }
 573
 574 static int
 575 man_ign_pre(MAN_ARGS)
 576 {
 577
 578         return 0;
 579 }
 580
 581 static int
 582 man_RS_pre(MAN_ARGS)
 583 {
 584         struct roffsu    su;
 585
 586         if (n->type == ROFFT_HEAD)
 587                 return 0;
 588         else if (n->type == ROFFT_BODY)
 589                 return 1;
 590
 591         SCALE_HS_INIT(&su, INDENT);
 592         if (n->head->child)
 593                 a2width(n->head->child, &su);
 594
 595         print_otag(h, TAG_DIV, "sul", &su);
 596         return 1;
 597 }
 598
 599 static int
 600 man_UR_pre(MAN_ARGS)
 601 {
 602         n = n->child;
 603         assert(n->type == ROFFT_HEAD);
 604         if (n->child != NULL) {
 605                 assert(n->child->type == ROFFT_TEXT);
 606                 print_otag(h, TAG_A, "ch", "Lk", n->child->string);
 607         }
 608
 609         assert(n->next->type == ROFFT_BODY);
 610         if (n->next->child != NULL)
 611                 n = n->next;
 612
 613         print_man_nodelist(man, n->child, mh, h);
 614
 615         return 0;
 616 }