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