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