1 /* $Id: mdoc_html.c,v 1.310 2018/07/27 17:49:31 schwarze Exp $ */ 2 /* 3 * Copyright (c) 2008-2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv> 4 * Copyright (c) 2014,2015,2016,2017,2018 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 #include <unistd.h> 28 29 #include "mandoc_aux.h" 30 #include "mandoc.h" 31 #include "roff.h" 32 #include "mdoc.h" 33 #include "out.h" 34 #include "html.h" 35 #include "main.h" 36 37 #define MDOC_ARGS const struct roff_meta *meta, \ 38 struct roff_node *n, \ 39 struct html *h 40 41 #ifndef MIN 42 #define MIN(a,b) ((/*CONSTCOND*/(a)<(b))?(a):(b)) 43 #endif 44 45 struct htmlmdoc { 46 int (*pre)(MDOC_ARGS); 47 void (*post)(MDOC_ARGS); 48 }; 49 50 static char *cond_id(const struct roff_node *); 51 static void print_mdoc_head(const struct roff_meta *, 52 struct html *); 53 static void print_mdoc_node(MDOC_ARGS); 54 static void print_mdoc_nodelist(MDOC_ARGS); 55 static void synopsis_pre(struct html *, 56 const struct roff_node *); 57 58 static void mdoc_root_post(const struct roff_meta *, 59 struct html *); 60 static int mdoc_root_pre(const struct roff_meta *, 61 struct html *); 62 63 static void mdoc__x_post(MDOC_ARGS); 64 static int mdoc__x_pre(MDOC_ARGS); 65 static int mdoc_ad_pre(MDOC_ARGS); 66 static int mdoc_an_pre(MDOC_ARGS); 67 static int mdoc_ap_pre(MDOC_ARGS); 68 static int mdoc_ar_pre(MDOC_ARGS); 69 static int mdoc_bd_pre(MDOC_ARGS); 70 static int mdoc_bf_pre(MDOC_ARGS); 71 static void mdoc_bk_post(MDOC_ARGS); 72 static int mdoc_bk_pre(MDOC_ARGS); 73 static int mdoc_bl_pre(MDOC_ARGS); 74 static int mdoc_cd_pre(MDOC_ARGS); 75 static int mdoc_cm_pre(MDOC_ARGS); 76 static int mdoc_d1_pre(MDOC_ARGS); 77 static int mdoc_dv_pre(MDOC_ARGS); 78 static int mdoc_fa_pre(MDOC_ARGS); 79 static int mdoc_fd_pre(MDOC_ARGS); 80 static int mdoc_fl_pre(MDOC_ARGS); 81 static int mdoc_fn_pre(MDOC_ARGS); 82 static int mdoc_ft_pre(MDOC_ARGS); 83 static int mdoc_em_pre(MDOC_ARGS); 84 static void mdoc_eo_post(MDOC_ARGS); 85 static int mdoc_eo_pre(MDOC_ARGS); 86 static int mdoc_er_pre(MDOC_ARGS); 87 static int mdoc_ev_pre(MDOC_ARGS); 88 static int mdoc_ex_pre(MDOC_ARGS); 89 static void mdoc_fo_post(MDOC_ARGS); 90 static int mdoc_fo_pre(MDOC_ARGS); 91 static int mdoc_ic_pre(MDOC_ARGS); 92 static int mdoc_igndelim_pre(MDOC_ARGS); 93 static int mdoc_in_pre(MDOC_ARGS); 94 static int mdoc_it_pre(MDOC_ARGS); 95 static int mdoc_lb_pre(MDOC_ARGS); 96 static int mdoc_li_pre(MDOC_ARGS); 97 static int mdoc_lk_pre(MDOC_ARGS); 98 static int mdoc_mt_pre(MDOC_ARGS); 99 static int mdoc_ms_pre(MDOC_ARGS); 100 static int mdoc_nd_pre(MDOC_ARGS); 101 static int mdoc_nm_pre(MDOC_ARGS); 102 static int mdoc_no_pre(MDOC_ARGS); 103 static int mdoc_ns_pre(MDOC_ARGS); 104 static int mdoc_pa_pre(MDOC_ARGS); 105 static void mdoc_pf_post(MDOC_ARGS); 106 static int mdoc_pp_pre(MDOC_ARGS); 107 static void mdoc_quote_post(MDOC_ARGS); 108 static int mdoc_quote_pre(MDOC_ARGS); 109 static int mdoc_rs_pre(MDOC_ARGS); 110 static int mdoc_sh_pre(MDOC_ARGS); 111 static int mdoc_skip_pre(MDOC_ARGS); 112 static int mdoc_sm_pre(MDOC_ARGS); 113 static int mdoc_ss_pre(MDOC_ARGS); 114 static int mdoc_st_pre(MDOC_ARGS); 115 static int mdoc_sx_pre(MDOC_ARGS); 116 static int mdoc_sy_pre(MDOC_ARGS); 117 static int mdoc_va_pre(MDOC_ARGS); 118 static int mdoc_vt_pre(MDOC_ARGS); 119 static int mdoc_xr_pre(MDOC_ARGS); 120 static int mdoc_xx_pre(MDOC_ARGS); 121 122 static const struct htmlmdoc __mdocs[MDOC_MAX - MDOC_Dd] = { 123 {NULL, NULL}, /* Dd */ 124 {NULL, NULL}, /* Dt */ 125 {NULL, NULL}, /* Os */ 126 {mdoc_sh_pre, NULL }, /* Sh */ 127 {mdoc_ss_pre, NULL }, /* Ss */ 128 {mdoc_pp_pre, NULL}, /* Pp */ 129 {mdoc_d1_pre, NULL}, /* D1 */ 130 {mdoc_d1_pre, NULL}, /* Dl */ 131 {mdoc_bd_pre, NULL}, /* Bd */ 132 {NULL, NULL}, /* Ed */ 133 {mdoc_bl_pre, NULL}, /* Bl */ 134 {NULL, NULL}, /* El */ 135 {mdoc_it_pre, NULL}, /* It */ 136 {mdoc_ad_pre, NULL}, /* Ad */ 137 {mdoc_an_pre, NULL}, /* An */ 138 {mdoc_ap_pre, NULL}, /* Ap */ 139 {mdoc_ar_pre, NULL}, /* Ar */ 140 {mdoc_cd_pre, NULL}, /* Cd */ 141 {mdoc_cm_pre, NULL}, /* Cm */ 142 {mdoc_dv_pre, NULL}, /* Dv */ 143 {mdoc_er_pre, NULL}, /* Er */ 144 {mdoc_ev_pre, NULL}, /* Ev */ 145 {mdoc_ex_pre, NULL}, /* Ex */ 146 {mdoc_fa_pre, NULL}, /* Fa */ 147 {mdoc_fd_pre, NULL}, /* Fd */ 148 {mdoc_fl_pre, NULL}, /* Fl */ 149 {mdoc_fn_pre, NULL}, /* Fn */ 150 {mdoc_ft_pre, NULL}, /* Ft */ 151 {mdoc_ic_pre, NULL}, /* Ic */ 152 {mdoc_in_pre, NULL}, /* In */ 153 {mdoc_li_pre, NULL}, /* Li */ 154 {mdoc_nd_pre, NULL}, /* Nd */ 155 {mdoc_nm_pre, NULL}, /* Nm */ 156 {mdoc_quote_pre, mdoc_quote_post}, /* Op */ 157 {mdoc_ft_pre, NULL}, /* Ot */ 158 {mdoc_pa_pre, NULL}, /* Pa */ 159 {mdoc_ex_pre, NULL}, /* Rv */ 160 {mdoc_st_pre, NULL}, /* St */ 161 {mdoc_va_pre, NULL}, /* Va */ 162 {mdoc_vt_pre, NULL}, /* Vt */ 163 {mdoc_xr_pre, NULL}, /* Xr */ 164 {mdoc__x_pre, mdoc__x_post}, /* %A */ 165 {mdoc__x_pre, mdoc__x_post}, /* %B */ 166 {mdoc__x_pre, mdoc__x_post}, /* %D */ 167 {mdoc__x_pre, mdoc__x_post}, /* %I */ 168 {mdoc__x_pre, mdoc__x_post}, /* %J */ 169 {mdoc__x_pre, mdoc__x_post}, /* %N */ 170 {mdoc__x_pre, mdoc__x_post}, /* %O */ 171 {mdoc__x_pre, mdoc__x_post}, /* %P */ 172 {mdoc__x_pre, mdoc__x_post}, /* %R */ 173 {mdoc__x_pre, mdoc__x_post}, /* %T */ 174 {mdoc__x_pre, mdoc__x_post}, /* %V */ 175 {NULL, NULL}, /* Ac */ 176 {mdoc_quote_pre, mdoc_quote_post}, /* Ao */ 177 {mdoc_quote_pre, mdoc_quote_post}, /* Aq */ 178 {mdoc_xx_pre, NULL}, /* At */ 179 {NULL, NULL}, /* Bc */ 180 {mdoc_bf_pre, NULL}, /* Bf */ 181 {mdoc_quote_pre, mdoc_quote_post}, /* Bo */ 182 {mdoc_quote_pre, mdoc_quote_post}, /* Bq */ 183 {mdoc_xx_pre, NULL}, /* Bsx */ 184 {mdoc_xx_pre, NULL}, /* Bx */ 185 {mdoc_skip_pre, NULL}, /* Db */ 186 {NULL, NULL}, /* Dc */ 187 {mdoc_quote_pre, mdoc_quote_post}, /* Do */ 188 {mdoc_quote_pre, mdoc_quote_post}, /* Dq */ 189 {NULL, NULL}, /* Ec */ /* FIXME: no space */ 190 {NULL, NULL}, /* Ef */ 191 {mdoc_em_pre, NULL}, /* Em */ 192 {mdoc_eo_pre, mdoc_eo_post}, /* Eo */ 193 {mdoc_xx_pre, NULL}, /* Fx */ 194 {mdoc_ms_pre, NULL}, /* Ms */ 195 {mdoc_no_pre, NULL}, /* No */ 196 {mdoc_ns_pre, NULL}, /* Ns */ 197 {mdoc_xx_pre, NULL}, /* Nx */ 198 {mdoc_xx_pre, NULL}, /* Ox */ 199 {NULL, NULL}, /* Pc */ 200 {mdoc_igndelim_pre, mdoc_pf_post}, /* Pf */ 201 {mdoc_quote_pre, mdoc_quote_post}, /* Po */ 202 {mdoc_quote_pre, mdoc_quote_post}, /* Pq */ 203 {NULL, NULL}, /* Qc */ 204 {mdoc_quote_pre, mdoc_quote_post}, /* Ql */ 205 {mdoc_quote_pre, mdoc_quote_post}, /* Qo */ 206 {mdoc_quote_pre, mdoc_quote_post}, /* Qq */ 207 {NULL, NULL}, /* Re */ 208 {mdoc_rs_pre, NULL}, /* Rs */ 209 {NULL, NULL}, /* Sc */ 210 {mdoc_quote_pre, mdoc_quote_post}, /* So */ 211 {mdoc_quote_pre, mdoc_quote_post}, /* Sq */ 212 {mdoc_sm_pre, NULL}, /* Sm */ 213 {mdoc_sx_pre, NULL}, /* Sx */ 214 {mdoc_sy_pre, NULL}, /* Sy */ 215 {NULL, NULL}, /* Tn */ 216 {mdoc_xx_pre, NULL}, /* Ux */ 217 {NULL, NULL}, /* Xc */ 218 {NULL, NULL}, /* Xo */ 219 {mdoc_fo_pre, mdoc_fo_post}, /* Fo */ 220 {NULL, NULL}, /* Fc */ 221 {mdoc_quote_pre, mdoc_quote_post}, /* Oo */ 222 {NULL, NULL}, /* Oc */ 223 {mdoc_bk_pre, mdoc_bk_post}, /* Bk */ 224 {NULL, NULL}, /* Ek */ 225 {NULL, NULL}, /* Bt */ 226 {NULL, NULL}, /* Hf */ 227 {mdoc_em_pre, NULL}, /* Fr */ 228 {NULL, NULL}, /* Ud */ 229 {mdoc_lb_pre, NULL}, /* Lb */ 230 {mdoc_pp_pre, NULL}, /* Lp */ 231 {mdoc_lk_pre, NULL}, /* Lk */ 232 {mdoc_mt_pre, NULL}, /* Mt */ 233 {mdoc_quote_pre, mdoc_quote_post}, /* Brq */ 234 {mdoc_quote_pre, mdoc_quote_post}, /* Bro */ 235 {NULL, NULL}, /* Brc */ 236 {mdoc__x_pre, mdoc__x_post}, /* %C */ 237 {mdoc_skip_pre, NULL}, /* Es */ 238 {mdoc_quote_pre, mdoc_quote_post}, /* En */ 239 {mdoc_xx_pre, NULL}, /* Dx */ 240 {mdoc__x_pre, mdoc__x_post}, /* %Q */ 241 {mdoc__x_pre, mdoc__x_post}, /* %U */ 242 {NULL, NULL}, /* Ta */ 243 }; 244 static const struct htmlmdoc *const mdocs = __mdocs - MDOC_Dd; 245 246 247 /* 248 * See the same function in mdoc_term.c for documentation. 249 */ 250 static void 251 synopsis_pre(struct html *h, const struct roff_node *n) 252 { 253 254 if (NULL == n->prev || ! (NODE_SYNPRETTY & n->flags)) 255 return; 256 257 if (n->prev->tok == n->tok && 258 MDOC_Fo != n->tok && 259 MDOC_Ft != n->tok && 260 MDOC_Fn != n->tok) { 261 print_otag(h, TAG_BR, ""); 262 return; 263 } 264 265 switch (n->prev->tok) { 266 case MDOC_Fd: 267 case MDOC_Fn: 268 case MDOC_Fo: 269 case MDOC_In: 270 case MDOC_Vt: 271 print_paragraph(h); 272 break; 273 case MDOC_Ft: 274 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) { 275 print_paragraph(h); 276 break; 277 } 278 /* FALLTHROUGH */ 279 default: 280 print_otag(h, TAG_BR, ""); 281 break; 282 } 283 } 284 285 void 286 html_mdoc(void *arg, const struct roff_man *mdoc) 287 { 288 struct html *h; 289 struct roff_node *n; 290 struct tag *t; 291 292 h = (struct html *)arg; 293 n = mdoc->first->child; 294 295 if ((h->oflags & HTML_FRAGMENT) == 0) { 296 print_gen_decls(h); 297 print_otag(h, TAG_HTML, ""); 298 if (n->type == ROFFT_COMMENT) 299 print_gen_comment(h, n); 300 t = print_otag(h, TAG_HEAD, ""); 301 print_mdoc_head(&mdoc->meta, h); 302 print_tagq(h, t); 303 print_otag(h, TAG_BODY, ""); 304 } 305 306 mdoc_root_pre(&mdoc->meta, h); 307 t = print_otag(h, TAG_DIV, "c", "manual-text"); 308 print_mdoc_nodelist(&mdoc->meta, n, h); 309 print_tagq(h, t); 310 mdoc_root_post(&mdoc->meta, h); 311 print_tagq(h, NULL); 312 } 313 314 static void 315 print_mdoc_head(const struct roff_meta *meta, struct html *h) 316 { 317 char *cp; 318 319 print_gen_head(h); 320 321 if (meta->arch != NULL && meta->msec != NULL) 322 mandoc_asprintf(&cp, "%s(%s) (%s)", meta->title, 323 meta->msec, meta->arch); 324 else if (meta->msec != NULL) 325 mandoc_asprintf(&cp, "%s(%s)", meta->title, meta->msec); 326 else if (meta->arch != NULL) 327 mandoc_asprintf(&cp, "%s (%s)", meta->title, meta->arch); 328 else 329 cp = mandoc_strdup(meta->title); 330 331 print_otag(h, TAG_TITLE, ""); 332 print_text(h, cp); 333 free(cp); 334 } 335 336 static void 337 print_mdoc_nodelist(MDOC_ARGS) 338 { 339 340 while (n != NULL) { 341 print_mdoc_node(meta, n, h); 342 n = n->next; 343 } 344 } 345 346 static void 347 print_mdoc_node(MDOC_ARGS) 348 { 349 int child; 350 struct tag *t; 351 352 if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT) 353 return; 354 355 child = 1; 356 t = h->tag; 357 n->flags &= ~NODE_ENDED; 358 359 switch (n->type) { 360 case ROFFT_TEXT: 361 /* No tables in this mode... */ 362 assert(NULL == h->tblt); 363 364 /* 365 * Make sure that if we're in a literal mode already 366 * (i.e., within a <PRE>) don't print the newline. 367 */ 368 if (*n->string == ' ' && n->flags & NODE_LINE && 369 (h->flags & (HTML_LITERAL | HTML_NONEWLINE)) == 0) 370 print_otag(h, TAG_BR, ""); 371 if (NODE_DELIMC & n->flags) 372 h->flags |= HTML_NOSPACE; 373 print_text(h, n->string); 374 if (NODE_DELIMO & n->flags) 375 h->flags |= HTML_NOSPACE; 376 return; 377 case ROFFT_EQN: 378 print_eqn(h, n->eqn); 379 break; 380 case ROFFT_TBL: 381 /* 382 * This will take care of initialising all of the table 383 * state data for the first table, then tearing it down 384 * for the last one. 385 */ 386 print_tbl(h, n->span); 387 return; 388 default: 389 /* 390 * Close out the current table, if it's open, and unset 391 * the "meta" table state. This will be reopened on the 392 * next table element. 393 */ 394 if (h->tblt != NULL) { 395 print_tblclose(h); 396 t = h->tag; 397 } 398 assert(h->tblt == NULL); 399 if (n->tok < ROFF_MAX) { 400 roff_html_pre(h, n); 401 child = 0; 402 break; 403 } 404 assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX); 405 if (mdocs[n->tok].pre != NULL && 406 (n->end == ENDBODY_NOT || n->child != NULL)) 407 child = (*mdocs[n->tok].pre)(meta, n, h); 408 break; 409 } 410 411 if (h->flags & HTML_KEEP && n->flags & NODE_LINE) { 412 h->flags &= ~HTML_KEEP; 413 h->flags |= HTML_PREKEEP; 414 } 415 416 if (child && n->child) 417 print_mdoc_nodelist(meta, n->child, h); 418 419 print_stagq(h, t); 420 421 switch (n->type) { 422 case ROFFT_EQN: 423 break; 424 default: 425 if (n->tok < ROFF_MAX || 426 mdocs[n->tok].post == NULL || 427 n->flags & NODE_ENDED) 428 break; 429 (*mdocs[n->tok].post)(meta, n, h); 430 if (n->end != ENDBODY_NOT) 431 n->body->flags |= NODE_ENDED; 432 break; 433 } 434 } 435 436 static void 437 mdoc_root_post(const struct roff_meta *meta, struct html *h) 438 { 439 struct tag *t, *tt; 440 441 t = print_otag(h, TAG_TABLE, "c", "foot"); 442 tt = print_otag(h, TAG_TR, ""); 443 444 print_otag(h, TAG_TD, "c", "foot-date"); 445 print_text(h, meta->date); 446 print_stagq(h, tt); 447 448 print_otag(h, TAG_TD, "c", "foot-os"); 449 print_text(h, meta->os); 450 print_tagq(h, t); 451 } 452 453 static int 454 mdoc_root_pre(const struct roff_meta *meta, struct html *h) 455 { 456 struct tag *t, *tt; 457 char *volume, *title; 458 459 if (NULL == meta->arch) 460 volume = mandoc_strdup(meta->vol); 461 else 462 mandoc_asprintf(&volume, "%s (%s)", 463 meta->vol, meta->arch); 464 465 if (NULL == meta->msec) 466 title = mandoc_strdup(meta->title); 467 else 468 mandoc_asprintf(&title, "%s(%s)", 469 meta->title, meta->msec); 470 471 t = print_otag(h, TAG_TABLE, "c", "head"); 472 tt = print_otag(h, TAG_TR, ""); 473 474 print_otag(h, TAG_TD, "c", "head-ltitle"); 475 print_text(h, title); 476 print_stagq(h, tt); 477 478 print_otag(h, TAG_TD, "c", "head-vol"); 479 print_text(h, volume); 480 print_stagq(h, tt); 481 482 print_otag(h, TAG_TD, "c", "head-rtitle"); 483 print_text(h, title); 484 print_tagq(h, t); 485 486 free(title); 487 free(volume); 488 return 1; 489 } 490 491 static char * 492 cond_id(const struct roff_node *n) 493 { 494 if (n->child != NULL && 495 n->child->type == ROFFT_TEXT && 496 (n->prev == NULL || 497 (n->prev->type == ROFFT_TEXT && 498 strcmp(n->prev->string, "|") == 0)) && 499 (n->parent->tok == MDOC_It || 500 (n->parent->tok == MDOC_Xo && 501 n->parent->parent->prev == NULL && 502 n->parent->parent->parent->tok == MDOC_It))) 503 return html_make_id(n, 1); 504 return NULL; 505 } 506 507 static int 508 mdoc_sh_pre(MDOC_ARGS) 509 { 510 char *id; 511 512 switch (n->type) { 513 case ROFFT_HEAD: 514 id = html_make_id(n, 1); 515 print_otag(h, TAG_H1, "cTi", "Sh", id); 516 if (id != NULL) 517 print_otag(h, TAG_A, "chR", "permalink", id); 518 break; 519 case ROFFT_BODY: 520 if (n->sec == SEC_AUTHORS) 521 h->flags &= ~(HTML_SPLIT|HTML_NOSPLIT); 522 break; 523 default: 524 break; 525 } 526 return 1; 527 } 528 529 static int 530 mdoc_ss_pre(MDOC_ARGS) 531 { 532 char *id; 533 534 if (n->type != ROFFT_HEAD) 535 return 1; 536 537 id = html_make_id(n, 1); 538 print_otag(h, TAG_H2, "cTi", "Ss", id); 539 if (id != NULL) 540 print_otag(h, TAG_A, "chR", "permalink", id); 541 return 1; 542 } 543 544 static int 545 mdoc_fl_pre(MDOC_ARGS) 546 { 547 char *id; 548 549 if ((id = cond_id(n)) != NULL) 550 print_otag(h, TAG_A, "chR", "permalink", id); 551 print_otag(h, TAG_CODE, "cTi", "Fl", id); 552 553 print_text(h, "\\-"); 554 if (!(n->child == NULL && 555 (n->next == NULL || 556 n->next->type == ROFFT_TEXT || 557 n->next->flags & NODE_LINE))) 558 h->flags |= HTML_NOSPACE; 559 560 return 1; 561 } 562 563 static int 564 mdoc_cm_pre(MDOC_ARGS) 565 { 566 char *id; 567 568 if ((id = cond_id(n)) != NULL) 569 print_otag(h, TAG_A, "chR", "permalink", id); 570 print_otag(h, TAG_CODE, "cTi", "Cm", id); 571 return 1; 572 } 573 574 static int 575 mdoc_nd_pre(MDOC_ARGS) 576 { 577 if (n->type != ROFFT_BODY) 578 return 1; 579 580 print_text(h, "\\(em"); 581 /* Cannot use TAG_SPAN because it may contain blocks. */ 582 print_otag(h, TAG_DIV, "cT", "Nd"); 583 return 1; 584 } 585 586 static int 587 mdoc_nm_pre(MDOC_ARGS) 588 { 589 switch (n->type) { 590 case ROFFT_HEAD: 591 print_otag(h, TAG_TD, ""); 592 /* FALLTHROUGH */ 593 case ROFFT_ELEM: 594 print_otag(h, TAG_CODE, "cT", "Nm"); 595 return 1; 596 case ROFFT_BODY: 597 print_otag(h, TAG_TD, ""); 598 return 1; 599 default: 600 break; 601 } 602 synopsis_pre(h, n); 603 print_otag(h, TAG_TABLE, "c", "Nm"); 604 print_otag(h, TAG_TR, ""); 605 return 1; 606 } 607 608 static int 609 mdoc_xr_pre(MDOC_ARGS) 610 { 611 if (NULL == n->child) 612 return 0; 613 614 if (h->base_man) 615 print_otag(h, TAG_A, "cThM", "Xr", 616 n->child->string, n->child->next == NULL ? 617 NULL : n->child->next->string); 618 else 619 print_otag(h, TAG_A, "cT", "Xr"); 620 621 n = n->child; 622 print_text(h, n->string); 623 624 if (NULL == (n = n->next)) 625 return 0; 626 627 h->flags |= HTML_NOSPACE; 628 print_text(h, "("); 629 h->flags |= HTML_NOSPACE; 630 print_text(h, n->string); 631 h->flags |= HTML_NOSPACE; 632 print_text(h, ")"); 633 return 0; 634 } 635 636 static int 637 mdoc_ns_pre(MDOC_ARGS) 638 { 639 640 if ( ! (NODE_LINE & n->flags)) 641 h->flags |= HTML_NOSPACE; 642 return 1; 643 } 644 645 static int 646 mdoc_ar_pre(MDOC_ARGS) 647 { 648 print_otag(h, TAG_VAR, "cT", "Ar"); 649 return 1; 650 } 651 652 static int 653 mdoc_xx_pre(MDOC_ARGS) 654 { 655 print_otag(h, TAG_SPAN, "c", "Ux"); 656 return 1; 657 } 658 659 static int 660 mdoc_it_pre(MDOC_ARGS) 661 { 662 const struct roff_node *bl; 663 struct tag *t; 664 enum mdoc_list type; 665 666 bl = n->parent; 667 while (bl->tok != MDOC_Bl) 668 bl = bl->parent; 669 type = bl->norm->Bl.type; 670 671 switch (type) { 672 case LIST_bullet: 673 case LIST_dash: 674 case LIST_hyphen: 675 case LIST_item: 676 case LIST_enum: 677 switch (n->type) { 678 case ROFFT_HEAD: 679 return 0; 680 case ROFFT_BODY: 681 print_otag(h, TAG_LI, ""); 682 break; 683 default: 684 break; 685 } 686 break; 687 case LIST_diag: 688 case LIST_hang: 689 case LIST_inset: 690 case LIST_ohang: 691 switch (n->type) { 692 case ROFFT_HEAD: 693 print_otag(h, TAG_DT, ""); 694 break; 695 case ROFFT_BODY: 696 print_otag(h, TAG_DD, ""); 697 break; 698 default: 699 break; 700 } 701 break; 702 case LIST_tag: 703 switch (n->type) { 704 case ROFFT_HEAD: 705 if (h->style != NULL && !bl->norm->Bl.comp && 706 (n->parent->prev == NULL || 707 n->parent->prev->body == NULL || 708 n->parent->prev->body->child != NULL)) { 709 t = print_otag(h, TAG_DT, ""); 710 print_text(h, "\\ "); 711 print_tagq(h, t); 712 t = print_otag(h, TAG_DD, ""); 713 print_text(h, "\\ "); 714 print_tagq(h, t); 715 } 716 print_otag(h, TAG_DT, ""); 717 break; 718 case ROFFT_BODY: 719 if (n->child == NULL) { 720 print_otag(h, TAG_DD, "s", "width", "auto"); 721 print_text(h, "\\ "); 722 } else 723 print_otag(h, TAG_DD, ""); 724 break; 725 default: 726 break; 727 } 728 break; 729 case LIST_column: 730 switch (n->type) { 731 case ROFFT_HEAD: 732 break; 733 case ROFFT_BODY: 734 print_otag(h, TAG_TD, ""); 735 break; 736 default: 737 print_otag(h, TAG_TR, ""); 738 } 739 default: 740 break; 741 } 742 743 return 1; 744 } 745 746 static int 747 mdoc_bl_pre(MDOC_ARGS) 748 { 749 char cattr[28]; 750 struct mdoc_bl *bl; 751 enum htmltag elemtype; 752 753 switch (n->type) { 754 case ROFFT_BODY: 755 return 1; 756 case ROFFT_HEAD: 757 return 0; 758 default: 759 break; 760 } 761 762 bl = &n->norm->Bl; 763 switch (bl->type) { 764 case LIST_bullet: 765 elemtype = TAG_UL; 766 (void)strlcpy(cattr, "Bl-bullet", sizeof(cattr)); 767 break; 768 case LIST_dash: 769 case LIST_hyphen: 770 elemtype = TAG_UL; 771 (void)strlcpy(cattr, "Bl-dash", sizeof(cattr)); 772 break; 773 case LIST_item: 774 elemtype = TAG_UL; 775 (void)strlcpy(cattr, "Bl-item", sizeof(cattr)); 776 break; 777 case LIST_enum: 778 elemtype = TAG_OL; 779 (void)strlcpy(cattr, "Bl-enum", sizeof(cattr)); 780 break; 781 case LIST_diag: 782 elemtype = TAG_DL; 783 (void)strlcpy(cattr, "Bl-diag", sizeof(cattr)); 784 break; 785 case LIST_hang: 786 elemtype = TAG_DL; 787 (void)strlcpy(cattr, "Bl-hang", sizeof(cattr)); 788 break; 789 case LIST_inset: 790 elemtype = TAG_DL; 791 (void)strlcpy(cattr, "Bl-inset", sizeof(cattr)); 792 break; 793 case LIST_ohang: 794 elemtype = TAG_DL; 795 (void)strlcpy(cattr, "Bl-ohang", sizeof(cattr)); 796 break; 797 case LIST_tag: 798 if (bl->offs) 799 print_otag(h, TAG_DIV, "c", "Bd-indent"); 800 print_otag(h, TAG_DL, "c", bl->comp ? 801 "Bl-tag Bl-compact" : "Bl-tag"); 802 return 1; 803 case LIST_column: 804 elemtype = TAG_TABLE; 805 (void)strlcpy(cattr, "Bl-column", sizeof(cattr)); 806 break; 807 default: 808 abort(); 809 } 810 if (bl->offs != NULL) 811 (void)strlcat(cattr, " Bd-indent", sizeof(cattr)); 812 if (bl->comp) 813 (void)strlcat(cattr, " Bl-compact", sizeof(cattr)); 814 print_otag(h, elemtype, "c", cattr); 815 return 1; 816 } 817 818 static int 819 mdoc_ex_pre(MDOC_ARGS) 820 { 821 if (n->prev) 822 print_otag(h, TAG_BR, ""); 823 return 1; 824 } 825 826 static int 827 mdoc_st_pre(MDOC_ARGS) 828 { 829 print_otag(h, TAG_SPAN, "cT", "St"); 830 return 1; 831 } 832 833 static int 834 mdoc_em_pre(MDOC_ARGS) 835 { 836 print_otag(h, TAG_I, "cT", "Em"); 837 return 1; 838 } 839 840 static int 841 mdoc_d1_pre(MDOC_ARGS) 842 { 843 if (n->type != ROFFT_BLOCK) 844 return 1; 845 846 print_otag(h, TAG_DIV, "c", "Bd Bd-indent"); 847 848 if (n->tok == MDOC_Dl) 849 print_otag(h, TAG_CODE, "c", "Li"); 850 851 return 1; 852 } 853 854 static int 855 mdoc_sx_pre(MDOC_ARGS) 856 { 857 char *id; 858 859 id = html_make_id(n, 0); 860 print_otag(h, TAG_A, "cThR", "Sx", id); 861 free(id); 862 return 1; 863 } 864 865 static int 866 mdoc_bd_pre(MDOC_ARGS) 867 { 868 int comp, sv; 869 struct roff_node *nn; 870 871 if (n->type == ROFFT_HEAD) 872 return 0; 873 874 if (n->type == ROFFT_BLOCK) { 875 comp = n->norm->Bd.comp; 876 for (nn = n; nn && ! comp; nn = nn->parent) { 877 if (nn->type != ROFFT_BLOCK) 878 continue; 879 if (MDOC_Ss == nn->tok || MDOC_Sh == nn->tok) 880 comp = 1; 881 if (nn->prev) 882 break; 883 } 884 if ( ! comp) 885 print_paragraph(h); 886 return 1; 887 } 888 889 /* Handle the -offset argument. */ 890 891 if (n->norm->Bd.offs == NULL || 892 ! strcmp(n->norm->Bd.offs, "left")) 893 print_otag(h, TAG_DIV, "c", "Bd"); 894 else 895 print_otag(h, TAG_DIV, "c", "Bd Bd-indent"); 896 897 if (n->norm->Bd.type != DISP_unfilled && 898 n->norm->Bd.type != DISP_literal) 899 return 1; 900 901 print_otag(h, TAG_PRE, "c", "Li"); 902 903 /* This can be recursive: save & set our literal state. */ 904 905 sv = h->flags & HTML_LITERAL; 906 h->flags |= HTML_LITERAL; 907 908 for (nn = n->child; nn; nn = nn->next) { 909 print_mdoc_node(meta, nn, h); 910 /* 911 * If the printed node flushes its own line, then we 912 * needn't do it here as well. This is hacky, but the 913 * notion of selective eoln whitespace is pretty dumb 914 * anyway, so don't sweat it. 915 */ 916 switch (nn->tok) { 917 case ROFF_br: 918 case ROFF_sp: 919 case MDOC_Sm: 920 case MDOC_Bl: 921 case MDOC_D1: 922 case MDOC_Dl: 923 case MDOC_Lp: 924 case MDOC_Pp: 925 continue; 926 default: 927 break; 928 } 929 if (h->flags & HTML_NONEWLINE || 930 (nn->next && ! (nn->next->flags & NODE_LINE))) 931 continue; 932 else if (nn->next) 933 print_text(h, "\n"); 934 935 h->flags |= HTML_NOSPACE; 936 } 937 938 if (0 == sv) 939 h->flags &= ~HTML_LITERAL; 940 941 return 0; 942 } 943 944 static int 945 mdoc_pa_pre(MDOC_ARGS) 946 { 947 print_otag(h, TAG_SPAN, "cT", "Pa"); 948 return 1; 949 } 950 951 static int 952 mdoc_ad_pre(MDOC_ARGS) 953 { 954 print_otag(h, TAG_SPAN, "c", "Ad"); 955 return 1; 956 } 957 958 static int 959 mdoc_an_pre(MDOC_ARGS) 960 { 961 if (n->norm->An.auth == AUTH_split) { 962 h->flags &= ~HTML_NOSPLIT; 963 h->flags |= HTML_SPLIT; 964 return 0; 965 } 966 if (n->norm->An.auth == AUTH_nosplit) { 967 h->flags &= ~HTML_SPLIT; 968 h->flags |= HTML_NOSPLIT; 969 return 0; 970 } 971 972 if (h->flags & HTML_SPLIT) 973 print_otag(h, TAG_BR, ""); 974 975 if (n->sec == SEC_AUTHORS && ! (h->flags & HTML_NOSPLIT)) 976 h->flags |= HTML_SPLIT; 977 978 print_otag(h, TAG_SPAN, "cT", "An"); 979 return 1; 980 } 981 982 static int 983 mdoc_cd_pre(MDOC_ARGS) 984 { 985 synopsis_pre(h, n); 986 print_otag(h, TAG_CODE, "cT", "Cd"); 987 return 1; 988 } 989 990 static int 991 mdoc_dv_pre(MDOC_ARGS) 992 { 993 char *id; 994 995 if ((id = cond_id(n)) != NULL) 996 print_otag(h, TAG_A, "chR", "permalink", id); 997 print_otag(h, TAG_CODE, "cTi", "Dv", id); 998 return 1; 999 } 1000 1001 static int 1002 mdoc_ev_pre(MDOC_ARGS) 1003 { 1004 char *id; 1005 1006 if ((id = cond_id(n)) != NULL) 1007 print_otag(h, TAG_A, "chR", "permalink", id); 1008 print_otag(h, TAG_CODE, "cTi", "Ev", id); 1009 return 1; 1010 } 1011 1012 static int 1013 mdoc_er_pre(MDOC_ARGS) 1014 { 1015 char *id; 1016 1017 id = n->sec == SEC_ERRORS && 1018 (n->parent->tok == MDOC_It || 1019 (n->parent->tok == MDOC_Bq && 1020 n->parent->parent->parent->tok == MDOC_It)) ? 1021 html_make_id(n, 1) : NULL; 1022 1023 if (id != NULL) 1024 print_otag(h, TAG_A, "chR", "permalink", id); 1025 print_otag(h, TAG_CODE, "cTi", "Er", id); 1026 return 1; 1027 } 1028 1029 static int 1030 mdoc_fa_pre(MDOC_ARGS) 1031 { 1032 const struct roff_node *nn; 1033 struct tag *t; 1034 1035 if (n->parent->tok != MDOC_Fo) { 1036 print_otag(h, TAG_VAR, "cT", "Fa"); 1037 return 1; 1038 } 1039 1040 for (nn = n->child; nn; nn = nn->next) { 1041 t = print_otag(h, TAG_VAR, "cT", "Fa"); 1042 print_text(h, nn->string); 1043 print_tagq(h, t); 1044 if (nn->next) { 1045 h->flags |= HTML_NOSPACE; 1046 print_text(h, ","); 1047 } 1048 } 1049 1050 if (n->child && n->next && n->next->tok == MDOC_Fa) { 1051 h->flags |= HTML_NOSPACE; 1052 print_text(h, ","); 1053 } 1054 1055 return 0; 1056 } 1057 1058 static int 1059 mdoc_fd_pre(MDOC_ARGS) 1060 { 1061 struct tag *t; 1062 char *buf, *cp; 1063 1064 synopsis_pre(h, n); 1065 1066 if (NULL == (n = n->child)) 1067 return 0; 1068 1069 assert(n->type == ROFFT_TEXT); 1070 1071 if (strcmp(n->string, "#include")) { 1072 print_otag(h, TAG_CODE, "cT", "Fd"); 1073 return 1; 1074 } 1075 1076 print_otag(h, TAG_CODE, "cT", "In"); 1077 print_text(h, n->string); 1078 1079 if (NULL != (n = n->next)) { 1080 assert(n->type == ROFFT_TEXT); 1081 1082 if (h->base_includes) { 1083 cp = n->string; 1084 if (*cp == '<' || *cp == '"') 1085 cp++; 1086 buf = mandoc_strdup(cp); 1087 cp = strchr(buf, '\0') - 1; 1088 if (cp >= buf && (*cp == '>' || *cp == '"')) 1089 *cp = '\0'; 1090 t = print_otag(h, TAG_A, "cThI", "In", buf); 1091 free(buf); 1092 } else 1093 t = print_otag(h, TAG_A, "cT", "In"); 1094 1095 print_text(h, n->string); 1096 print_tagq(h, t); 1097 1098 n = n->next; 1099 } 1100 1101 for ( ; n; n = n->next) { 1102 assert(n->type == ROFFT_TEXT); 1103 print_text(h, n->string); 1104 } 1105 1106 return 0; 1107 } 1108 1109 static int 1110 mdoc_vt_pre(MDOC_ARGS) 1111 { 1112 if (n->type == ROFFT_BLOCK) { 1113 synopsis_pre(h, n); 1114 return 1; 1115 } else if (n->type == ROFFT_ELEM) { 1116 synopsis_pre(h, n); 1117 } else if (n->type == ROFFT_HEAD) 1118 return 0; 1119 1120 print_otag(h, TAG_VAR, "cT", "Vt"); 1121 return 1; 1122 } 1123 1124 static int 1125 mdoc_ft_pre(MDOC_ARGS) 1126 { 1127 synopsis_pre(h, n); 1128 print_otag(h, TAG_VAR, "cT", "Ft"); 1129 return 1; 1130 } 1131 1132 static int 1133 mdoc_fn_pre(MDOC_ARGS) 1134 { 1135 struct tag *t; 1136 char nbuf[BUFSIZ]; 1137 const char *sp, *ep; 1138 int sz, pretty; 1139 1140 pretty = NODE_SYNPRETTY & n->flags; 1141 synopsis_pre(h, n); 1142 1143 /* Split apart into type and name. */ 1144 assert(n->child->string); 1145 sp = n->child->string; 1146 1147 ep = strchr(sp, ' '); 1148 if (NULL != ep) { 1149 t = print_otag(h, TAG_VAR, "cT", "Ft"); 1150 1151 while (ep) { 1152 sz = MIN((int)(ep - sp), BUFSIZ - 1); 1153 (void)memcpy(nbuf, sp, (size_t)sz); 1154 nbuf[sz] = '\0'; 1155 print_text(h, nbuf); 1156 sp = ++ep; 1157 ep = strchr(sp, ' '); 1158 } 1159 print_tagq(h, t); 1160 } 1161 1162 t = print_otag(h, TAG_CODE, "cT", "Fn"); 1163 1164 if (sp) 1165 print_text(h, sp); 1166 1167 print_tagq(h, t); 1168 1169 h->flags |= HTML_NOSPACE; 1170 print_text(h, "("); 1171 h->flags |= HTML_NOSPACE; 1172 1173 for (n = n->child->next; n; n = n->next) { 1174 if (NODE_SYNPRETTY & n->flags) 1175 t = print_otag(h, TAG_VAR, "cTs", "Fa", 1176 "white-space", "nowrap"); 1177 else 1178 t = print_otag(h, TAG_VAR, "cT", "Fa"); 1179 print_text(h, n->string); 1180 print_tagq(h, t); 1181 if (n->next) { 1182 h->flags |= HTML_NOSPACE; 1183 print_text(h, ","); 1184 } 1185 } 1186 1187 h->flags |= HTML_NOSPACE; 1188 print_text(h, ")"); 1189 1190 if (pretty) { 1191 h->flags |= HTML_NOSPACE; 1192 print_text(h, ";"); 1193 } 1194 1195 return 0; 1196 } 1197 1198 static int 1199 mdoc_sm_pre(MDOC_ARGS) 1200 { 1201 1202 if (NULL == n->child) 1203 h->flags ^= HTML_NONOSPACE; 1204 else if (0 == strcmp("on", n->child->string)) 1205 h->flags &= ~HTML_NONOSPACE; 1206 else 1207 h->flags |= HTML_NONOSPACE; 1208 1209 if ( ! (HTML_NONOSPACE & h->flags)) 1210 h->flags &= ~HTML_NOSPACE; 1211 1212 return 0; 1213 } 1214 1215 static int 1216 mdoc_skip_pre(MDOC_ARGS) 1217 { 1218 1219 return 0; 1220 } 1221 1222 static int 1223 mdoc_pp_pre(MDOC_ARGS) 1224 { 1225 1226 print_paragraph(h); 1227 return 0; 1228 } 1229 1230 static int 1231 mdoc_lk_pre(MDOC_ARGS) 1232 { 1233 const struct roff_node *link, *descr, *punct; 1234 struct tag *t; 1235 1236 if ((link = n->child) == NULL) 1237 return 0; 1238 1239 /* Find beginning of trailing punctuation. */ 1240 punct = n->last; 1241 while (punct != link && punct->flags & NODE_DELIMC) 1242 punct = punct->prev; 1243 punct = punct->next; 1244 1245 /* Link target and link text. */ 1246 descr = link->next; 1247 if (descr == punct) 1248 descr = link; /* no text */ 1249 t = print_otag(h, TAG_A, "cTh", "Lk", link->string); 1250 do { 1251 if (descr->flags & (NODE_DELIMC | NODE_DELIMO)) 1252 h->flags |= HTML_NOSPACE; 1253 print_text(h, descr->string); 1254 descr = descr->next; 1255 } while (descr != punct); 1256 print_tagq(h, t); 1257 1258 /* Trailing punctuation. */ 1259 while (punct != NULL) { 1260 h->flags |= HTML_NOSPACE; 1261 print_text(h, punct->string); 1262 punct = punct->next; 1263 } 1264 return 0; 1265 } 1266 1267 static int 1268 mdoc_mt_pre(MDOC_ARGS) 1269 { 1270 struct tag *t; 1271 char *cp; 1272 1273 for (n = n->child; n; n = n->next) { 1274 assert(n->type == ROFFT_TEXT); 1275 1276 mandoc_asprintf(&cp, "mailto:%s", n->string); 1277 t = print_otag(h, TAG_A, "cTh", "Mt", cp); 1278 print_text(h, n->string); 1279 print_tagq(h, t); 1280 free(cp); 1281 } 1282 1283 return 0; 1284 } 1285 1286 static int 1287 mdoc_fo_pre(MDOC_ARGS) 1288 { 1289 struct tag *t; 1290 1291 if (n->type == ROFFT_BODY) { 1292 h->flags |= HTML_NOSPACE; 1293 print_text(h, "("); 1294 h->flags |= HTML_NOSPACE; 1295 return 1; 1296 } else if (n->type == ROFFT_BLOCK) { 1297 synopsis_pre(h, n); 1298 return 1; 1299 } 1300 1301 if (n->child == NULL) 1302 return 0; 1303 1304 assert(n->child->string); 1305 t = print_otag(h, TAG_CODE, "cT", "Fn"); 1306 print_text(h, n->child->string); 1307 print_tagq(h, t); 1308 return 0; 1309 } 1310 1311 static void 1312 mdoc_fo_post(MDOC_ARGS) 1313 { 1314 1315 if (n->type != ROFFT_BODY) 1316 return; 1317 h->flags |= HTML_NOSPACE; 1318 print_text(h, ")"); 1319 h->flags |= HTML_NOSPACE; 1320 print_text(h, ";"); 1321 } 1322 1323 static int 1324 mdoc_in_pre(MDOC_ARGS) 1325 { 1326 struct tag *t; 1327 1328 synopsis_pre(h, n); 1329 print_otag(h, TAG_CODE, "cT", "In"); 1330 1331 /* 1332 * The first argument of the `In' gets special treatment as 1333 * being a linked value. Subsequent values are printed 1334 * afterward. groff does similarly. This also handles the case 1335 * of no children. 1336 */ 1337 1338 if (NODE_SYNPRETTY & n->flags && NODE_LINE & n->flags) 1339 print_text(h, "#include"); 1340 1341 print_text(h, "<"); 1342 h->flags |= HTML_NOSPACE; 1343 1344 if (NULL != (n = n->child)) { 1345 assert(n->type == ROFFT_TEXT); 1346 1347 if (h->base_includes) 1348 t = print_otag(h, TAG_A, "cThI", "In", n->string); 1349 else 1350 t = print_otag(h, TAG_A, "cT", "In"); 1351 print_text(h, n->string); 1352 print_tagq(h, t); 1353 1354 n = n->next; 1355 } 1356 1357 h->flags |= HTML_NOSPACE; 1358 print_text(h, ">"); 1359 1360 for ( ; n; n = n->next) { 1361 assert(n->type == ROFFT_TEXT); 1362 print_text(h, n->string); 1363 } 1364 1365 return 0; 1366 } 1367 1368 static int 1369 mdoc_ic_pre(MDOC_ARGS) 1370 { 1371 char *id; 1372 1373 if ((id = cond_id(n)) != NULL) 1374 print_otag(h, TAG_A, "chR", "permalink", id); 1375 print_otag(h, TAG_CODE, "cTi", "Ic", id); 1376 return 1; 1377 } 1378 1379 static int 1380 mdoc_va_pre(MDOC_ARGS) 1381 { 1382 print_otag(h, TAG_VAR, "cT", "Va"); 1383 return 1; 1384 } 1385 1386 static int 1387 mdoc_ap_pre(MDOC_ARGS) 1388 { 1389 1390 h->flags |= HTML_NOSPACE; 1391 print_text(h, "\\(aq"); 1392 h->flags |= HTML_NOSPACE; 1393 return 1; 1394 } 1395 1396 static int 1397 mdoc_bf_pre(MDOC_ARGS) 1398 { 1399 const char *cattr; 1400 1401 if (n->type == ROFFT_HEAD) 1402 return 0; 1403 else if (n->type != ROFFT_BODY) 1404 return 1; 1405 1406 if (FONT_Em == n->norm->Bf.font) 1407 cattr = "Bf Em"; 1408 else if (FONT_Sy == n->norm->Bf.font) 1409 cattr = "Bf Sy"; 1410 else if (FONT_Li == n->norm->Bf.font) 1411 cattr = "Bf Li"; 1412 else 1413 cattr = "Bf No"; 1414 1415 /* Cannot use TAG_SPAN because it may contain blocks. */ 1416 print_otag(h, TAG_DIV, "c", cattr); 1417 return 1; 1418 } 1419 1420 static int 1421 mdoc_ms_pre(MDOC_ARGS) 1422 { 1423 char *id; 1424 1425 if ((id = cond_id(n)) != NULL) 1426 print_otag(h, TAG_A, "chR", "permalink", id); 1427 print_otag(h, TAG_SPAN, "cTi", "Ms", id); 1428 return 1; 1429 } 1430 1431 static int 1432 mdoc_igndelim_pre(MDOC_ARGS) 1433 { 1434 1435 h->flags |= HTML_IGNDELIM; 1436 return 1; 1437 } 1438 1439 static void 1440 mdoc_pf_post(MDOC_ARGS) 1441 { 1442 1443 if ( ! (n->next == NULL || n->next->flags & NODE_LINE)) 1444 h->flags |= HTML_NOSPACE; 1445 } 1446 1447 static int 1448 mdoc_rs_pre(MDOC_ARGS) 1449 { 1450 if (n->type != ROFFT_BLOCK) 1451 return 1; 1452 1453 if (n->prev && SEC_SEE_ALSO == n->sec) 1454 print_paragraph(h); 1455 1456 print_otag(h, TAG_CITE, "cT", "Rs"); 1457 return 1; 1458 } 1459 1460 static int 1461 mdoc_no_pre(MDOC_ARGS) 1462 { 1463 char *id; 1464 1465 if ((id = cond_id(n)) != NULL) 1466 print_otag(h, TAG_A, "chR", "permalink", id); 1467 print_otag(h, TAG_SPAN, "ci", "No", id); 1468 return 1; 1469 } 1470 1471 static int 1472 mdoc_li_pre(MDOC_ARGS) 1473 { 1474 char *id; 1475 1476 if ((id = cond_id(n)) != NULL) 1477 print_otag(h, TAG_A, "chR", "permalink", id); 1478 print_otag(h, TAG_CODE, "ci", "Li", id); 1479 return 1; 1480 } 1481 1482 static int 1483 mdoc_sy_pre(MDOC_ARGS) 1484 { 1485 print_otag(h, TAG_B, "cT", "Sy"); 1486 return 1; 1487 } 1488 1489 static int 1490 mdoc_lb_pre(MDOC_ARGS) 1491 { 1492 if (SEC_LIBRARY == n->sec && NODE_LINE & n->flags && n->prev) 1493 print_otag(h, TAG_BR, ""); 1494 1495 print_otag(h, TAG_SPAN, "cT", "Lb"); 1496 return 1; 1497 } 1498 1499 static int 1500 mdoc__x_pre(MDOC_ARGS) 1501 { 1502 const char *cattr; 1503 enum htmltag t; 1504 1505 t = TAG_SPAN; 1506 1507 switch (n->tok) { 1508 case MDOC__A: 1509 cattr = "RsA"; 1510 if (n->prev && MDOC__A == n->prev->tok) 1511 if (NULL == n->next || MDOC__A != n->next->tok) 1512 print_text(h, "and"); 1513 break; 1514 case MDOC__B: 1515 t = TAG_I; 1516 cattr = "RsB"; 1517 break; 1518 case MDOC__C: 1519 cattr = "RsC"; 1520 break; 1521 case MDOC__D: 1522 cattr = "RsD"; 1523 break; 1524 case MDOC__I: 1525 t = TAG_I; 1526 cattr = "RsI"; 1527 break; 1528 case MDOC__J: 1529 t = TAG_I; 1530 cattr = "RsJ"; 1531 break; 1532 case MDOC__N: 1533 cattr = "RsN"; 1534 break; 1535 case MDOC__O: 1536 cattr = "RsO"; 1537 break; 1538 case MDOC__P: 1539 cattr = "RsP"; 1540 break; 1541 case MDOC__Q: 1542 cattr = "RsQ"; 1543 break; 1544 case MDOC__R: 1545 cattr = "RsR"; 1546 break; 1547 case MDOC__T: 1548 cattr = "RsT"; 1549 break; 1550 case MDOC__U: 1551 print_otag(h, TAG_A, "ch", "RsU", n->child->string); 1552 return 1; 1553 case MDOC__V: 1554 cattr = "RsV"; 1555 break; 1556 default: 1557 abort(); 1558 } 1559 1560 print_otag(h, t, "c", cattr); 1561 return 1; 1562 } 1563 1564 static void 1565 mdoc__x_post(MDOC_ARGS) 1566 { 1567 1568 if (MDOC__A == n->tok && n->next && MDOC__A == n->next->tok) 1569 if (NULL == n->next->next || MDOC__A != n->next->next->tok) 1570 if (NULL == n->prev || MDOC__A != n->prev->tok) 1571 return; 1572 1573 /* TODO: %U */ 1574 1575 if (NULL == n->parent || MDOC_Rs != n->parent->tok) 1576 return; 1577 1578 h->flags |= HTML_NOSPACE; 1579 print_text(h, n->next ? "," : "."); 1580 } 1581 1582 static int 1583 mdoc_bk_pre(MDOC_ARGS) 1584 { 1585 1586 switch (n->type) { 1587 case ROFFT_BLOCK: 1588 break; 1589 case ROFFT_HEAD: 1590 return 0; 1591 case ROFFT_BODY: 1592 if (n->parent->args != NULL || n->prev->child == NULL) 1593 h->flags |= HTML_PREKEEP; 1594 break; 1595 default: 1596 abort(); 1597 } 1598 1599 return 1; 1600 } 1601 1602 static void 1603 mdoc_bk_post(MDOC_ARGS) 1604 { 1605 1606 if (n->type == ROFFT_BODY) 1607 h->flags &= ~(HTML_KEEP | HTML_PREKEEP); 1608 } 1609 1610 static int 1611 mdoc_quote_pre(MDOC_ARGS) 1612 { 1613 if (n->type != ROFFT_BODY) 1614 return 1; 1615 1616 switch (n->tok) { 1617 case MDOC_Ao: 1618 case MDOC_Aq: 1619 print_text(h, n->child != NULL && n->child->next == NULL && 1620 n->child->tok == MDOC_Mt ? "<" : "\\(la"); 1621 break; 1622 case MDOC_Bro: 1623 case MDOC_Brq: 1624 print_text(h, "\\(lC"); 1625 break; 1626 case MDOC_Bo: 1627 case MDOC_Bq: 1628 print_text(h, "\\(lB"); 1629 break; 1630 case MDOC_Oo: 1631 case MDOC_Op: 1632 print_text(h, "\\(lB"); 1633 h->flags |= HTML_NOSPACE; 1634 /* Cannot use TAG_SPAN because it may contain blocks. */ 1635 print_otag(h, TAG_IDIV, "c", "Op"); 1636 break; 1637 case MDOC_En: 1638 if (NULL == n->norm->Es || 1639 NULL == n->norm->Es->child) 1640 return 1; 1641 print_text(h, n->norm->Es->child->string); 1642 break; 1643 case MDOC_Do: 1644 case MDOC_Dq: 1645 case MDOC_Qo: 1646 case MDOC_Qq: 1647 print_text(h, "\\(lq"); 1648 break; 1649 case MDOC_Po: 1650 case MDOC_Pq: 1651 print_text(h, "("); 1652 break; 1653 case MDOC_Ql: 1654 print_text(h, "\\(oq"); 1655 h->flags |= HTML_NOSPACE; 1656 print_otag(h, TAG_CODE, "c", "Li"); 1657 break; 1658 case MDOC_So: 1659 case MDOC_Sq: 1660 print_text(h, "\\(oq"); 1661 break; 1662 default: 1663 abort(); 1664 } 1665 1666 h->flags |= HTML_NOSPACE; 1667 return 1; 1668 } 1669 1670 static void 1671 mdoc_quote_post(MDOC_ARGS) 1672 { 1673 1674 if (n->type != ROFFT_BODY && n->type != ROFFT_ELEM) 1675 return; 1676 1677 h->flags |= HTML_NOSPACE; 1678 1679 switch (n->tok) { 1680 case MDOC_Ao: 1681 case MDOC_Aq: 1682 print_text(h, n->child != NULL && n->child->next == NULL && 1683 n->child->tok == MDOC_Mt ? ">" : "\\(ra"); 1684 break; 1685 case MDOC_Bro: 1686 case MDOC_Brq: 1687 print_text(h, "\\(rC"); 1688 break; 1689 case MDOC_Oo: 1690 case MDOC_Op: 1691 case MDOC_Bo: 1692 case MDOC_Bq: 1693 print_text(h, "\\(rB"); 1694 break; 1695 case MDOC_En: 1696 if (n->norm->Es == NULL || 1697 n->norm->Es->child == NULL || 1698 n->norm->Es->child->next == NULL) 1699 h->flags &= ~HTML_NOSPACE; 1700 else 1701 print_text(h, n->norm->Es->child->next->string); 1702 break; 1703 case MDOC_Qo: 1704 case MDOC_Qq: 1705 case MDOC_Do: 1706 case MDOC_Dq: 1707 print_text(h, "\\(rq"); 1708 break; 1709 case MDOC_Po: 1710 case MDOC_Pq: 1711 print_text(h, ")"); 1712 break; 1713 case MDOC_Ql: 1714 case MDOC_So: 1715 case MDOC_Sq: 1716 print_text(h, "\\(cq"); 1717 break; 1718 default: 1719 abort(); 1720 } 1721 } 1722 1723 static int 1724 mdoc_eo_pre(MDOC_ARGS) 1725 { 1726 1727 if (n->type != ROFFT_BODY) 1728 return 1; 1729 1730 if (n->end == ENDBODY_NOT && 1731 n->parent->head->child == NULL && 1732 n->child != NULL && 1733 n->child->end != ENDBODY_NOT) 1734 print_text(h, "\\&"); 1735 else if (n->end != ENDBODY_NOT ? n->child != NULL : 1736 n->parent->head->child != NULL && (n->child != NULL || 1737 (n->parent->tail != NULL && n->parent->tail->child != NULL))) 1738 h->flags |= HTML_NOSPACE; 1739 return 1; 1740 } 1741 1742 static void 1743 mdoc_eo_post(MDOC_ARGS) 1744 { 1745 int body, tail; 1746 1747 if (n->type != ROFFT_BODY) 1748 return; 1749 1750 if (n->end != ENDBODY_NOT) { 1751 h->flags &= ~HTML_NOSPACE; 1752 return; 1753 } 1754 1755 body = n->child != NULL || n->parent->head->child != NULL; 1756 tail = n->parent->tail != NULL && n->parent->tail->child != NULL; 1757 1758 if (body && tail) 1759 h->flags |= HTML_NOSPACE; 1760 else if ( ! tail) 1761 h->flags &= ~HTML_NOSPACE; 1762 } 1763