1 /* $Id: mdoc_term.c,v 1.372 2019/01/04 03:39:01 schwarze Exp $ */ 2 /* 3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv> 4 * Copyright (c) 2010, 2012-2019 Ingo Schwarze <schwarze@openbsd.org> 5 * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 #include "config.h" 20 21 #include <sys/types.h> 22 23 #include <assert.h> 24 #include <ctype.h> 25 #include <limits.h> 26 #include <stdint.h> 27 #include <stdio.h> 28 #include <stdlib.h> 29 #include <string.h> 30 31 #include "mandoc_aux.h" 32 #include "roff.h" 33 #include "mdoc.h" 34 #include "out.h" 35 #include "term.h" 36 #include "tag.h" 37 #include "main.h" 38 39 struct termpair { 40 struct termpair *ppair; 41 int count; 42 }; 43 44 #define DECL_ARGS struct termp *p, \ 45 struct termpair *pair, \ 46 const struct roff_meta *meta, \ 47 struct roff_node *n 48 49 struct mdoc_term_act { 50 int (*pre)(DECL_ARGS); 51 void (*post)(DECL_ARGS); 52 }; 53 54 static int a2width(const struct termp *, const char *); 55 56 static void print_bvspace(struct termp *, 57 const struct roff_node *, 58 const struct roff_node *); 59 static void print_mdoc_node(DECL_ARGS); 60 static void print_mdoc_nodelist(DECL_ARGS); 61 static void print_mdoc_head(struct termp *, const struct roff_meta *); 62 static void print_mdoc_foot(struct termp *, const struct roff_meta *); 63 static void synopsis_pre(struct termp *, 64 const struct roff_node *); 65 66 static void termp____post(DECL_ARGS); 67 static void termp__t_post(DECL_ARGS); 68 static void termp_bd_post(DECL_ARGS); 69 static void termp_bk_post(DECL_ARGS); 70 static void termp_bl_post(DECL_ARGS); 71 static void termp_eo_post(DECL_ARGS); 72 static void termp_fd_post(DECL_ARGS); 73 static void termp_fo_post(DECL_ARGS); 74 static void termp_in_post(DECL_ARGS); 75 static void termp_it_post(DECL_ARGS); 76 static void termp_lb_post(DECL_ARGS); 77 static void termp_nm_post(DECL_ARGS); 78 static void termp_pf_post(DECL_ARGS); 79 static void termp_quote_post(DECL_ARGS); 80 static void termp_sh_post(DECL_ARGS); 81 static void termp_ss_post(DECL_ARGS); 82 static void termp_xx_post(DECL_ARGS); 83 84 static int termp__a_pre(DECL_ARGS); 85 static int termp__t_pre(DECL_ARGS); 86 static int termp_abort_pre(DECL_ARGS); 87 static int termp_an_pre(DECL_ARGS); 88 static int termp_ap_pre(DECL_ARGS); 89 static int termp_bd_pre(DECL_ARGS); 90 static int termp_bf_pre(DECL_ARGS); 91 static int termp_bk_pre(DECL_ARGS); 92 static int termp_bl_pre(DECL_ARGS); 93 static int termp_bold_pre(DECL_ARGS); 94 static int termp_cd_pre(DECL_ARGS); 95 static int termp_d1_pre(DECL_ARGS); 96 static int termp_eo_pre(DECL_ARGS); 97 static int termp_em_pre(DECL_ARGS); 98 static int termp_er_pre(DECL_ARGS); 99 static int termp_ex_pre(DECL_ARGS); 100 static int termp_fa_pre(DECL_ARGS); 101 static int termp_fd_pre(DECL_ARGS); 102 static int termp_fl_pre(DECL_ARGS); 103 static int termp_fn_pre(DECL_ARGS); 104 static int termp_fo_pre(DECL_ARGS); 105 static int termp_ft_pre(DECL_ARGS); 106 static int termp_in_pre(DECL_ARGS); 107 static int termp_it_pre(DECL_ARGS); 108 static int termp_li_pre(DECL_ARGS); 109 static int termp_lk_pre(DECL_ARGS); 110 static int termp_nd_pre(DECL_ARGS); 111 static int termp_nm_pre(DECL_ARGS); 112 static int termp_ns_pre(DECL_ARGS); 113 static int termp_quote_pre(DECL_ARGS); 114 static int termp_rs_pre(DECL_ARGS); 115 static int termp_sh_pre(DECL_ARGS); 116 static int termp_skip_pre(DECL_ARGS); 117 static int termp_sm_pre(DECL_ARGS); 118 static int termp_pp_pre(DECL_ARGS); 119 static int termp_ss_pre(DECL_ARGS); 120 static int termp_sy_pre(DECL_ARGS); 121 static int termp_tag_pre(DECL_ARGS); 122 static int termp_under_pre(DECL_ARGS); 123 static int termp_vt_pre(DECL_ARGS); 124 static int termp_xr_pre(DECL_ARGS); 125 static int termp_xx_pre(DECL_ARGS); 126 127 static const struct mdoc_term_act mdoc_term_acts[MDOC_MAX - MDOC_Dd] = { 128 { NULL, NULL }, /* Dd */ 129 { NULL, NULL }, /* Dt */ 130 { NULL, NULL }, /* Os */ 131 { termp_sh_pre, termp_sh_post }, /* Sh */ 132 { termp_ss_pre, termp_ss_post }, /* Ss */ 133 { termp_pp_pre, NULL }, /* Pp */ 134 { termp_d1_pre, termp_bl_post }, /* D1 */ 135 { termp_d1_pre, termp_bl_post }, /* Dl */ 136 { termp_bd_pre, termp_bd_post }, /* Bd */ 137 { NULL, NULL }, /* Ed */ 138 { termp_bl_pre, termp_bl_post }, /* Bl */ 139 { NULL, NULL }, /* El */ 140 { termp_it_pre, termp_it_post }, /* It */ 141 { termp_under_pre, NULL }, /* Ad */ 142 { termp_an_pre, NULL }, /* An */ 143 { termp_ap_pre, NULL }, /* Ap */ 144 { termp_under_pre, NULL }, /* Ar */ 145 { termp_cd_pre, NULL }, /* Cd */ 146 { termp_bold_pre, NULL }, /* Cm */ 147 { termp_li_pre, NULL }, /* Dv */ 148 { termp_er_pre, NULL }, /* Er */ 149 { termp_tag_pre, NULL }, /* Ev */ 150 { termp_ex_pre, NULL }, /* Ex */ 151 { termp_fa_pre, NULL }, /* Fa */ 152 { termp_fd_pre, termp_fd_post }, /* Fd */ 153 { termp_fl_pre, NULL }, /* Fl */ 154 { termp_fn_pre, NULL }, /* Fn */ 155 { termp_ft_pre, NULL }, /* Ft */ 156 { termp_bold_pre, NULL }, /* Ic */ 157 { termp_in_pre, termp_in_post }, /* In */ 158 { termp_li_pre, NULL }, /* Li */ 159 { termp_nd_pre, NULL }, /* Nd */ 160 { termp_nm_pre, termp_nm_post }, /* Nm */ 161 { termp_quote_pre, termp_quote_post }, /* Op */ 162 { termp_abort_pre, NULL }, /* Ot */ 163 { termp_under_pre, NULL }, /* Pa */ 164 { termp_ex_pre, NULL }, /* Rv */ 165 { NULL, NULL }, /* St */ 166 { termp_under_pre, NULL }, /* Va */ 167 { termp_vt_pre, NULL }, /* Vt */ 168 { termp_xr_pre, NULL }, /* Xr */ 169 { termp__a_pre, termp____post }, /* %A */ 170 { termp_under_pre, termp____post }, /* %B */ 171 { NULL, termp____post }, /* %D */ 172 { termp_under_pre, termp____post }, /* %I */ 173 { termp_under_pre, termp____post }, /* %J */ 174 { NULL, termp____post }, /* %N */ 175 { NULL, termp____post }, /* %O */ 176 { NULL, termp____post }, /* %P */ 177 { NULL, termp____post }, /* %R */ 178 { termp__t_pre, termp__t_post }, /* %T */ 179 { NULL, termp____post }, /* %V */ 180 { NULL, NULL }, /* Ac */ 181 { termp_quote_pre, termp_quote_post }, /* Ao */ 182 { termp_quote_pre, termp_quote_post }, /* Aq */ 183 { NULL, NULL }, /* At */ 184 { NULL, NULL }, /* Bc */ 185 { termp_bf_pre, NULL }, /* Bf */ 186 { termp_quote_pre, termp_quote_post }, /* Bo */ 187 { termp_quote_pre, termp_quote_post }, /* Bq */ 188 { termp_xx_pre, termp_xx_post }, /* Bsx */ 189 { NULL, NULL }, /* Bx */ 190 { termp_skip_pre, NULL }, /* Db */ 191 { NULL, NULL }, /* Dc */ 192 { termp_quote_pre, termp_quote_post }, /* Do */ 193 { termp_quote_pre, termp_quote_post }, /* Dq */ 194 { NULL, NULL }, /* Ec */ /* FIXME: no space */ 195 { NULL, NULL }, /* Ef */ 196 { termp_em_pre, NULL }, /* Em */ 197 { termp_eo_pre, termp_eo_post }, /* Eo */ 198 { termp_xx_pre, termp_xx_post }, /* Fx */ 199 { termp_bold_pre, NULL }, /* Ms */ 200 { termp_li_pre, NULL }, /* No */ 201 { termp_ns_pre, NULL }, /* Ns */ 202 { termp_xx_pre, termp_xx_post }, /* Nx */ 203 { termp_xx_pre, termp_xx_post }, /* Ox */ 204 { NULL, NULL }, /* Pc */ 205 { NULL, termp_pf_post }, /* Pf */ 206 { termp_quote_pre, termp_quote_post }, /* Po */ 207 { termp_quote_pre, termp_quote_post }, /* Pq */ 208 { NULL, NULL }, /* Qc */ 209 { termp_quote_pre, termp_quote_post }, /* Ql */ 210 { termp_quote_pre, termp_quote_post }, /* Qo */ 211 { termp_quote_pre, termp_quote_post }, /* Qq */ 212 { NULL, NULL }, /* Re */ 213 { termp_rs_pre, NULL }, /* Rs */ 214 { NULL, NULL }, /* Sc */ 215 { termp_quote_pre, termp_quote_post }, /* So */ 216 { termp_quote_pre, termp_quote_post }, /* Sq */ 217 { termp_sm_pre, NULL }, /* Sm */ 218 { termp_under_pre, NULL }, /* Sx */ 219 { termp_sy_pre, NULL }, /* Sy */ 220 { NULL, NULL }, /* Tn */ 221 { termp_xx_pre, termp_xx_post }, /* Ux */ 222 { NULL, NULL }, /* Xc */ 223 { NULL, NULL }, /* Xo */ 224 { termp_fo_pre, termp_fo_post }, /* Fo */ 225 { NULL, NULL }, /* Fc */ 226 { termp_quote_pre, termp_quote_post }, /* Oo */ 227 { NULL, NULL }, /* Oc */ 228 { termp_bk_pre, termp_bk_post }, /* Bk */ 229 { NULL, NULL }, /* Ek */ 230 { NULL, NULL }, /* Bt */ 231 { NULL, NULL }, /* Hf */ 232 { termp_under_pre, NULL }, /* Fr */ 233 { NULL, NULL }, /* Ud */ 234 { NULL, termp_lb_post }, /* Lb */ 235 { termp_abort_pre, NULL }, /* Lp */ 236 { termp_lk_pre, NULL }, /* Lk */ 237 { termp_under_pre, NULL }, /* Mt */ 238 { termp_quote_pre, termp_quote_post }, /* Brq */ 239 { termp_quote_pre, termp_quote_post }, /* Bro */ 240 { NULL, NULL }, /* Brc */ 241 { NULL, termp____post }, /* %C */ 242 { termp_skip_pre, NULL }, /* Es */ 243 { termp_quote_pre, termp_quote_post }, /* En */ 244 { termp_xx_pre, termp_xx_post }, /* Dx */ 245 { NULL, termp____post }, /* %Q */ 246 { NULL, termp____post }, /* %U */ 247 { NULL, NULL }, /* Ta */ 248 }; 249 250 static int fn_prio; 251 252 253 void 254 terminal_mdoc(void *arg, const struct roff_meta *mdoc) 255 { 256 struct roff_node *n; 257 struct termp *p; 258 size_t save_defindent; 259 260 p = (struct termp *)arg; 261 p->tcol->rmargin = p->maxrmargin = p->defrmargin; 262 term_tab_set(p, NULL); 263 term_tab_set(p, "T"); 264 term_tab_set(p, ".5i"); 265 266 n = mdoc->first->child; 267 if (p->synopsisonly) { 268 while (n != NULL) { 269 if (n->tok == MDOC_Sh && n->sec == SEC_SYNOPSIS) { 270 if (n->child->next->child != NULL) 271 print_mdoc_nodelist(p, NULL, 272 mdoc, n->child->next->child); 273 term_newln(p); 274 break; 275 } 276 n = n->next; 277 } 278 } else { 279 save_defindent = p->defindent; 280 if (p->defindent == 0) 281 p->defindent = 5; 282 term_begin(p, print_mdoc_head, print_mdoc_foot, mdoc); 283 while (n != NULL && 284 (n->type == ROFFT_COMMENT || 285 n->flags & NODE_NOPRT)) 286 n = n->next; 287 if (n != NULL) { 288 if (n->tok != MDOC_Sh) 289 term_vspace(p); 290 print_mdoc_nodelist(p, NULL, mdoc, n); 291 } 292 term_end(p); 293 p->defindent = save_defindent; 294 } 295 } 296 297 static void 298 print_mdoc_nodelist(DECL_ARGS) 299 { 300 301 while (n != NULL) { 302 print_mdoc_node(p, pair, meta, n); 303 n = n->next; 304 } 305 } 306 307 static void 308 print_mdoc_node(DECL_ARGS) 309 { 310 const struct mdoc_term_act *act; 311 struct termpair npair; 312 size_t offset, rmargin; 313 int chld; 314 315 /* 316 * In no-fill mode, break the output line at the beginning 317 * of new input lines except after \c, and nowhere else. 318 */ 319 320 if (n->flags & NODE_NOFILL) { 321 if (n->flags & NODE_LINE && 322 (p->flags & TERMP_NONEWLINE) == 0) 323 term_newln(p); 324 p->flags |= TERMP_BRNEVER; 325 } else 326 p->flags &= ~TERMP_BRNEVER; 327 328 if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT) 329 return; 330 331 chld = 1; 332 offset = p->tcol->offset; 333 rmargin = p->tcol->rmargin; 334 n->flags &= ~NODE_ENDED; 335 n->prev_font = p->fonti; 336 337 memset(&npair, 0, sizeof(struct termpair)); 338 npair.ppair = pair; 339 340 /* 341 * Keeps only work until the end of a line. If a keep was 342 * invoked in a prior line, revert it to PREKEEP. 343 */ 344 345 if (p->flags & TERMP_KEEP && n->flags & NODE_LINE) { 346 p->flags &= ~TERMP_KEEP; 347 p->flags |= TERMP_PREKEEP; 348 } 349 350 /* 351 * After the keep flags have been set up, we may now 352 * produce output. Note that some pre-handlers do so. 353 */ 354 355 switch (n->type) { 356 case ROFFT_TEXT: 357 if (n->flags & NODE_LINE) { 358 switch (*n->string) { 359 case '\0': 360 if (p->flags & TERMP_NONEWLINE) 361 term_newln(p); 362 else 363 term_vspace(p); 364 return; 365 case ' ': 366 if ((p->flags & TERMP_NONEWLINE) == 0) 367 term_newln(p); 368 break; 369 default: 370 break; 371 } 372 } 373 if (NODE_DELIMC & n->flags) 374 p->flags |= TERMP_NOSPACE; 375 term_word(p, n->string); 376 if (NODE_DELIMO & n->flags) 377 p->flags |= TERMP_NOSPACE; 378 break; 379 case ROFFT_EQN: 380 if ( ! (n->flags & NODE_LINE)) 381 p->flags |= TERMP_NOSPACE; 382 term_eqn(p, n->eqn); 383 if (n->next != NULL && ! (n->next->flags & NODE_LINE)) 384 p->flags |= TERMP_NOSPACE; 385 break; 386 case ROFFT_TBL: 387 if (p->tbl.cols == NULL) 388 term_newln(p); 389 term_tbl(p, n->span); 390 break; 391 default: 392 if (n->tok < ROFF_MAX) { 393 roff_term_pre(p, n); 394 return; 395 } 396 assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX); 397 act = mdoc_term_acts + (n->tok - MDOC_Dd); 398 if (act->pre != NULL && 399 (n->end == ENDBODY_NOT || n->child != NULL)) 400 chld = (*act->pre)(p, &npair, meta, n); 401 break; 402 } 403 404 if (chld && n->child) 405 print_mdoc_nodelist(p, &npair, meta, n->child); 406 407 term_fontpopq(p, 408 (ENDBODY_NOT == n->end ? n : n->body)->prev_font); 409 410 switch (n->type) { 411 case ROFFT_TEXT: 412 break; 413 case ROFFT_TBL: 414 break; 415 case ROFFT_EQN: 416 break; 417 default: 418 if (act->post == NULL || n->flags & NODE_ENDED) 419 break; 420 (void)(*act->post)(p, &npair, meta, n); 421 422 /* 423 * Explicit end tokens not only call the post 424 * handler, but also tell the respective block 425 * that it must not call the post handler again. 426 */ 427 if (ENDBODY_NOT != n->end) 428 n->body->flags |= NODE_ENDED; 429 break; 430 } 431 432 if (NODE_EOS & n->flags) 433 p->flags |= TERMP_SENTENCE; 434 435 if (n->type != ROFFT_TEXT) 436 p->tcol->offset = offset; 437 p->tcol->rmargin = rmargin; 438 } 439 440 static void 441 print_mdoc_foot(struct termp *p, const struct roff_meta *meta) 442 { 443 size_t sz; 444 445 term_fontrepl(p, TERMFONT_NONE); 446 447 /* 448 * Output the footer in new-groff style, that is, three columns 449 * with the middle being the manual date and flanking columns 450 * being the operating system: 451 * 452 * SYSTEM DATE SYSTEM 453 */ 454 455 term_vspace(p); 456 457 p->tcol->offset = 0; 458 sz = term_strlen(p, meta->date); 459 p->tcol->rmargin = p->maxrmargin > sz ? 460 (p->maxrmargin + term_len(p, 1) - sz) / 2 : 0; 461 p->trailspace = 1; 462 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK; 463 464 term_word(p, meta->os); 465 term_flushln(p); 466 467 p->tcol->offset = p->tcol->rmargin; 468 sz = term_strlen(p, meta->os); 469 p->tcol->rmargin = p->maxrmargin > sz ? p->maxrmargin - sz : 0; 470 p->flags |= TERMP_NOSPACE; 471 472 term_word(p, meta->date); 473 term_flushln(p); 474 475 p->tcol->offset = p->tcol->rmargin; 476 p->tcol->rmargin = p->maxrmargin; 477 p->trailspace = 0; 478 p->flags &= ~TERMP_NOBREAK; 479 p->flags |= TERMP_NOSPACE; 480 481 term_word(p, meta->os); 482 term_flushln(p); 483 484 p->tcol->offset = 0; 485 p->tcol->rmargin = p->maxrmargin; 486 p->flags = 0; 487 } 488 489 static void 490 print_mdoc_head(struct termp *p, const struct roff_meta *meta) 491 { 492 char *volume, *title; 493 size_t vollen, titlen; 494 495 /* 496 * The header is strange. It has three components, which are 497 * really two with the first duplicated. It goes like this: 498 * 499 * IDENTIFIER TITLE IDENTIFIER 500 * 501 * The IDENTIFIER is NAME(SECTION), which is the command-name 502 * (if given, or "unknown" if not) followed by the manual page 503 * section. These are given in `Dt'. The TITLE is a free-form 504 * string depending on the manual volume. If not specified, it 505 * switches on the manual section. 506 */ 507 508 assert(meta->vol); 509 if (NULL == meta->arch) 510 volume = mandoc_strdup(meta->vol); 511 else 512 mandoc_asprintf(&volume, "%s (%s)", 513 meta->vol, meta->arch); 514 vollen = term_strlen(p, volume); 515 516 if (NULL == meta->msec) 517 title = mandoc_strdup(meta->title); 518 else 519 mandoc_asprintf(&title, "%s(%s)", 520 meta->title, meta->msec); 521 titlen = term_strlen(p, title); 522 523 p->flags |= TERMP_NOBREAK | TERMP_NOSPACE; 524 p->trailspace = 1; 525 p->tcol->offset = 0; 526 p->tcol->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ? 527 (p->maxrmargin - vollen + term_len(p, 1)) / 2 : 528 vollen < p->maxrmargin ? p->maxrmargin - vollen : 0; 529 530 term_word(p, title); 531 term_flushln(p); 532 533 p->flags |= TERMP_NOSPACE; 534 p->tcol->offset = p->tcol->rmargin; 535 p->tcol->rmargin = p->tcol->offset + vollen + titlen < 536 p->maxrmargin ? p->maxrmargin - titlen : p->maxrmargin; 537 538 term_word(p, volume); 539 term_flushln(p); 540 541 p->flags &= ~TERMP_NOBREAK; 542 p->trailspace = 0; 543 if (p->tcol->rmargin + titlen <= p->maxrmargin) { 544 p->flags |= TERMP_NOSPACE; 545 p->tcol->offset = p->tcol->rmargin; 546 p->tcol->rmargin = p->maxrmargin; 547 term_word(p, title); 548 term_flushln(p); 549 } 550 551 p->flags &= ~TERMP_NOSPACE; 552 p->tcol->offset = 0; 553 p->tcol->rmargin = p->maxrmargin; 554 free(title); 555 free(volume); 556 } 557 558 static int 559 a2width(const struct termp *p, const char *v) 560 { 561 struct roffsu su; 562 const char *end; 563 564 end = a2roffsu(v, &su, SCALE_MAX); 565 if (end == NULL || *end != '\0') { 566 SCALE_HS_INIT(&su, term_strlen(p, v)); 567 su.scale /= term_strlen(p, "0"); 568 } 569 return term_hen(p, &su); 570 } 571 572 /* 573 * Determine how much space to print out before block elements of `It' 574 * (and thus `Bl') and `Bd'. And then go ahead and print that space, 575 * too. 576 */ 577 static void 578 print_bvspace(struct termp *p, 579 const struct roff_node *bl, 580 const struct roff_node *n) 581 { 582 const struct roff_node *nn; 583 584 assert(n); 585 586 term_newln(p); 587 588 if (MDOC_Bd == bl->tok && bl->norm->Bd.comp) 589 return; 590 if (MDOC_Bl == bl->tok && bl->norm->Bl.comp) 591 return; 592 593 /* Do not vspace directly after Ss/Sh. */ 594 595 nn = n; 596 while (nn->prev != NULL && 597 (nn->prev->type == ROFFT_COMMENT || 598 nn->prev->flags & NODE_NOPRT)) 599 nn = nn->prev; 600 while (nn->prev == NULL) { 601 do { 602 nn = nn->parent; 603 if (nn->type == ROFFT_ROOT) 604 return; 605 } while (nn->type != ROFFT_BLOCK); 606 if (nn->tok == MDOC_Sh || nn->tok == MDOC_Ss) 607 return; 608 if (nn->tok == MDOC_It && 609 nn->parent->parent->norm->Bl.type != LIST_item) 610 break; 611 } 612 613 /* A `-column' does not assert vspace within the list. */ 614 615 if (MDOC_Bl == bl->tok && LIST_column == bl->norm->Bl.type) 616 if (n->prev && MDOC_It == n->prev->tok) 617 return; 618 619 /* A `-diag' without body does not vspace. */ 620 621 if (MDOC_Bl == bl->tok && LIST_diag == bl->norm->Bl.type) 622 if (n->prev && MDOC_It == n->prev->tok) { 623 assert(n->prev->body); 624 if (NULL == n->prev->body->child) 625 return; 626 } 627 628 term_vspace(p); 629 } 630 631 632 static int 633 termp_it_pre(DECL_ARGS) 634 { 635 struct roffsu su; 636 char buf[24]; 637 const struct roff_node *bl, *nn; 638 size_t ncols, dcol; 639 int i, offset, width; 640 enum mdoc_list type; 641 642 if (n->type == ROFFT_BLOCK) { 643 print_bvspace(p, n->parent->parent, n); 644 return 1; 645 } 646 647 bl = n->parent->parent->parent; 648 type = bl->norm->Bl.type; 649 650 /* 651 * Defaults for specific list types. 652 */ 653 654 switch (type) { 655 case LIST_bullet: 656 case LIST_dash: 657 case LIST_hyphen: 658 case LIST_enum: 659 width = term_len(p, 2); 660 break; 661 case LIST_hang: 662 case LIST_tag: 663 width = term_len(p, 8); 664 break; 665 case LIST_column: 666 width = term_len(p, 10); 667 break; 668 default: 669 width = 0; 670 break; 671 } 672 offset = 0; 673 674 /* 675 * First calculate width and offset. This is pretty easy unless 676 * we're a -column list, in which case all prior columns must 677 * be accounted for. 678 */ 679 680 if (bl->norm->Bl.offs != NULL) { 681 offset = a2width(p, bl->norm->Bl.offs); 682 if (offset < 0 && (size_t)(-offset) > p->tcol->offset) 683 offset = -p->tcol->offset; 684 else if (offset > SHRT_MAX) 685 offset = 0; 686 } 687 688 switch (type) { 689 case LIST_column: 690 if (n->type == ROFFT_HEAD) 691 break; 692 693 /* 694 * Imitate groff's column handling: 695 * - For each earlier column, add its width. 696 * - For less than 5 columns, add four more blanks per 697 * column. 698 * - For exactly 5 columns, add three more blank per 699 * column. 700 * - For more than 5 columns, add only one column. 701 */ 702 ncols = bl->norm->Bl.ncols; 703 dcol = ncols < 5 ? term_len(p, 4) : 704 ncols == 5 ? term_len(p, 3) : term_len(p, 1); 705 706 /* 707 * Calculate the offset by applying all prior ROFFT_BODY, 708 * so we stop at the ROFFT_HEAD (nn->prev == NULL). 709 */ 710 711 for (i = 0, nn = n->prev; 712 nn->prev && i < (int)ncols; 713 nn = nn->prev, i++) { 714 SCALE_HS_INIT(&su, 715 term_strlen(p, bl->norm->Bl.cols[i])); 716 su.scale /= term_strlen(p, "0"); 717 offset += term_hen(p, &su) + dcol; 718 } 719 720 /* 721 * When exceeding the declared number of columns, leave 722 * the remaining widths at 0. This will later be 723 * adjusted to the default width of 10, or, for the last 724 * column, stretched to the right margin. 725 */ 726 if (i >= (int)ncols) 727 break; 728 729 /* 730 * Use the declared column widths, extended as explained 731 * in the preceding paragraph. 732 */ 733 SCALE_HS_INIT(&su, term_strlen(p, bl->norm->Bl.cols[i])); 734 su.scale /= term_strlen(p, "0"); 735 width = term_hen(p, &su) + dcol; 736 break; 737 default: 738 if (NULL == bl->norm->Bl.width) 739 break; 740 741 /* 742 * Note: buffer the width by 2, which is groff's magic 743 * number for buffering single arguments. See the above 744 * handling for column for how this changes. 745 */ 746 width = a2width(p, bl->norm->Bl.width) + term_len(p, 2); 747 if (width < 0 && (size_t)(-width) > p->tcol->offset) 748 width = -p->tcol->offset; 749 else if (width > SHRT_MAX) 750 width = 0; 751 break; 752 } 753 754 /* 755 * Whitespace control. Inset bodies need an initial space, 756 * while diagonal bodies need two. 757 */ 758 759 p->flags |= TERMP_NOSPACE; 760 761 switch (type) { 762 case LIST_diag: 763 if (n->type == ROFFT_BODY) 764 term_word(p, "\\ \\ "); 765 break; 766 case LIST_inset: 767 if (n->type == ROFFT_BODY && n->parent->head->child != NULL) 768 term_word(p, "\\ "); 769 break; 770 default: 771 break; 772 } 773 774 p->flags |= TERMP_NOSPACE; 775 776 switch (type) { 777 case LIST_diag: 778 if (n->type == ROFFT_HEAD) 779 term_fontpush(p, TERMFONT_BOLD); 780 break; 781 default: 782 break; 783 } 784 785 /* 786 * Pad and break control. This is the tricky part. These flags 787 * are documented in term_flushln() in term.c. Note that we're 788 * going to unset all of these flags in termp_it_post() when we 789 * exit. 790 */ 791 792 switch (type) { 793 case LIST_enum: 794 case LIST_bullet: 795 case LIST_dash: 796 case LIST_hyphen: 797 if (n->type == ROFFT_HEAD) { 798 p->flags |= TERMP_NOBREAK | TERMP_HANG; 799 p->trailspace = 1; 800 } else if (width <= (int)term_len(p, 2)) 801 p->flags |= TERMP_NOPAD; 802 break; 803 case LIST_hang: 804 if (n->type != ROFFT_HEAD) 805 break; 806 p->flags |= TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG; 807 p->trailspace = 1; 808 break; 809 case LIST_tag: 810 if (n->type != ROFFT_HEAD) 811 break; 812 813 p->flags |= TERMP_NOBREAK | TERMP_BRTRSP | TERMP_BRIND; 814 p->trailspace = 2; 815 816 if (NULL == n->next || NULL == n->next->child) 817 p->flags |= TERMP_HANG; 818 break; 819 case LIST_column: 820 if (n->type == ROFFT_HEAD) 821 break; 822 823 if (NULL == n->next) { 824 p->flags &= ~TERMP_NOBREAK; 825 p->trailspace = 0; 826 } else { 827 p->flags |= TERMP_NOBREAK; 828 p->trailspace = 1; 829 } 830 831 break; 832 case LIST_diag: 833 if (n->type != ROFFT_HEAD) 834 break; 835 p->flags |= TERMP_NOBREAK | TERMP_BRIND; 836 p->trailspace = 1; 837 break; 838 default: 839 break; 840 } 841 842 /* 843 * Margin control. Set-head-width lists have their right 844 * margins shortened. The body for these lists has the offset 845 * necessarily lengthened. Everybody gets the offset. 846 */ 847 848 p->tcol->offset += offset; 849 850 switch (type) { 851 case LIST_bullet: 852 case LIST_dash: 853 case LIST_enum: 854 case LIST_hyphen: 855 case LIST_hang: 856 case LIST_tag: 857 if (n->type == ROFFT_HEAD) 858 p->tcol->rmargin = p->tcol->offset + width; 859 else 860 p->tcol->offset += width; 861 break; 862 case LIST_column: 863 assert(width); 864 p->tcol->rmargin = p->tcol->offset + width; 865 /* 866 * XXX - this behaviour is not documented: the 867 * right-most column is filled to the right margin. 868 */ 869 if (n->type == ROFFT_HEAD) 870 break; 871 if (n->next == NULL && p->tcol->rmargin < p->maxrmargin) 872 p->tcol->rmargin = p->maxrmargin; 873 break; 874 default: 875 break; 876 } 877 878 /* 879 * The dash, hyphen, bullet and enum lists all have a special 880 * HEAD character (temporarily bold, in some cases). 881 */ 882 883 if (n->type == ROFFT_HEAD) 884 switch (type) { 885 case LIST_bullet: 886 term_fontpush(p, TERMFONT_BOLD); 887 term_word(p, "\\[bu]"); 888 term_fontpop(p); 889 break; 890 case LIST_dash: 891 case LIST_hyphen: 892 term_fontpush(p, TERMFONT_BOLD); 893 term_word(p, "-"); 894 term_fontpop(p); 895 break; 896 case LIST_enum: 897 (pair->ppair->ppair->count)++; 898 (void)snprintf(buf, sizeof(buf), "%d.", 899 pair->ppair->ppair->count); 900 term_word(p, buf); 901 break; 902 default: 903 break; 904 } 905 906 /* 907 * If we're not going to process our children, indicate so here. 908 */ 909 910 switch (type) { 911 case LIST_bullet: 912 case LIST_item: 913 case LIST_dash: 914 case LIST_hyphen: 915 case LIST_enum: 916 if (n->type == ROFFT_HEAD) 917 return 0; 918 break; 919 case LIST_column: 920 if (n->type == ROFFT_HEAD) 921 return 0; 922 p->minbl = 0; 923 break; 924 default: 925 break; 926 } 927 928 return 1; 929 } 930 931 static void 932 termp_it_post(DECL_ARGS) 933 { 934 enum mdoc_list type; 935 936 if (n->type == ROFFT_BLOCK) 937 return; 938 939 type = n->parent->parent->parent->norm->Bl.type; 940 941 switch (type) { 942 case LIST_item: 943 case LIST_diag: 944 case LIST_inset: 945 if (n->type == ROFFT_BODY) 946 term_newln(p); 947 break; 948 case LIST_column: 949 if (n->type == ROFFT_BODY) 950 term_flushln(p); 951 break; 952 default: 953 term_newln(p); 954 break; 955 } 956 957 /* 958 * Now that our output is flushed, we can reset our tags. Since 959 * only `It' sets these flags, we're free to assume that nobody 960 * has munged them in the meanwhile. 961 */ 962 963 p->flags &= ~(TERMP_NOBREAK | TERMP_BRTRSP | TERMP_BRIND | TERMP_HANG); 964 p->trailspace = 0; 965 } 966 967 static int 968 termp_nm_pre(DECL_ARGS) 969 { 970 const char *cp; 971 972 if (n->type == ROFFT_BLOCK) { 973 p->flags |= TERMP_PREKEEP; 974 return 1; 975 } 976 977 if (n->type == ROFFT_BODY) { 978 if (n->child == NULL) 979 return 0; 980 p->flags |= TERMP_NOSPACE; 981 cp = NULL; 982 if (n->prev->child != NULL) 983 cp = n->prev->child->string; 984 if (cp == NULL) 985 cp = meta->name; 986 if (cp == NULL) 987 p->tcol->offset += term_len(p, 6); 988 else 989 p->tcol->offset += term_len(p, 1) + 990 term_strlen(p, cp); 991 return 1; 992 } 993 994 if (n->child == NULL) 995 return 0; 996 997 if (n->type == ROFFT_HEAD) 998 synopsis_pre(p, n->parent); 999 1000 if (n->type == ROFFT_HEAD && 1001 n->next != NULL && n->next->child != NULL) { 1002 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK | TERMP_BRIND; 1003 p->trailspace = 1; 1004 p->tcol->rmargin = p->tcol->offset + term_len(p, 1); 1005 if (n->child == NULL) 1006 p->tcol->rmargin += term_strlen(p, meta->name); 1007 else if (n->child->type == ROFFT_TEXT) { 1008 p->tcol->rmargin += term_strlen(p, n->child->string); 1009 if (n->child->next != NULL) 1010 p->flags |= TERMP_HANG; 1011 } else { 1012 p->tcol->rmargin += term_len(p, 5); 1013 p->flags |= TERMP_HANG; 1014 } 1015 } 1016 1017 term_fontpush(p, TERMFONT_BOLD); 1018 return 1; 1019 } 1020 1021 static void 1022 termp_nm_post(DECL_ARGS) 1023 { 1024 1025 if (n->type == ROFFT_BLOCK) { 1026 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP); 1027 } else if (n->type == ROFFT_HEAD && 1028 NULL != n->next && NULL != n->next->child) { 1029 term_flushln(p); 1030 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG); 1031 p->trailspace = 0; 1032 } else if (n->type == ROFFT_BODY && n->child != NULL) 1033 term_flushln(p); 1034 } 1035 1036 static int 1037 termp_fl_pre(DECL_ARGS) 1038 { 1039 1040 termp_tag_pre(p, pair, meta, n); 1041 term_fontpush(p, TERMFONT_BOLD); 1042 term_word(p, "\\-"); 1043 1044 if (!(n->child == NULL && 1045 (n->next == NULL || 1046 n->next->type == ROFFT_TEXT || 1047 n->next->flags & NODE_LINE))) 1048 p->flags |= TERMP_NOSPACE; 1049 1050 return 1; 1051 } 1052 1053 static int 1054 termp__a_pre(DECL_ARGS) 1055 { 1056 1057 if (n->prev && MDOC__A == n->prev->tok) 1058 if (NULL == n->next || MDOC__A != n->next->tok) 1059 term_word(p, "and"); 1060 1061 return 1; 1062 } 1063 1064 static int 1065 termp_an_pre(DECL_ARGS) 1066 { 1067 1068 if (n->norm->An.auth == AUTH_split) { 1069 p->flags &= ~TERMP_NOSPLIT; 1070 p->flags |= TERMP_SPLIT; 1071 return 0; 1072 } 1073 if (n->norm->An.auth == AUTH_nosplit) { 1074 p->flags &= ~TERMP_SPLIT; 1075 p->flags |= TERMP_NOSPLIT; 1076 return 0; 1077 } 1078 1079 if (p->flags & TERMP_SPLIT) 1080 term_newln(p); 1081 1082 if (n->sec == SEC_AUTHORS && ! (p->flags & TERMP_NOSPLIT)) 1083 p->flags |= TERMP_SPLIT; 1084 1085 return 1; 1086 } 1087 1088 static int 1089 termp_ns_pre(DECL_ARGS) 1090 { 1091 1092 if ( ! (NODE_LINE & n->flags)) 1093 p->flags |= TERMP_NOSPACE; 1094 return 1; 1095 } 1096 1097 static int 1098 termp_rs_pre(DECL_ARGS) 1099 { 1100 1101 if (SEC_SEE_ALSO != n->sec) 1102 return 1; 1103 if (n->type == ROFFT_BLOCK && n->prev != NULL) 1104 term_vspace(p); 1105 return 1; 1106 } 1107 1108 static int 1109 termp_ex_pre(DECL_ARGS) 1110 { 1111 term_newln(p); 1112 return 1; 1113 } 1114 1115 static int 1116 termp_nd_pre(DECL_ARGS) 1117 { 1118 1119 if (n->type == ROFFT_BODY) 1120 term_word(p, "\\(en"); 1121 return 1; 1122 } 1123 1124 static int 1125 termp_bl_pre(DECL_ARGS) 1126 { 1127 1128 return n->type != ROFFT_HEAD; 1129 } 1130 1131 static void 1132 termp_bl_post(DECL_ARGS) 1133 { 1134 1135 if (n->type != ROFFT_BLOCK) 1136 return; 1137 term_newln(p); 1138 if (n->tok != MDOC_Bl || n->norm->Bl.type != LIST_column) 1139 return; 1140 term_tab_set(p, NULL); 1141 term_tab_set(p, "T"); 1142 term_tab_set(p, ".5i"); 1143 } 1144 1145 static int 1146 termp_xr_pre(DECL_ARGS) 1147 { 1148 1149 if (NULL == (n = n->child)) 1150 return 0; 1151 1152 assert(n->type == ROFFT_TEXT); 1153 term_word(p, n->string); 1154 1155 if (NULL == (n = n->next)) 1156 return 0; 1157 1158 p->flags |= TERMP_NOSPACE; 1159 term_word(p, "("); 1160 p->flags |= TERMP_NOSPACE; 1161 1162 assert(n->type == ROFFT_TEXT); 1163 term_word(p, n->string); 1164 1165 p->flags |= TERMP_NOSPACE; 1166 term_word(p, ")"); 1167 1168 return 0; 1169 } 1170 1171 /* 1172 * This decides how to assert whitespace before any of the SYNOPSIS set 1173 * of macros (which, as in the case of Ft/Fo and Ft/Fn, may contain 1174 * macro combos). 1175 */ 1176 static void 1177 synopsis_pre(struct termp *p, const struct roff_node *n) 1178 { 1179 /* 1180 * Obviously, if we're not in a SYNOPSIS or no prior macros 1181 * exist, do nothing. 1182 */ 1183 if (NULL == n->prev || ! (NODE_SYNPRETTY & n->flags)) 1184 return; 1185 1186 /* 1187 * If we're the second in a pair of like elements, emit our 1188 * newline and return. UNLESS we're `Fo', `Fn', `Fn', in which 1189 * case we soldier on. 1190 */ 1191 if (n->prev->tok == n->tok && 1192 MDOC_Ft != n->tok && 1193 MDOC_Fo != n->tok && 1194 MDOC_Fn != n->tok) { 1195 term_newln(p); 1196 return; 1197 } 1198 1199 /* 1200 * If we're one of the SYNOPSIS set and non-like pair-wise after 1201 * another (or Fn/Fo, which we've let slip through) then assert 1202 * vertical space, else only newline and move on. 1203 */ 1204 switch (n->prev->tok) { 1205 case MDOC_Fd: 1206 case MDOC_Fn: 1207 case MDOC_Fo: 1208 case MDOC_In: 1209 case MDOC_Vt: 1210 term_vspace(p); 1211 break; 1212 case MDOC_Ft: 1213 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) { 1214 term_vspace(p); 1215 break; 1216 } 1217 /* FALLTHROUGH */ 1218 default: 1219 term_newln(p); 1220 break; 1221 } 1222 } 1223 1224 static int 1225 termp_vt_pre(DECL_ARGS) 1226 { 1227 1228 if (n->type == ROFFT_ELEM) { 1229 synopsis_pre(p, n); 1230 return termp_under_pre(p, pair, meta, n); 1231 } else if (n->type == ROFFT_BLOCK) { 1232 synopsis_pre(p, n); 1233 return 1; 1234 } else if (n->type == ROFFT_HEAD) 1235 return 0; 1236 1237 return termp_under_pre(p, pair, meta, n); 1238 } 1239 1240 static int 1241 termp_bold_pre(DECL_ARGS) 1242 { 1243 1244 termp_tag_pre(p, pair, meta, n); 1245 term_fontpush(p, TERMFONT_BOLD); 1246 return 1; 1247 } 1248 1249 static int 1250 termp_fd_pre(DECL_ARGS) 1251 { 1252 1253 synopsis_pre(p, n); 1254 return termp_bold_pre(p, pair, meta, n); 1255 } 1256 1257 static void 1258 termp_fd_post(DECL_ARGS) 1259 { 1260 1261 term_newln(p); 1262 } 1263 1264 static int 1265 termp_sh_pre(DECL_ARGS) 1266 { 1267 1268 switch (n->type) { 1269 case ROFFT_BLOCK: 1270 /* 1271 * Vertical space before sections, except 1272 * when the previous section was empty. 1273 */ 1274 if (n->prev == NULL || 1275 n->prev->tok != MDOC_Sh || 1276 (n->prev->body != NULL && 1277 n->prev->body->child != NULL)) 1278 term_vspace(p); 1279 break; 1280 case ROFFT_HEAD: 1281 term_fontpush(p, TERMFONT_BOLD); 1282 break; 1283 case ROFFT_BODY: 1284 p->tcol->offset = term_len(p, p->defindent); 1285 term_tab_set(p, NULL); 1286 term_tab_set(p, "T"); 1287 term_tab_set(p, ".5i"); 1288 switch (n->sec) { 1289 case SEC_DESCRIPTION: 1290 fn_prio = 0; 1291 break; 1292 case SEC_AUTHORS: 1293 p->flags &= ~(TERMP_SPLIT|TERMP_NOSPLIT); 1294 break; 1295 default: 1296 break; 1297 } 1298 break; 1299 default: 1300 break; 1301 } 1302 return 1; 1303 } 1304 1305 static void 1306 termp_sh_post(DECL_ARGS) 1307 { 1308 1309 switch (n->type) { 1310 case ROFFT_HEAD: 1311 term_newln(p); 1312 break; 1313 case ROFFT_BODY: 1314 term_newln(p); 1315 p->tcol->offset = 0; 1316 break; 1317 default: 1318 break; 1319 } 1320 } 1321 1322 static void 1323 termp_lb_post(DECL_ARGS) 1324 { 1325 1326 if (SEC_LIBRARY == n->sec && NODE_LINE & n->flags) 1327 term_newln(p); 1328 } 1329 1330 static int 1331 termp_d1_pre(DECL_ARGS) 1332 { 1333 1334 if (n->type != ROFFT_BLOCK) 1335 return 1; 1336 term_newln(p); 1337 p->tcol->offset += term_len(p, p->defindent + 1); 1338 term_tab_set(p, NULL); 1339 term_tab_set(p, "T"); 1340 term_tab_set(p, ".5i"); 1341 return 1; 1342 } 1343 1344 static int 1345 termp_ft_pre(DECL_ARGS) 1346 { 1347 1348 /* NB: NODE_LINE does not effect this! */ 1349 synopsis_pre(p, n); 1350 term_fontpush(p, TERMFONT_UNDER); 1351 return 1; 1352 } 1353 1354 static int 1355 termp_fn_pre(DECL_ARGS) 1356 { 1357 size_t rmargin = 0; 1358 int pretty; 1359 1360 pretty = NODE_SYNPRETTY & n->flags; 1361 1362 synopsis_pre(p, n); 1363 1364 if (NULL == (n = n->child)) 1365 return 0; 1366 1367 if (pretty) { 1368 rmargin = p->tcol->rmargin; 1369 p->tcol->rmargin = p->tcol->offset + term_len(p, 4); 1370 p->flags |= TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG; 1371 } 1372 1373 assert(n->type == ROFFT_TEXT); 1374 term_fontpush(p, TERMFONT_BOLD); 1375 term_word(p, n->string); 1376 term_fontpop(p); 1377 1378 if (n->sec == SEC_DESCRIPTION || n->sec == SEC_CUSTOM) 1379 tag_put(n->string, ++fn_prio, p->line); 1380 1381 if (pretty) { 1382 term_flushln(p); 1383 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG); 1384 p->flags |= TERMP_NOPAD; 1385 p->tcol->offset = p->tcol->rmargin; 1386 p->tcol->rmargin = rmargin; 1387 } 1388 1389 p->flags |= TERMP_NOSPACE; 1390 term_word(p, "("); 1391 p->flags |= TERMP_NOSPACE; 1392 1393 for (n = n->next; n; n = n->next) { 1394 assert(n->type == ROFFT_TEXT); 1395 term_fontpush(p, TERMFONT_UNDER); 1396 if (pretty) 1397 p->flags |= TERMP_NBRWORD; 1398 term_word(p, n->string); 1399 term_fontpop(p); 1400 1401 if (n->next) { 1402 p->flags |= TERMP_NOSPACE; 1403 term_word(p, ","); 1404 } 1405 } 1406 1407 p->flags |= TERMP_NOSPACE; 1408 term_word(p, ")"); 1409 1410 if (pretty) { 1411 p->flags |= TERMP_NOSPACE; 1412 term_word(p, ";"); 1413 term_flushln(p); 1414 } 1415 1416 return 0; 1417 } 1418 1419 static int 1420 termp_fa_pre(DECL_ARGS) 1421 { 1422 const struct roff_node *nn; 1423 1424 if (n->parent->tok != MDOC_Fo) { 1425 term_fontpush(p, TERMFONT_UNDER); 1426 return 1; 1427 } 1428 1429 for (nn = n->child; nn; nn = nn->next) { 1430 term_fontpush(p, TERMFONT_UNDER); 1431 p->flags |= TERMP_NBRWORD; 1432 term_word(p, nn->string); 1433 term_fontpop(p); 1434 1435 if (nn->next || (n->next && n->next->tok == MDOC_Fa)) { 1436 p->flags |= TERMP_NOSPACE; 1437 term_word(p, ","); 1438 } 1439 } 1440 1441 return 0; 1442 } 1443 1444 static int 1445 termp_bd_pre(DECL_ARGS) 1446 { 1447 int offset; 1448 1449 if (n->type == ROFFT_BLOCK) { 1450 print_bvspace(p, n, n); 1451 return 1; 1452 } else if (n->type == ROFFT_HEAD) 1453 return 0; 1454 1455 /* Handle the -offset argument. */ 1456 1457 if (n->norm->Bd.offs == NULL || 1458 ! strcmp(n->norm->Bd.offs, "left")) 1459 /* nothing */; 1460 else if ( ! strcmp(n->norm->Bd.offs, "indent")) 1461 p->tcol->offset += term_len(p, p->defindent + 1); 1462 else if ( ! strcmp(n->norm->Bd.offs, "indent-two")) 1463 p->tcol->offset += term_len(p, (p->defindent + 1) * 2); 1464 else { 1465 offset = a2width(p, n->norm->Bd.offs); 1466 if (offset < 0 && (size_t)(-offset) > p->tcol->offset) 1467 p->tcol->offset = 0; 1468 else if (offset < SHRT_MAX) 1469 p->tcol->offset += offset; 1470 } 1471 1472 switch (n->norm->Bd.type) { 1473 case DISP_literal: 1474 term_tab_set(p, NULL); 1475 term_tab_set(p, "T"); 1476 term_tab_set(p, "8n"); 1477 break; 1478 case DISP_centered: 1479 p->flags |= TERMP_CENTER; 1480 break; 1481 default: 1482 break; 1483 } 1484 return 1; 1485 } 1486 1487 static void 1488 termp_bd_post(DECL_ARGS) 1489 { 1490 if (n->type != ROFFT_BODY) 1491 return; 1492 if (n->norm->Bd.type == DISP_unfilled || 1493 n->norm->Bd.type == DISP_literal) 1494 p->flags |= TERMP_BRNEVER; 1495 p->flags |= TERMP_NOSPACE; 1496 term_newln(p); 1497 p->flags &= ~TERMP_BRNEVER; 1498 if (n->norm->Bd.type == DISP_centered) 1499 p->flags &= ~TERMP_CENTER; 1500 } 1501 1502 static int 1503 termp_xx_pre(DECL_ARGS) 1504 { 1505 if ((n->aux = p->flags & TERMP_PREKEEP) == 0) 1506 p->flags |= TERMP_PREKEEP; 1507 return 1; 1508 } 1509 1510 static void 1511 termp_xx_post(DECL_ARGS) 1512 { 1513 if (n->aux == 0) 1514 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP); 1515 } 1516 1517 static void 1518 termp_pf_post(DECL_ARGS) 1519 { 1520 1521 if ( ! (n->next == NULL || n->next->flags & NODE_LINE)) 1522 p->flags |= TERMP_NOSPACE; 1523 } 1524 1525 static int 1526 termp_ss_pre(DECL_ARGS) 1527 { 1528 struct roff_node *nn; 1529 1530 switch (n->type) { 1531 case ROFFT_BLOCK: 1532 term_newln(p); 1533 for (nn = n->prev; nn != NULL; nn = nn->prev) 1534 if (nn->type != ROFFT_COMMENT && 1535 (nn->flags & NODE_NOPRT) == 0) 1536 break; 1537 if (nn != NULL) 1538 term_vspace(p); 1539 break; 1540 case ROFFT_HEAD: 1541 term_fontpush(p, TERMFONT_BOLD); 1542 p->tcol->offset = term_len(p, (p->defindent+1)/2); 1543 break; 1544 case ROFFT_BODY: 1545 p->tcol->offset = term_len(p, p->defindent); 1546 term_tab_set(p, NULL); 1547 term_tab_set(p, "T"); 1548 term_tab_set(p, ".5i"); 1549 break; 1550 default: 1551 break; 1552 } 1553 1554 return 1; 1555 } 1556 1557 static void 1558 termp_ss_post(DECL_ARGS) 1559 { 1560 1561 if (n->type == ROFFT_HEAD || n->type == ROFFT_BODY) 1562 term_newln(p); 1563 } 1564 1565 static int 1566 termp_cd_pre(DECL_ARGS) 1567 { 1568 1569 synopsis_pre(p, n); 1570 term_fontpush(p, TERMFONT_BOLD); 1571 return 1; 1572 } 1573 1574 static int 1575 termp_in_pre(DECL_ARGS) 1576 { 1577 1578 synopsis_pre(p, n); 1579 1580 if (NODE_SYNPRETTY & n->flags && NODE_LINE & n->flags) { 1581 term_fontpush(p, TERMFONT_BOLD); 1582 term_word(p, "#include"); 1583 term_word(p, "<"); 1584 } else { 1585 term_word(p, "<"); 1586 term_fontpush(p, TERMFONT_UNDER); 1587 } 1588 1589 p->flags |= TERMP_NOSPACE; 1590 return 1; 1591 } 1592 1593 static void 1594 termp_in_post(DECL_ARGS) 1595 { 1596 1597 if (NODE_SYNPRETTY & n->flags) 1598 term_fontpush(p, TERMFONT_BOLD); 1599 1600 p->flags |= TERMP_NOSPACE; 1601 term_word(p, ">"); 1602 1603 if (NODE_SYNPRETTY & n->flags) 1604 term_fontpop(p); 1605 } 1606 1607 static int 1608 termp_pp_pre(DECL_ARGS) 1609 { 1610 fn_prio = 0; 1611 term_vspace(p); 1612 return 0; 1613 } 1614 1615 static int 1616 termp_skip_pre(DECL_ARGS) 1617 { 1618 1619 return 0; 1620 } 1621 1622 static int 1623 termp_quote_pre(DECL_ARGS) 1624 { 1625 1626 if (n->type != ROFFT_BODY && n->type != ROFFT_ELEM) 1627 return 1; 1628 1629 switch (n->tok) { 1630 case MDOC_Ao: 1631 case MDOC_Aq: 1632 term_word(p, n->child != NULL && n->child->next == NULL && 1633 n->child->tok == MDOC_Mt ? "<" : "\\(la"); 1634 break; 1635 case MDOC_Bro: 1636 case MDOC_Brq: 1637 term_word(p, "{"); 1638 break; 1639 case MDOC_Oo: 1640 case MDOC_Op: 1641 case MDOC_Bo: 1642 case MDOC_Bq: 1643 term_word(p, "["); 1644 break; 1645 case MDOC__T: 1646 /* FALLTHROUGH */ 1647 case MDOC_Do: 1648 case MDOC_Dq: 1649 term_word(p, "\\(lq"); 1650 break; 1651 case MDOC_En: 1652 if (NULL == n->norm->Es || 1653 NULL == n->norm->Es->child) 1654 return 1; 1655 term_word(p, n->norm->Es->child->string); 1656 break; 1657 case MDOC_Po: 1658 case MDOC_Pq: 1659 term_word(p, "("); 1660 break; 1661 case MDOC_Qo: 1662 case MDOC_Qq: 1663 term_word(p, "\""); 1664 break; 1665 case MDOC_Ql: 1666 case MDOC_So: 1667 case MDOC_Sq: 1668 term_word(p, "\\(oq"); 1669 break; 1670 default: 1671 abort(); 1672 } 1673 1674 p->flags |= TERMP_NOSPACE; 1675 return 1; 1676 } 1677 1678 static void 1679 termp_quote_post(DECL_ARGS) 1680 { 1681 1682 if (n->type != ROFFT_BODY && n->type != ROFFT_ELEM) 1683 return; 1684 1685 p->flags |= TERMP_NOSPACE; 1686 1687 switch (n->tok) { 1688 case MDOC_Ao: 1689 case MDOC_Aq: 1690 term_word(p, n->child != NULL && n->child->next == NULL && 1691 n->child->tok == MDOC_Mt ? ">" : "\\(ra"); 1692 break; 1693 case MDOC_Bro: 1694 case MDOC_Brq: 1695 term_word(p, "}"); 1696 break; 1697 case MDOC_Oo: 1698 case MDOC_Op: 1699 case MDOC_Bo: 1700 case MDOC_Bq: 1701 term_word(p, "]"); 1702 break; 1703 case MDOC__T: 1704 /* FALLTHROUGH */ 1705 case MDOC_Do: 1706 case MDOC_Dq: 1707 term_word(p, "\\(rq"); 1708 break; 1709 case MDOC_En: 1710 if (n->norm->Es == NULL || 1711 n->norm->Es->child == NULL || 1712 n->norm->Es->child->next == NULL) 1713 p->flags &= ~TERMP_NOSPACE; 1714 else 1715 term_word(p, n->norm->Es->child->next->string); 1716 break; 1717 case MDOC_Po: 1718 case MDOC_Pq: 1719 term_word(p, ")"); 1720 break; 1721 case MDOC_Qo: 1722 case MDOC_Qq: 1723 term_word(p, "\""); 1724 break; 1725 case MDOC_Ql: 1726 case MDOC_So: 1727 case MDOC_Sq: 1728 term_word(p, "\\(cq"); 1729 break; 1730 default: 1731 abort(); 1732 } 1733 } 1734 1735 static int 1736 termp_eo_pre(DECL_ARGS) 1737 { 1738 1739 if (n->type != ROFFT_BODY) 1740 return 1; 1741 1742 if (n->end == ENDBODY_NOT && 1743 n->parent->head->child == NULL && 1744 n->child != NULL && 1745 n->child->end != ENDBODY_NOT) 1746 term_word(p, "\\&"); 1747 else if (n->end != ENDBODY_NOT ? n->child != NULL : 1748 n->parent->head->child != NULL && (n->child != NULL || 1749 (n->parent->tail != NULL && n->parent->tail->child != NULL))) 1750 p->flags |= TERMP_NOSPACE; 1751 1752 return 1; 1753 } 1754 1755 static void 1756 termp_eo_post(DECL_ARGS) 1757 { 1758 int body, tail; 1759 1760 if (n->type != ROFFT_BODY) 1761 return; 1762 1763 if (n->end != ENDBODY_NOT) { 1764 p->flags &= ~TERMP_NOSPACE; 1765 return; 1766 } 1767 1768 body = n->child != NULL || n->parent->head->child != NULL; 1769 tail = n->parent->tail != NULL && n->parent->tail->child != NULL; 1770 1771 if (body && tail) 1772 p->flags |= TERMP_NOSPACE; 1773 else if ( ! (body || tail)) 1774 term_word(p, "\\&"); 1775 else if ( ! tail) 1776 p->flags &= ~TERMP_NOSPACE; 1777 } 1778 1779 static int 1780 termp_fo_pre(DECL_ARGS) 1781 { 1782 size_t rmargin = 0; 1783 int pretty; 1784 1785 pretty = NODE_SYNPRETTY & n->flags; 1786 1787 if (n->type == ROFFT_BLOCK) { 1788 synopsis_pre(p, n); 1789 return 1; 1790 } else if (n->type == ROFFT_BODY) { 1791 if (pretty) { 1792 rmargin = p->tcol->rmargin; 1793 p->tcol->rmargin = p->tcol->offset + term_len(p, 4); 1794 p->flags |= TERMP_NOBREAK | TERMP_BRIND | 1795 TERMP_HANG; 1796 } 1797 p->flags |= TERMP_NOSPACE; 1798 term_word(p, "("); 1799 p->flags |= TERMP_NOSPACE; 1800 if (pretty) { 1801 term_flushln(p); 1802 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | 1803 TERMP_HANG); 1804 p->flags |= TERMP_NOPAD; 1805 p->tcol->offset = p->tcol->rmargin; 1806 p->tcol->rmargin = rmargin; 1807 } 1808 return 1; 1809 } 1810 1811 if (NULL == n->child) 1812 return 0; 1813 1814 /* XXX: we drop non-initial arguments as per groff. */ 1815 1816 assert(n->child->string); 1817 term_fontpush(p, TERMFONT_BOLD); 1818 term_word(p, n->child->string); 1819 return 0; 1820 } 1821 1822 static void 1823 termp_fo_post(DECL_ARGS) 1824 { 1825 1826 if (n->type != ROFFT_BODY) 1827 return; 1828 1829 p->flags |= TERMP_NOSPACE; 1830 term_word(p, ")"); 1831 1832 if (NODE_SYNPRETTY & n->flags) { 1833 p->flags |= TERMP_NOSPACE; 1834 term_word(p, ";"); 1835 term_flushln(p); 1836 } 1837 } 1838 1839 static int 1840 termp_bf_pre(DECL_ARGS) 1841 { 1842 1843 if (n->type == ROFFT_HEAD) 1844 return 0; 1845 else if (n->type != ROFFT_BODY) 1846 return 1; 1847 1848 if (FONT_Em == n->norm->Bf.font) 1849 term_fontpush(p, TERMFONT_UNDER); 1850 else if (FONT_Sy == n->norm->Bf.font) 1851 term_fontpush(p, TERMFONT_BOLD); 1852 else 1853 term_fontpush(p, TERMFONT_NONE); 1854 1855 return 1; 1856 } 1857 1858 static int 1859 termp_sm_pre(DECL_ARGS) 1860 { 1861 1862 if (NULL == n->child) 1863 p->flags ^= TERMP_NONOSPACE; 1864 else if (0 == strcmp("on", n->child->string)) 1865 p->flags &= ~TERMP_NONOSPACE; 1866 else 1867 p->flags |= TERMP_NONOSPACE; 1868 1869 if (p->col && ! (TERMP_NONOSPACE & p->flags)) 1870 p->flags &= ~TERMP_NOSPACE; 1871 1872 return 0; 1873 } 1874 1875 static int 1876 termp_ap_pre(DECL_ARGS) 1877 { 1878 1879 p->flags |= TERMP_NOSPACE; 1880 term_word(p, "'"); 1881 p->flags |= TERMP_NOSPACE; 1882 return 1; 1883 } 1884 1885 static void 1886 termp____post(DECL_ARGS) 1887 { 1888 1889 /* 1890 * Handle lists of authors. In general, print each followed by 1891 * a comma. Don't print the comma if there are only two 1892 * authors. 1893 */ 1894 if (MDOC__A == n->tok && n->next && MDOC__A == n->next->tok) 1895 if (NULL == n->next->next || MDOC__A != n->next->next->tok) 1896 if (NULL == n->prev || MDOC__A != n->prev->tok) 1897 return; 1898 1899 /* TODO: %U. */ 1900 1901 if (NULL == n->parent || MDOC_Rs != n->parent->tok) 1902 return; 1903 1904 p->flags |= TERMP_NOSPACE; 1905 if (NULL == n->next) { 1906 term_word(p, "."); 1907 p->flags |= TERMP_SENTENCE; 1908 } else 1909 term_word(p, ","); 1910 } 1911 1912 static int 1913 termp_li_pre(DECL_ARGS) 1914 { 1915 1916 termp_tag_pre(p, pair, meta, n); 1917 term_fontpush(p, TERMFONT_NONE); 1918 return 1; 1919 } 1920 1921 static int 1922 termp_lk_pre(DECL_ARGS) 1923 { 1924 const struct roff_node *link, *descr, *punct; 1925 1926 if ((link = n->child) == NULL) 1927 return 0; 1928 1929 /* Find beginning of trailing punctuation. */ 1930 punct = n->last; 1931 while (punct != link && punct->flags & NODE_DELIMC) 1932 punct = punct->prev; 1933 punct = punct->next; 1934 1935 /* Link text. */ 1936 if ((descr = link->next) != NULL && descr != punct) { 1937 term_fontpush(p, TERMFONT_UNDER); 1938 while (descr != punct) { 1939 if (descr->flags & (NODE_DELIMC | NODE_DELIMO)) 1940 p->flags |= TERMP_NOSPACE; 1941 term_word(p, descr->string); 1942 descr = descr->next; 1943 } 1944 term_fontpop(p); 1945 p->flags |= TERMP_NOSPACE; 1946 term_word(p, ":"); 1947 } 1948 1949 /* Link target. */ 1950 term_fontpush(p, TERMFONT_BOLD); 1951 term_word(p, link->string); 1952 term_fontpop(p); 1953 1954 /* Trailing punctuation. */ 1955 while (punct != NULL) { 1956 p->flags |= TERMP_NOSPACE; 1957 term_word(p, punct->string); 1958 punct = punct->next; 1959 } 1960 return 0; 1961 } 1962 1963 static int 1964 termp_bk_pre(DECL_ARGS) 1965 { 1966 1967 switch (n->type) { 1968 case ROFFT_BLOCK: 1969 break; 1970 case ROFFT_HEAD: 1971 return 0; 1972 case ROFFT_BODY: 1973 if (n->parent->args != NULL || n->prev->child == NULL) 1974 p->flags |= TERMP_PREKEEP; 1975 break; 1976 default: 1977 abort(); 1978 } 1979 1980 return 1; 1981 } 1982 1983 static void 1984 termp_bk_post(DECL_ARGS) 1985 { 1986 1987 if (n->type == ROFFT_BODY) 1988 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP); 1989 } 1990 1991 static void 1992 termp__t_post(DECL_ARGS) 1993 { 1994 1995 /* 1996 * If we're in an `Rs' and there's a journal present, then quote 1997 * us instead of underlining us (for disambiguation). 1998 */ 1999 if (n->parent && MDOC_Rs == n->parent->tok && 2000 n->parent->norm->Rs.quote_T) 2001 termp_quote_post(p, pair, meta, n); 2002 2003 termp____post(p, pair, meta, n); 2004 } 2005 2006 static int 2007 termp__t_pre(DECL_ARGS) 2008 { 2009 2010 /* 2011 * If we're in an `Rs' and there's a journal present, then quote 2012 * us instead of underlining us (for disambiguation). 2013 */ 2014 if (n->parent && MDOC_Rs == n->parent->tok && 2015 n->parent->norm->Rs.quote_T) 2016 return termp_quote_pre(p, pair, meta, n); 2017 2018 term_fontpush(p, TERMFONT_UNDER); 2019 return 1; 2020 } 2021 2022 static int 2023 termp_under_pre(DECL_ARGS) 2024 { 2025 2026 term_fontpush(p, TERMFONT_UNDER); 2027 return 1; 2028 } 2029 2030 static int 2031 termp_em_pre(DECL_ARGS) 2032 { 2033 if (n->child != NULL && 2034 n->child->type == ROFFT_TEXT) 2035 tag_put(n->child->string, 0, p->line); 2036 term_fontpush(p, TERMFONT_UNDER); 2037 return 1; 2038 } 2039 2040 static int 2041 termp_sy_pre(DECL_ARGS) 2042 { 2043 if (n->child != NULL && 2044 n->child->type == ROFFT_TEXT) 2045 tag_put(n->child->string, 0, p->line); 2046 term_fontpush(p, TERMFONT_BOLD); 2047 return 1; 2048 } 2049 2050 static int 2051 termp_er_pre(DECL_ARGS) 2052 { 2053 2054 if (n->sec == SEC_ERRORS && 2055 (n->parent->tok == MDOC_It || 2056 (n->parent->tok == MDOC_Bq && 2057 n->parent->parent->parent->tok == MDOC_It))) 2058 tag_put(n->child->string, 1, p->line); 2059 return 1; 2060 } 2061 2062 static int 2063 termp_tag_pre(DECL_ARGS) 2064 { 2065 2066 if (n->child != NULL && 2067 n->child->type == ROFFT_TEXT && 2068 (n->prev == NULL || 2069 (n->prev->type == ROFFT_TEXT && 2070 strcmp(n->prev->string, "|") == 0)) && 2071 (n->parent->tok == MDOC_It || 2072 (n->parent->tok == MDOC_Xo && 2073 n->parent->parent->prev == NULL && 2074 n->parent->parent->parent->tok == MDOC_It))) 2075 tag_put(n->child->string, 1, p->line); 2076 return 1; 2077 } 2078 2079 static int 2080 termp_abort_pre(DECL_ARGS) 2081 { 2082 abort(); 2083 } 2084