man_html.c

   1 /* $Id: man_html.c,v 1.184 2022/07/06 16:05:40 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2013-2015,2017-2020,2022 Ingo Schwarze <schwarze@openbsd.org>
   4  * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
   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  * HTML formatter for man(7) used by mandoc(1).
  19  */
  20 #include "config.h"
  21
  22 #include <sys/types.h>
  23
  24 #include <assert.h>
  25 #include <ctype.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "mandoc_aux.h"
  31 #include "mandoc.h"
  32 #include "roff.h"
  33 #include "man.h"
  34 #include "out.h"
  35 #include "html.h"
  36 #include "main.h"
  37
  38 #define MAN_ARGS          const struct roff_meta *man, \
  39                           struct roff_node *n, \
  40                           struct html *h
  41
  42 struct  man_html_act {
  43         int             (*pre)(MAN_ARGS);
  44         int             (*post)(MAN_ARGS);
  45 };
  46
  47 static  void              print_man_head(const struct roff_meta *,
  48                                 struct html *);
  49 static  void              print_man_nodelist(MAN_ARGS);
  50 static  void              print_man_node(MAN_ARGS);
  51 static  char              list_continues(const struct roff_node *,
  52                                 const struct roff_node *);
  53 static  int               man_B_pre(MAN_ARGS);
  54 static  int               man_IP_pre(MAN_ARGS);
  55 static  int               man_I_pre(MAN_ARGS);
  56 static  int               man_OP_pre(MAN_ARGS);
  57 static  int               man_PP_pre(MAN_ARGS);
  58 static  int               man_RS_pre(MAN_ARGS);
  59 static  int               man_SH_pre(MAN_ARGS);
  60 static  int               man_SM_pre(MAN_ARGS);
  61 static  int               man_SY_pre(MAN_ARGS);
  62 static  int               man_UR_pre(MAN_ARGS);
  63 static  int               man_abort_pre(MAN_ARGS);
  64 static  int               man_alt_pre(MAN_ARGS);
  65 static  int               man_ign_pre(MAN_ARGS);
  66 static  int               man_in_pre(MAN_ARGS);
  67 static  void              man_root_post(const struct roff_meta *,
  68                                 struct html *);
  69 static  void              man_root_pre(const struct roff_meta *,
  70                                 struct html *);
  71
  72 static  const struct man_html_act man_html_acts[MAN_MAX - MAN_TH] = {
  73         { NULL, NULL }, /* TH */
  74         { man_SH_pre, NULL }, /* SH */
  75         { man_SH_pre, NULL }, /* SS */
  76         { man_IP_pre, NULL }, /* TP */
  77         { man_IP_pre, NULL }, /* TQ */
  78         { man_abort_pre, NULL }, /* LP */
  79         { man_PP_pre, NULL }, /* PP */
  80         { man_abort_pre, NULL }, /* P */
  81         { man_IP_pre, NULL }, /* IP */
  82         { man_PP_pre, NULL }, /* HP */
  83         { man_SM_pre, NULL }, /* SM */
  84         { man_SM_pre, NULL }, /* SB */
  85         { man_alt_pre, NULL }, /* BI */
  86         { man_alt_pre, NULL }, /* IB */
  87         { man_alt_pre, NULL }, /* BR */
  88         { man_alt_pre, NULL }, /* RB */
  89         { NULL, NULL }, /* R */
  90         { man_B_pre, NULL }, /* B */
  91         { man_I_pre, NULL }, /* I */
  92         { man_alt_pre, NULL }, /* IR */
  93         { man_alt_pre, NULL }, /* RI */
  94         { NULL, NULL }, /* RE */
  95         { man_RS_pre, NULL }, /* RS */
  96         { man_ign_pre, NULL }, /* DT */
  97         { man_ign_pre, NULL }, /* UC */
  98         { man_ign_pre, NULL }, /* PD */
  99         { man_ign_pre, NULL }, /* AT */
 100         { man_in_pre, NULL }, /* in */
 101         { man_SY_pre, NULL }, /* SY */
 102         { NULL, NULL }, /* YS */
 103         { man_OP_pre, NULL }, /* OP */
 104         { NULL, NULL }, /* EX */
 105         { NULL, NULL }, /* EE */
 106         { man_UR_pre, NULL }, /* UR */
 107         { NULL, NULL }, /* UE */
 108         { man_UR_pre, NULL }, /* MT */
 109         { NULL, NULL }, /* ME */
 110 };
 111
 112
 113 void
 114 html_man(void *arg, const struct roff_meta *man)
 115 {
 116         struct html             *h;
 117         struct roff_node        *n;
 118         struct tag              *t;
 119
 120         h = (struct html *)arg;
 121         n = man->first->child;
 122
 123         if ((h->oflags & HTML_FRAGMENT) == 0) {
 124                 print_gen_decls(h);
 125                 print_otag(h, TAG_HTML, "");
 126                 t = print_otag(h, TAG_HEAD, "");
 127                 print_man_head(man, h);
 128                 print_tagq(h, t);
 129                 if (n != NULL && n->type == ROFFT_COMMENT)
 130                         print_gen_comment(h, n);
 131                 print_otag(h, TAG_BODY, "");
 132         }
 133
 134         man_root_pre(man, h);
 135         t = print_otag(h, TAG_MAIN, "c", "manual-text");
 136         print_man_nodelist(man, n, h);
 137         print_tagq(h, t);
 138         man_root_post(man, h);
 139         print_tagq(h, NULL);
 140 }
 141
 142 static void
 143 print_man_head(const struct roff_meta *man, struct html *h)
 144 {
 145         char    *cp;
 146
 147         print_gen_head(h);
 148         mandoc_asprintf(&cp, "%s(%s)", man->title, man->msec);
 149         print_otag(h, TAG_TITLE, "");
 150         print_text(h, cp);
 151         free(cp);
 152 }
 153
 154 static void
 155 print_man_nodelist(MAN_ARGS)
 156 {
 157         while (n != NULL) {
 158                 print_man_node(man, n, h);
 159                 n = n->next;
 160         }
 161 }
 162
 163 static void
 164 print_man_node(MAN_ARGS)
 165 {
 166         struct tag      *t;
 167         int              child;
 168
 169         if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)
 170                 return;
 171
 172         if ((n->flags & NODE_NOFILL) == 0)
 173                 html_fillmode(h, ROFF_fi);
 174         else if (html_fillmode(h, ROFF_nf) == ROFF_nf &&
 175             n->tok != ROFF_fi && n->flags & NODE_LINE &&
 176             (n->prev == NULL || n->prev->tok != MAN_YS))
 177                 print_endline(h);
 178
 179         child = 1;
 180         switch (n->type) {
 181         case ROFFT_TEXT:
 182                 if (*n->string == '\0') {
 183                         print_endline(h);
 184                         return;
 185                 }
 186                 if (*n->string == ' ' && n->flags & NODE_LINE &&
 187                     (h->flags & HTML_NONEWLINE) == 0)
 188                         print_otag(h, TAG_BR, "");
 189                 else if (n->flags & NODE_DELIMC)
 190                         h->flags |= HTML_NOSPACE;
 191                 t = h->tag;
 192                 t->refcnt++;
 193                 print_text(h, n->string);
 194                 break;
 195         case ROFFT_EQN:
 196                 t = h->tag;
 197                 t->refcnt++;
 198                 print_eqn(h, n->eqn);
 199                 break;
 200         case ROFFT_TBL:
 201                 /*
 202                  * This will take care of initialising all of the table
 203                  * state data for the first table, then tearing it down
 204                  * for the last one.
 205                  */
 206                 print_tbl(h, n->span);
 207                 return;
 208         default:
 209                 /*
 210                  * Close out scope of font prior to opening a macro
 211                  * scope.
 212                  */
 213                 if (h->metac != ESCAPE_FONTROMAN) {
 214                         h->metal = h->metac;
 215                         h->metac = ESCAPE_FONTROMAN;
 216                 }
 217
 218                 /*
 219                  * Close out the current table, if it's open, and unset
 220                  * the "meta" table state.  This will be reopened on the
 221                  * next table element.
 222                  */
 223                 if (h->tblt != NULL)
 224                         print_tblclose(h);
 225                 t = h->tag;
 226                 t->refcnt++;
 227                 if (n->tok < ROFF_MAX) {
 228                         roff_html_pre(h, n);
 229                         t->refcnt--;
 230                         print_stagq(h, t);
 231                         return;
 232                 }
 233                 assert(n->tok >= MAN_TH && n->tok < MAN_MAX);
 234                 if (man_html_acts[n->tok - MAN_TH].pre != NULL)
 235                         child = (*man_html_acts[n->tok - MAN_TH].pre)(man,
 236                             n, h);
 237                 break;
 238         }
 239
 240         if (child && n->child != NULL)
 241                 print_man_nodelist(man, n->child, h);
 242
 243         /* This will automatically close out any font scope. */
 244         t->refcnt--;
 245         if (n->type == ROFFT_BLOCK &&
 246             (n->tok == MAN_IP || n->tok == MAN_TP || n->tok == MAN_TQ)) {
 247                 t = h->tag;
 248                 while (t->tag != TAG_DL && t->tag != TAG_UL)
 249                         t = t->next;
 250                 /*
 251                  * Close the list if no further item of the same type
 252                  * follows; otherwise, close the item only.
 253                  */
 254                 if (list_continues(n, roff_node_next(n)) == '\0') {
 255                         print_tagq(h, t);
 256                         t = NULL;
 257                 }
 258         }
 259         if (t != NULL)
 260                 print_stagq(h, t);
 261 }
 262
 263 static void
 264 man_root_pre(const struct roff_meta *man, struct html *h)
 265 {
 266         struct tag      *t;
 267         char            *title;
 268
 269         assert(man->title);
 270         assert(man->msec);
 271         mandoc_asprintf(&title, "%s(%s)", man->title, man->msec);
 272
 273         t = print_otag(h, TAG_DIV, "cr?", "head", "doc-pageheader",
 274             "aria-label", "Manual header line");
 275
 276         print_otag(h, TAG_SPAN, "c", "head-ltitle");
 277         print_text(h, title);
 278         print_stagq(h, t);
 279
 280         print_otag(h, TAG_SPAN, "c", "head-vol");
 281         if (man->vol != NULL)
 282                 print_text(h, man->vol);
 283         print_stagq(h, t);
 284
 285         print_otag(h, TAG_SPAN, "c", "head-rtitle");
 286         print_text(h, title);
 287         print_tagq(h, t);
 288         free(title);
 289 }
 290
 291 static void
 292 man_root_post(const struct roff_meta *man, struct html *h)
 293 {
 294         struct tag      *t;
 295
 296         t = print_otag(h, TAG_DIV, "cr?", "foot", "doc-pagefooter",
 297             "aria-label", "Manual footer line");
 298
 299         print_otag(h, TAG_SPAN, "c", "foot-left");
 300         print_stagq(h, t);
 301
 302         print_otag(h, TAG_SPAN, "c", "foot-date");
 303         print_text(h, man->date);
 304         print_stagq(h, t);
 305
 306         print_otag(h, TAG_SPAN, "c", "foot-os");
 307         if (man->os != NULL)
 308                 print_text(h, man->os);
 309         print_tagq(h, t);
 310 }
 311
 312 static int
 313 man_SH_pre(MAN_ARGS)
 314 {
 315         const char      *class;
 316         enum htmltag     tag;
 317
 318         if (n->tok == MAN_SH) {
 319                 tag = TAG_H2;
 320                 class = "Sh";
 321         } else {
 322                 tag = TAG_H3;
 323                 class = "Ss";
 324         }
 325         switch (n->type) {
 326         case ROFFT_BLOCK:
 327                 html_close_paragraph(h);
 328                 print_otag(h, TAG_SECTION, "c", class);
 329                 break;
 330         case ROFFT_HEAD:
 331                 print_otag_id(h, tag, class, n);
 332                 break;
 333         case ROFFT_BODY:
 334                 break;
 335         default:
 336                 abort();
 337         }
 338         return 1;
 339 }
 340
 341 static int
 342 man_alt_pre(MAN_ARGS)
 343 {
 344         const struct roff_node  *nn;
 345         struct tag      *t;
 346         int              i;
 347         enum htmltag     fp;
 348
 349         for (i = 0, nn = n->child; nn != NULL; nn = nn->next, i++) {
 350                 switch (n->tok) {
 351                 case MAN_BI:
 352                         fp = i % 2 ? TAG_I : TAG_B;
 353                         break;
 354                 case MAN_IB:
 355                         fp = i % 2 ? TAG_B : TAG_I;
 356                         break;
 357                 case MAN_RI:
 358                         fp = i % 2 ? TAG_I : TAG_MAX;
 359                         break;
 360                 case MAN_IR:
 361                         fp = i % 2 ? TAG_MAX : TAG_I;
 362                         break;
 363                 case MAN_BR:
 364                         fp = i % 2 ? TAG_MAX : TAG_B;
 365                         break;
 366                 case MAN_RB:
 367                         fp = i % 2 ? TAG_B : TAG_MAX;
 368                         break;
 369                 default:
 370                         abort();
 371                 }
 372
 373                 if (i)
 374                         h->flags |= HTML_NOSPACE;
 375
 376                 if (fp != TAG_MAX)
 377                         t = print_otag(h, fp, "");
 378
 379                 print_text(h, nn->string);
 380
 381                 if (fp != TAG_MAX)
 382                         print_tagq(h, t);
 383         }
 384         return 0;
 385 }
 386
 387 static int
 388 man_SM_pre(MAN_ARGS)
 389 {
 390         print_otag(h, TAG_SMALL, "");
 391         if (n->tok == MAN_SB)
 392                 print_otag(h, TAG_B, "");
 393         return 1;
 394 }
 395
 396 static int
 397 man_PP_pre(MAN_ARGS)
 398 {
 399         switch (n->type) {
 400         case ROFFT_BLOCK:
 401                 html_close_paragraph(h);
 402                 break;
 403         case ROFFT_HEAD:
 404                 return 0;
 405         case ROFFT_BODY:
 406                 if (n->child != NULL &&
 407                     (n->child->flags & NODE_NOFILL) == 0)
 408                         print_otag(h, TAG_P, "c",
 409                             n->tok == MAN_PP ? "Pp" : "Pp HP");
 410                 break;
 411         default:
 412                 abort();
 413         }
 414         return 1;
 415 }
 416
 417 static char
 418 list_continues(const struct roff_node *n1, const struct roff_node *n2)
 419 {
 420         const char *s1, *s2;
 421         char c1, c2;
 422
 423         if (n1 == NULL || n1->type != ROFFT_BLOCK ||
 424             n2 == NULL || n2->type != ROFFT_BLOCK)
 425                 return '\0';
 426         if ((n1->tok == MAN_TP || n1->tok == MAN_TQ) &&
 427             (n2->tok == MAN_TP || n2->tok == MAN_TQ))
 428                 return ' ';
 429         if (n1->tok != MAN_IP || n2->tok != MAN_IP)
 430                 return '\0';
 431         n1 = n1->head->child;
 432         n2 = n2->head->child;
 433         s1 = n1 == NULL ? "" : n1->string;
 434         s2 = n2 == NULL ? "" : n2->string;
 435         c1 = strcmp(s1, "*") == 0 ? '*' :
 436              strcmp(s1, "\\-") == 0 ? '-' :
 437              strcmp(s1, "\\(bu") == 0 ? 'b' : ' ';
 438         c2 = strcmp(s2, "*") == 0 ? '*' :
 439              strcmp(s2, "\\-") == 0 ? '-' :
 440              strcmp(s2, "\\(bu") == 0 ? 'b' : ' ';
 441         return c1 != c2 ? '\0' : c1 == 'b' ? '*' : c1;
 442 }
 443
 444 static int
 445 man_IP_pre(MAN_ARGS)
 446 {
 447         struct roff_node        *nn;
 448         const char              *list_class;
 449         enum htmltag             list_elem, body_elem;
 450         char                     list_type;
 451
 452         nn = n->type == ROFFT_BLOCK ? n : n->parent;
 453         list_type = list_continues(roff_node_prev(nn), nn);
 454         if (list_type == '\0') {
 455                 /* Start a new list. */
 456                 list_type = list_continues(nn, roff_node_next(nn));
 457                 if (list_type == '\0')
 458                         list_type = ' ';
 459                 switch (list_type) {
 460                 case ' ':
 461                         list_class = "Bl-tag";
 462                         list_elem = TAG_DL;
 463                         break;
 464                 case '*':
 465                         list_class = "Bl-bullet";
 466                         list_elem = TAG_UL;
 467                         break;
 468                 case '-':
 469                         list_class = "Bl-dash";
 470                         list_elem = TAG_UL;
 471                         break;
 472                 default:
 473                         abort();
 474                 }
 475         } else {
 476                 /* Continue a list that was started earlier. */
 477                 list_class = NULL;
 478                 list_elem = TAG_MAX;
 479         }
 480         body_elem = list_type == ' ' ? TAG_DD : TAG_LI;
 481
 482         switch (n->type) {
 483         case ROFFT_BLOCK:
 484                 html_close_paragraph(h);
 485                 if (list_elem != TAG_MAX)
 486                         print_otag(h, list_elem, "c", list_class);
 487                 return 1;
 488         case ROFFT_HEAD:
 489                 if (body_elem == TAG_LI)
 490                         return 0;
 491                 print_otag_id(h, TAG_DT, NULL, n);
 492                 break;
 493         case ROFFT_BODY:
 494                 print_otag(h, body_elem, "");
 495                 return 1;
 496         default:
 497                 abort();
 498         }
 499         switch(n->tok) {
 500         case MAN_IP:  /* Only print the first header element. */
 501                 if (n->child != NULL)
 502                         print_man_node(man, n->child, h);
 503                 break;
 504         case MAN_TP:  /* Only print next-line header elements. */
 505         case MAN_TQ:
 506                 nn = n->child;
 507                 while (nn != NULL && (NODE_LINE & nn->flags) == 0)
 508                         nn = nn->next;
 509                 while (nn != NULL) {
 510                         print_man_node(man, nn, h);
 511                         nn = nn->next;
 512                 }
 513                 break;
 514         default:
 515                 abort();
 516         }
 517         return 0;
 518 }
 519
 520 static int
 521 man_OP_pre(MAN_ARGS)
 522 {
 523         struct tag      *tt;
 524
 525         print_text(h, "[");
 526         h->flags |= HTML_NOSPACE;
 527         tt = print_otag(h, TAG_SPAN, "c", "Op");
 528
 529         if ((n = n->child) != NULL) {
 530                 print_otag(h, TAG_B, "");
 531                 print_text(h, n->string);
 532         }
 533
 534         print_stagq(h, tt);
 535
 536         if (n != NULL && n->next != NULL) {
 537                 print_otag(h, TAG_I, "");
 538                 print_text(h, n->next->string);
 539         }
 540
 541         print_stagq(h, tt);
 542         h->flags |= HTML_NOSPACE;
 543         print_text(h, "]");
 544         return 0;
 545 }
 546
 547 static int
 548 man_B_pre(MAN_ARGS)
 549 {
 550         print_otag(h, TAG_B, "");
 551         return 1;
 552 }
 553
 554 static int
 555 man_I_pre(MAN_ARGS)
 556 {
 557         print_otag(h, TAG_I, "");
 558         return 1;
 559 }
 560
 561 static int
 562 man_in_pre(MAN_ARGS)
 563 {
 564         print_otag(h, TAG_BR, "");
 565         return 0;
 566 }
 567
 568 static int
 569 man_ign_pre(MAN_ARGS)
 570 {
 571         return 0;
 572 }
 573
 574 static int
 575 man_RS_pre(MAN_ARGS)
 576 {
 577         switch (n->type) {
 578         case ROFFT_BLOCK:
 579                 html_close_paragraph(h);
 580                 break;
 581         case ROFFT_HEAD:
 582                 return 0;
 583         case ROFFT_BODY:
 584                 print_otag(h, TAG_DIV, "c", "Bd-indent");
 585                 break;
 586         default:
 587                 abort();
 588         }
 589         return 1;
 590 }
 591
 592 static int
 593 man_SY_pre(MAN_ARGS)
 594 {
 595         switch (n->type) {
 596         case ROFFT_BLOCK:
 597                 html_close_paragraph(h);
 598                 print_otag(h, TAG_TABLE, "c", "Nm");
 599                 print_otag(h, TAG_TR, "");
 600                 break;
 601         case ROFFT_HEAD:
 602                 print_otag(h, TAG_TD, "");
 603                 print_otag(h, TAG_CODE, "c", "Nm");
 604                 break;
 605         case ROFFT_BODY:
 606                 print_otag(h, TAG_TD, "");
 607                 break;
 608         default:
 609                 abort();
 610         }
 611         return 1;
 612 }
 613
 614 static int
 615 man_UR_pre(MAN_ARGS)
 616 {
 617         char *cp;
 618
 619         n = n->child;
 620         assert(n->type == ROFFT_HEAD);
 621         if (n->child != NULL) {
 622                 assert(n->child->type == ROFFT_TEXT);
 623                 if (n->tok == MAN_MT) {
 624                         mandoc_asprintf(&cp, "mailto:%s", n->child->string);
 625                         print_otag(h, TAG_A, "ch", "Mt", cp);
 626                         free(cp);
 627                 } else
 628                         print_otag(h, TAG_A, "ch", "Lk", n->child->string);
 629         }
 630
 631         assert(n->next->type == ROFFT_BODY);
 632         if (n->next->child != NULL)
 633                 n = n->next;
 634
 635         print_man_nodelist(man, n->child, h);
 636         return 0;
 637 }
 638
 639 static int
 640 man_abort_pre(MAN_ARGS)
 641 {
 642         abort();
 643 }