1 /* $Id: man_html.c,v 1.173 2019/03/02 16:30:53 schwarze Exp $ */ 2 /* 3 * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv> 4 * Copyright (c) 2013-2015, 2017-2019 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 "mandoc.h" 30 #include "roff.h" 31 #include "man.h" 32 #include "out.h" 33 #include "html.h" 34 #include "main.h" 35 36 #define MAN_ARGS const struct roff_meta *man, \ 37 const struct roff_node *n, \ 38 struct html *h 39 40 struct man_html_act { 41 int (*pre)(MAN_ARGS); 42 int (*post)(MAN_ARGS); 43 }; 44 45 static void print_man_head(const struct roff_meta *, 46 struct html *); 47 static void print_man_nodelist(MAN_ARGS); 48 static void print_man_node(MAN_ARGS); 49 static char list_continues(const struct roff_node *, 50 const struct roff_node *); 51 static int man_B_pre(MAN_ARGS); 52 static int man_IP_pre(MAN_ARGS); 53 static int man_I_pre(MAN_ARGS); 54 static int man_OP_pre(MAN_ARGS); 55 static int man_PP_pre(MAN_ARGS); 56 static int man_RS_pre(MAN_ARGS); 57 static int man_SH_pre(MAN_ARGS); 58 static int man_SM_pre(MAN_ARGS); 59 static int man_SY_pre(MAN_ARGS); 60 static int man_UR_pre(MAN_ARGS); 61 static int man_abort_pre(MAN_ARGS); 62 static int man_alt_pre(MAN_ARGS); 63 static int man_ign_pre(MAN_ARGS); 64 static int man_in_pre(MAN_ARGS); 65 static void man_root_post(const struct roff_meta *, 66 struct html *); 67 static void man_root_pre(const struct roff_meta *, 68 struct html *); 69 70 static const struct man_html_act man_html_acts[MAN_MAX - MAN_TH] = { 71 { NULL, NULL }, /* TH */ 72 { man_SH_pre, NULL }, /* SH */ 73 { man_SH_pre, NULL }, /* SS */ 74 { man_IP_pre, NULL }, /* TP */ 75 { man_IP_pre, NULL }, /* TQ */ 76 { man_abort_pre, NULL }, /* LP */ 77 { man_PP_pre, NULL }, /* PP */ 78 { man_abort_pre, NULL }, /* P */ 79 { man_IP_pre, NULL }, /* IP */ 80 { man_PP_pre, NULL }, /* HP */ 81 { man_SM_pre, NULL }, /* SM */ 82 { man_SM_pre, NULL }, /* SB */ 83 { man_alt_pre, NULL }, /* BI */ 84 { man_alt_pre, NULL }, /* IB */ 85 { man_alt_pre, NULL }, /* BR */ 86 { man_alt_pre, NULL }, /* RB */ 87 { NULL, NULL }, /* R */ 88 { man_B_pre, NULL }, /* B */ 89 { man_I_pre, NULL }, /* I */ 90 { man_alt_pre, NULL }, /* IR */ 91 { man_alt_pre, NULL }, /* RI */ 92 { NULL, NULL }, /* RE */ 93 { man_RS_pre, NULL }, /* RS */ 94 { man_ign_pre, NULL }, /* DT */ 95 { man_ign_pre, NULL }, /* UC */ 96 { man_ign_pre, NULL }, /* PD */ 97 { man_ign_pre, NULL }, /* AT */ 98 { man_in_pre, NULL }, /* in */ 99 { man_SY_pre, NULL }, /* SY */ 100 { NULL, NULL }, /* YS */ 101 { man_OP_pre, NULL }, /* OP */ 102 { NULL, NULL }, /* EX */ 103 { NULL, NULL }, /* EE */ 104 { man_UR_pre, NULL }, /* UR */ 105 { NULL, NULL }, /* UE */ 106 { man_UR_pre, NULL }, /* MT */ 107 { NULL, NULL }, /* ME */ 108 }; 109 110 111 void 112 html_man(void *arg, const struct roff_meta *man) 113 { 114 struct html *h; 115 struct roff_node *n; 116 struct tag *t; 117 118 h = (struct html *)arg; 119 n = man->first->child; 120 121 if ((h->oflags & HTML_FRAGMENT) == 0) { 122 print_gen_decls(h); 123 print_otag(h, TAG_HTML, ""); 124 if (n != NULL && n->type == ROFFT_COMMENT) 125 print_gen_comment(h, n); 126 t = print_otag(h, TAG_HEAD, ""); 127 print_man_head(man, h); 128 print_tagq(h, t); 129 print_otag(h, TAG_BODY, ""); 130 } 131 132 man_root_pre(man, h); 133 t = print_otag(h, TAG_DIV, "c", "manual-text"); 134 print_man_nodelist(man, n, h); 135 print_tagq(h, t); 136 man_root_post(man, h); 137 print_tagq(h, NULL); 138 } 139 140 static void 141 print_man_head(const struct roff_meta *man, struct html *h) 142 { 143 char *cp; 144 145 print_gen_head(h); 146 mandoc_asprintf(&cp, "%s(%s)", man->title, man->msec); 147 print_otag(h, TAG_TITLE, ""); 148 print_text(h, cp); 149 free(cp); 150 } 151 152 static void 153 print_man_nodelist(MAN_ARGS) 154 { 155 while (n != NULL) { 156 print_man_node(man, n, h); 157 n = n->next; 158 } 159 } 160 161 static void 162 print_man_node(MAN_ARGS) 163 { 164 struct tag *t; 165 int child; 166 167 if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT) 168 return; 169 170 html_fillmode(h, n->flags & NODE_NOFILL ? ROFF_nf : ROFF_fi); 171 172 child = 1; 173 switch (n->type) { 174 case ROFFT_TEXT: 175 if (*n->string == '\0') { 176 print_endline(h); 177 return; 178 } 179 if (*n->string == ' ' && n->flags & NODE_LINE && 180 (h->flags & HTML_NONEWLINE) == 0) 181 print_endline(h); 182 else if (n->flags & NODE_DELIMC) 183 h->flags |= HTML_NOSPACE; 184 t = h->tag; 185 t->refcnt++; 186 print_text(h, n->string); 187 break; 188 case ROFFT_EQN: 189 t = h->tag; 190 t->refcnt++; 191 print_eqn(h, n->eqn); 192 break; 193 case ROFFT_TBL: 194 /* 195 * This will take care of initialising all of the table 196 * state data for the first table, then tearing it down 197 * for the last one. 198 */ 199 print_tbl(h, n->span); 200 return; 201 default: 202 /* 203 * Close out scope of font prior to opening a macro 204 * scope. 205 */ 206 if (HTMLFONT_NONE != h->metac) { 207 h->metal = h->metac; 208 h->metac = HTMLFONT_NONE; 209 } 210 211 /* 212 * Close out the current table, if it's open, and unset 213 * the "meta" table state. This will be reopened on the 214 * next table element. 215 */ 216 if (h->tblt != NULL) 217 print_tblclose(h); 218 t = h->tag; 219 t->refcnt++; 220 if (n->tok < ROFF_MAX) { 221 roff_html_pre(h, n); 222 t->refcnt--; 223 print_stagq(h, t); 224 return; 225 } 226 assert(n->tok >= MAN_TH && n->tok < MAN_MAX); 227 if (man_html_acts[n->tok - MAN_TH].pre != NULL) 228 child = (*man_html_acts[n->tok - MAN_TH].pre)(man, 229 n, h); 230 break; 231 } 232 233 if (child && n->child != NULL) 234 print_man_nodelist(man, n->child, h); 235 236 /* This will automatically close out any font scope. */ 237 t->refcnt--; 238 if (n->type == ROFFT_BLOCK && 239 (n->tok == MAN_IP || n->tok == MAN_TP || n->tok == MAN_TQ)) { 240 t = h->tag; 241 while (t->tag != TAG_DL && t->tag != TAG_UL) 242 t = t->next; 243 /* 244 * Close the list if no further item of the same type 245 * follows; otherwise, close the item only. 246 */ 247 if (list_continues(n, n->next) == '\0') { 248 print_tagq(h, t); 249 t = NULL; 250 } 251 } 252 if (t != NULL) 253 print_stagq(h, t); 254 255 if (n->flags & NODE_NOFILL && n->tok != MAN_YS && 256 (n->next != NULL && n->next->flags & NODE_LINE)) { 257 /* In .nf = <pre>, print even empty lines. */ 258 h->col++; 259 print_endline(h); 260 } 261 } 262 263 static void 264 man_root_pre(const struct roff_meta *man, struct html *h) 265 { 266 struct tag *t, *tt; 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_TABLE, "c", "head"); 274 tt = print_otag(h, TAG_TR, ""); 275 276 print_otag(h, TAG_TD, "c", "head-ltitle"); 277 print_text(h, title); 278 print_stagq(h, tt); 279 280 print_otag(h, TAG_TD, "c", "head-vol"); 281 if (man->vol != NULL) 282 print_text(h, man->vol); 283 print_stagq(h, tt); 284 285 print_otag(h, TAG_TD, "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, *tt; 295 296 t = print_otag(h, TAG_TABLE, "c", "foot"); 297 tt = print_otag(h, TAG_TR, ""); 298 299 print_otag(h, TAG_TD, "c", "foot-date"); 300 print_text(h, man->date); 301 print_stagq(h, tt); 302 303 print_otag(h, TAG_TD, "c", "foot-os"); 304 if (man->os != NULL) 305 print_text(h, man->os); 306 print_tagq(h, t); 307 } 308 309 static int 310 man_SH_pre(MAN_ARGS) 311 { 312 const char *class; 313 char *id; 314 enum htmltag tag; 315 316 if (n->tok == MAN_SH) { 317 tag = TAG_H1; 318 class = "Sh"; 319 } else { 320 tag = TAG_H2; 321 class = "Ss"; 322 } 323 switch (n->type) { 324 case ROFFT_BLOCK: 325 html_close_paragraph(h); 326 print_otag(h, TAG_SECTION, "c", class); 327 break; 328 case ROFFT_HEAD: 329 id = html_make_id(n, 1); 330 print_otag(h, tag, "ci", class, id); 331 if (id != NULL) 332 print_otag(h, TAG_A, "chR", "permalink", id); 333 break; 334 case ROFFT_BODY: 335 break; 336 default: 337 abort(); 338 } 339 return 1; 340 } 341 342 static int 343 man_alt_pre(MAN_ARGS) 344 { 345 const struct roff_node *nn; 346 struct tag *t; 347 int i; 348 enum htmltag fp; 349 350 for (i = 0, nn = n->child; nn != NULL; nn = nn->next, i++) { 351 switch (n->tok) { 352 case MAN_BI: 353 fp = i % 2 ? TAG_I : TAG_B; 354 break; 355 case MAN_IB: 356 fp = i % 2 ? TAG_B : TAG_I; 357 break; 358 case MAN_RI: 359 fp = i % 2 ? TAG_I : TAG_MAX; 360 break; 361 case MAN_IR: 362 fp = i % 2 ? TAG_MAX : TAG_I; 363 break; 364 case MAN_BR: 365 fp = i % 2 ? TAG_MAX : TAG_B; 366 break; 367 case MAN_RB: 368 fp = i % 2 ? TAG_B : TAG_MAX; 369 break; 370 default: 371 abort(); 372 } 373 374 if (i) 375 h->flags |= HTML_NOSPACE; 376 377 if (fp != TAG_MAX) 378 t = print_otag(h, fp, ""); 379 380 print_text(h, nn->string); 381 382 if (fp != TAG_MAX) 383 print_tagq(h, t); 384 } 385 return 0; 386 } 387 388 static int 389 man_SM_pre(MAN_ARGS) 390 { 391 print_otag(h, TAG_SMALL, ""); 392 if (n->tok == MAN_SB) 393 print_otag(h, TAG_B, ""); 394 return 1; 395 } 396 397 static int 398 man_PP_pre(MAN_ARGS) 399 { 400 switch (n->type) { 401 case ROFFT_BLOCK: 402 html_close_paragraph(h); 403 break; 404 case ROFFT_HEAD: 405 return 0; 406 case ROFFT_BODY: 407 if (n->child != NULL && 408 (n->child->flags & NODE_NOFILL) == 0) 409 print_otag(h, TAG_P, "c", 410 n->tok == MAN_PP ? "Pp" : "Pp HP"); 411 break; 412 default: 413 abort(); 414 } 415 return 1; 416 } 417 418 static char 419 list_continues(const struct roff_node *n1, const struct roff_node *n2) 420 { 421 const char *s1, *s2; 422 char c1, c2; 423 424 if (n1 == NULL || n1->type != ROFFT_BLOCK || 425 n2 == NULL || n2->type != ROFFT_BLOCK) 426 return '\0'; 427 if ((n1->tok == MAN_TP || n1->tok == MAN_TQ) && 428 (n2->tok == MAN_TP || n2->tok == MAN_TQ)) 429 return ' '; 430 if (n1->tok != MAN_IP || n2->tok != MAN_IP) 431 return '\0'; 432 n1 = n1->head->child; 433 n2 = n2->head->child; 434 s1 = n1 == NULL ? "" : n1->string; 435 s2 = n2 == NULL ? "" : n2->string; 436 c1 = strcmp(s1, "*") == 0 ? '*' : 437 strcmp(s1, "\\-") == 0 ? '-' : 438 strcmp(s1, "\\(bu") == 0 ? 'b' : ' '; 439 c2 = strcmp(s2, "*") == 0 ? '*' : 440 strcmp(s2, "\\-") == 0 ? '-' : 441 strcmp(s2, "\\(bu") == 0 ? 'b' : ' '; 442 return c1 != c2 ? '\0' : c1 == 'b' ? '*' : c1; 443 } 444 445 static int 446 man_IP_pre(MAN_ARGS) 447 { 448 const struct roff_node *nn; 449 const char *list_class; 450 enum htmltag list_elem, body_elem; 451 char list_type; 452 453 nn = n->type == ROFFT_BLOCK ? n : n->parent; 454 if ((list_type = list_continues(nn->prev, nn)) == '\0') { 455 /* Start a new list. */ 456 if ((list_type = list_continues(nn, nn->next)) == '\0') 457 list_type = ' '; 458 switch (list_type) { 459 case ' ': 460 list_class = "Bl-tag"; 461 list_elem = TAG_DL; 462 break; 463 case '*': 464 list_class = "Bl-bullet"; 465 list_elem = TAG_UL; 466 break; 467 case '-': 468 list_class = "Bl-dash"; 469 list_elem = TAG_UL; 470 break; 471 default: 472 abort(); 473 } 474 } else { 475 /* Continue a list that was started earlier. */ 476 list_class = NULL; 477 list_elem = TAG_MAX; 478 } 479 body_elem = list_type == ' ' ? TAG_DD : TAG_LI; 480 481 switch (n->type) { 482 case ROFFT_BLOCK: 483 html_close_paragraph(h); 484 if (list_elem != TAG_MAX) 485 print_otag(h, list_elem, "c", list_class); 486 return 1; 487 case ROFFT_HEAD: 488 if (body_elem == TAG_LI) 489 return 0; 490 print_otag(h, TAG_DT, ""); 491 break; 492 case ROFFT_BODY: 493 print_otag(h, body_elem, ""); 494 return 1; 495 default: 496 abort(); 497 } 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 } 644