1 /* $Id: man_term.c,v 1.236 2021/06/28 19:50:15 schwarze Exp $ */ 2 /* 3 * Copyright (c) 2010-2015, 2017-2020 Ingo Schwarze <schwarze@openbsd.org> 4 * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@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 * Plain text formatter for man(7), used by mandoc(1) 19 * for ASCII, UTF-8, PostScript, and PDF output. 20 */ 21 #include "config.h" 22 23 #include <sys/types.h> 24 25 #include <assert.h> 26 #include <ctype.h> 27 #include <limits.h> 28 #include <stdio.h> 29 #include <stdlib.h> 30 #include <string.h> 31 32 #include "mandoc_aux.h" 33 #include "mandoc.h" 34 #include "roff.h" 35 #include "man.h" 36 #include "out.h" 37 #include "term.h" 38 #include "term_tag.h" 39 #include "main.h" 40 41 #define MAXMARGINS 64 /* maximum number of indented scopes */ 42 43 struct mtermp { 44 int lmargin[MAXMARGINS]; /* margins (incl. vis. page) */ 45 int lmargincur; /* index of current margin */ 46 int lmarginsz; /* actual number of nested margins */ 47 size_t offset; /* default offset to visible page */ 48 int pardist; /* vert. space before par., unit: [v] */ 49 }; 50 51 #define DECL_ARGS struct termp *p, \ 52 struct mtermp *mt, \ 53 struct roff_node *n, \ 54 const struct roff_meta *meta 55 56 struct man_term_act { 57 int (*pre)(DECL_ARGS); 58 void (*post)(DECL_ARGS); 59 int flags; 60 #define MAN_NOTEXT (1 << 0) /* Never has text children. */ 61 }; 62 63 static void print_man_nodelist(DECL_ARGS); 64 static void print_man_node(DECL_ARGS); 65 static void print_man_head(struct termp *, 66 const struct roff_meta *); 67 static void print_man_foot(struct termp *, 68 const struct roff_meta *); 69 static void print_bvspace(struct termp *, 70 struct roff_node *, int); 71 72 static int pre_B(DECL_ARGS); 73 static int pre_DT(DECL_ARGS); 74 static int pre_HP(DECL_ARGS); 75 static int pre_I(DECL_ARGS); 76 static int pre_IP(DECL_ARGS); 77 static int pre_OP(DECL_ARGS); 78 static int pre_PD(DECL_ARGS); 79 static int pre_PP(DECL_ARGS); 80 static int pre_RS(DECL_ARGS); 81 static int pre_SH(DECL_ARGS); 82 static int pre_SS(DECL_ARGS); 83 static int pre_SY(DECL_ARGS); 84 static int pre_TP(DECL_ARGS); 85 static int pre_UR(DECL_ARGS); 86 static int pre_abort(DECL_ARGS); 87 static int pre_alternate(DECL_ARGS); 88 static int pre_ign(DECL_ARGS); 89 static int pre_in(DECL_ARGS); 90 static int pre_literal(DECL_ARGS); 91 92 static void post_IP(DECL_ARGS); 93 static void post_HP(DECL_ARGS); 94 static void post_RS(DECL_ARGS); 95 static void post_SH(DECL_ARGS); 96 static void post_SY(DECL_ARGS); 97 static void post_TP(DECL_ARGS); 98 static void post_UR(DECL_ARGS); 99 100 static const struct man_term_act man_term_acts[MAN_MAX - MAN_TH] = { 101 { NULL, NULL, 0 }, /* TH */ 102 { pre_SH, post_SH, 0 }, /* SH */ 103 { pre_SS, post_SH, 0 }, /* SS */ 104 { pre_TP, post_TP, 0 }, /* TP */ 105 { pre_TP, post_TP, 0 }, /* TQ */ 106 { pre_abort, NULL, 0 }, /* LP */ 107 { pre_PP, NULL, 0 }, /* PP */ 108 { pre_abort, NULL, 0 }, /* P */ 109 { pre_IP, post_IP, 0 }, /* IP */ 110 { pre_HP, post_HP, 0 }, /* HP */ 111 { NULL, NULL, 0 }, /* SM */ 112 { pre_B, NULL, 0 }, /* SB */ 113 { pre_alternate, NULL, 0 }, /* BI */ 114 { pre_alternate, NULL, 0 }, /* IB */ 115 { pre_alternate, NULL, 0 }, /* BR */ 116 { pre_alternate, NULL, 0 }, /* RB */ 117 { NULL, NULL, 0 }, /* R */ 118 { pre_B, NULL, 0 }, /* B */ 119 { pre_I, NULL, 0 }, /* I */ 120 { pre_alternate, NULL, 0 }, /* IR */ 121 { pre_alternate, NULL, 0 }, /* RI */ 122 { NULL, NULL, 0 }, /* RE */ 123 { pre_RS, post_RS, 0 }, /* RS */ 124 { pre_DT, NULL, 0 }, /* DT */ 125 { pre_ign, NULL, MAN_NOTEXT }, /* UC */ 126 { pre_PD, NULL, MAN_NOTEXT }, /* PD */ 127 { pre_ign, NULL, 0 }, /* AT */ 128 { pre_in, NULL, MAN_NOTEXT }, /* in */ 129 { pre_SY, post_SY, 0 }, /* SY */ 130 { NULL, NULL, 0 }, /* YS */ 131 { pre_OP, NULL, 0 }, /* OP */ 132 { pre_literal, NULL, 0 }, /* EX */ 133 { pre_literal, NULL, 0 }, /* EE */ 134 { pre_UR, post_UR, 0 }, /* UR */ 135 { NULL, NULL, 0 }, /* UE */ 136 { pre_UR, post_UR, 0 }, /* MT */ 137 { NULL, NULL, 0 }, /* ME */ 138 }; 139 static const struct man_term_act *man_term_act(enum roff_tok); 140 141 142 static const struct man_term_act * 143 man_term_act(enum roff_tok tok) 144 { 145 assert(tok >= MAN_TH && tok <= MAN_MAX); 146 return man_term_acts + (tok - MAN_TH); 147 } 148 149 void 150 terminal_man(void *arg, const struct roff_meta *man) 151 { 152 struct mtermp mt; 153 struct termp *p; 154 struct roff_node *n, *nc, *nn; 155 size_t save_defindent; 156 157 p = (struct termp *)arg; 158 save_defindent = p->defindent; 159 if (p->synopsisonly == 0 && p->defindent == 0) 160 p->defindent = 7; 161 p->tcol->rmargin = p->maxrmargin = p->defrmargin; 162 term_tab_set(p, NULL); 163 term_tab_set(p, "T"); 164 term_tab_set(p, ".5i"); 165 166 memset(&mt, 0, sizeof(mt)); 167 mt.lmargin[mt.lmargincur] = term_len(p, p->defindent); 168 mt.offset = term_len(p, p->defindent); 169 mt.pardist = 1; 170 171 n = man->first->child; 172 if (p->synopsisonly) { 173 for (nn = NULL; n != NULL; n = n->next) { 174 if (n->tok != MAN_SH) 175 continue; 176 nc = n->child->child; 177 if (nc->type != ROFFT_TEXT) 178 continue; 179 if (strcmp(nc->string, "SYNOPSIS") == 0) 180 break; 181 if (nn == NULL && strcmp(nc->string, "NAME") == 0) 182 nn = n; 183 } 184 if (n == NULL) 185 n = nn; 186 p->flags |= TERMP_NOSPACE; 187 if (n != NULL && (n = n->child->next->child) != NULL) 188 print_man_nodelist(p, &mt, n, man); 189 term_newln(p); 190 } else { 191 term_begin(p, print_man_head, print_man_foot, man); 192 p->flags |= TERMP_NOSPACE; 193 if (n != NULL) 194 print_man_nodelist(p, &mt, n, man); 195 term_end(p); 196 } 197 p->defindent = save_defindent; 198 } 199 200 /* 201 * Printing leading vertical space before a block. 202 * This is used for the paragraph macros. 203 * The rules are pretty simple, since there's very little nesting going 204 * on here. Basically, if we're the first within another block (SS/SH), 205 * then don't emit vertical space. If we are (RS), then do. If not the 206 * first, print it. 207 */ 208 static void 209 print_bvspace(struct termp *p, struct roff_node *n, int pardist) 210 { 211 struct roff_node *nch; 212 int i; 213 214 term_newln(p); 215 216 if (n->body != NULL && 217 (nch = roff_node_child(n->body)) != NULL && 218 nch->type == ROFFT_TBL) 219 return; 220 221 if (n->parent->tok != MAN_RS && roff_node_prev(n) == NULL) 222 return; 223 224 for (i = 0; i < pardist; i++) 225 term_vspace(p); 226 } 227 228 229 static int 230 pre_abort(DECL_ARGS) 231 { 232 abort(); 233 } 234 235 static int 236 pre_ign(DECL_ARGS) 237 { 238 return 0; 239 } 240 241 static int 242 pre_I(DECL_ARGS) 243 { 244 term_fontrepl(p, TERMFONT_UNDER); 245 return 1; 246 } 247 248 static int 249 pre_literal(DECL_ARGS) 250 { 251 term_newln(p); 252 253 /* 254 * Unlike .IP and .TP, .HP does not have a HEAD. 255 * So in case a second call to term_flushln() is needed, 256 * indentation has to be set up explicitly. 257 */ 258 if (n->parent->tok == MAN_HP && p->tcol->rmargin < p->maxrmargin) { 259 p->tcol->offset = p->tcol->rmargin; 260 p->tcol->rmargin = p->maxrmargin; 261 p->trailspace = 0; 262 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND); 263 p->flags |= TERMP_NOSPACE; 264 } 265 return 0; 266 } 267 268 static int 269 pre_PD(DECL_ARGS) 270 { 271 struct roffsu su; 272 273 n = n->child; 274 if (n == NULL) { 275 mt->pardist = 1; 276 return 0; 277 } 278 assert(n->type == ROFFT_TEXT); 279 if (a2roffsu(n->string, &su, SCALE_VS) != NULL) 280 mt->pardist = term_vspan(p, &su); 281 return 0; 282 } 283 284 static int 285 pre_alternate(DECL_ARGS) 286 { 287 enum termfont font[2]; 288 struct roff_node *nn; 289 int i; 290 291 switch (n->tok) { 292 case MAN_RB: 293 font[0] = TERMFONT_NONE; 294 font[1] = TERMFONT_BOLD; 295 break; 296 case MAN_RI: 297 font[0] = TERMFONT_NONE; 298 font[1] = TERMFONT_UNDER; 299 break; 300 case MAN_BR: 301 font[0] = TERMFONT_BOLD; 302 font[1] = TERMFONT_NONE; 303 break; 304 case MAN_BI: 305 font[0] = TERMFONT_BOLD; 306 font[1] = TERMFONT_UNDER; 307 break; 308 case MAN_IR: 309 font[0] = TERMFONT_UNDER; 310 font[1] = TERMFONT_NONE; 311 break; 312 case MAN_IB: 313 font[0] = TERMFONT_UNDER; 314 font[1] = TERMFONT_BOLD; 315 break; 316 default: 317 abort(); 318 } 319 for (i = 0, nn = n->child; nn != NULL; nn = nn->next, i = 1 - i) { 320 term_fontrepl(p, font[i]); 321 assert(nn->type == ROFFT_TEXT); 322 term_word(p, nn->string); 323 if (nn->flags & NODE_EOS) 324 p->flags |= TERMP_SENTENCE; 325 if (nn->next != NULL) 326 p->flags |= TERMP_NOSPACE; 327 } 328 return 0; 329 } 330 331 static int 332 pre_B(DECL_ARGS) 333 { 334 term_fontrepl(p, TERMFONT_BOLD); 335 return 1; 336 } 337 338 static int 339 pre_OP(DECL_ARGS) 340 { 341 term_word(p, "["); 342 p->flags |= TERMP_KEEP | TERMP_NOSPACE; 343 344 if ((n = n->child) != NULL) { 345 term_fontrepl(p, TERMFONT_BOLD); 346 term_word(p, n->string); 347 } 348 if (n != NULL && n->next != NULL) { 349 term_fontrepl(p, TERMFONT_UNDER); 350 term_word(p, n->next->string); 351 } 352 term_fontrepl(p, TERMFONT_NONE); 353 p->flags &= ~TERMP_KEEP; 354 p->flags |= TERMP_NOSPACE; 355 term_word(p, "]"); 356 return 0; 357 } 358 359 static int 360 pre_in(DECL_ARGS) 361 { 362 struct roffsu su; 363 const char *cp; 364 size_t v; 365 int less; 366 367 term_newln(p); 368 369 if (n->child == NULL) { 370 p->tcol->offset = mt->offset; 371 return 0; 372 } 373 374 cp = n->child->string; 375 less = 0; 376 377 if (*cp == '-') 378 less = -1; 379 else if (*cp == '+') 380 less = 1; 381 else 382 cp--; 383 384 if (a2roffsu(++cp, &su, SCALE_EN) == NULL) 385 return 0; 386 387 v = term_hen(p, &su); 388 389 if (less < 0) 390 p->tcol->offset -= p->tcol->offset > v ? v : p->tcol->offset; 391 else if (less > 0) 392 p->tcol->offset += v; 393 else 394 p->tcol->offset = v; 395 if (p->tcol->offset > SHRT_MAX) 396 p->tcol->offset = term_len(p, p->defindent); 397 398 return 0; 399 } 400 401 static int 402 pre_DT(DECL_ARGS) 403 { 404 term_tab_set(p, NULL); 405 term_tab_set(p, "T"); 406 term_tab_set(p, ".5i"); 407 return 0; 408 } 409 410 static int 411 pre_HP(DECL_ARGS) 412 { 413 struct roffsu su; 414 const struct roff_node *nn; 415 int len; 416 417 switch (n->type) { 418 case ROFFT_BLOCK: 419 print_bvspace(p, n, mt->pardist); 420 return 1; 421 case ROFFT_HEAD: 422 return 0; 423 case ROFFT_BODY: 424 break; 425 default: 426 abort(); 427 } 428 429 if (n->child == NULL) 430 return 0; 431 432 if ((n->child->flags & NODE_NOFILL) == 0) { 433 p->flags |= TERMP_NOBREAK | TERMP_BRIND; 434 p->trailspace = 2; 435 } 436 437 /* Calculate offset. */ 438 439 if ((nn = n->parent->head->child) != NULL && 440 a2roffsu(nn->string, &su, SCALE_EN) != NULL) { 441 len = term_hen(p, &su); 442 if (len < 0 && (size_t)(-len) > mt->offset) 443 len = -mt->offset; 444 else if (len > SHRT_MAX) 445 len = term_len(p, p->defindent); 446 mt->lmargin[mt->lmargincur] = len; 447 } else 448 len = mt->lmargin[mt->lmargincur]; 449 450 p->tcol->offset = mt->offset; 451 p->tcol->rmargin = mt->offset + len; 452 return 1; 453 } 454 455 static void 456 post_HP(DECL_ARGS) 457 { 458 switch (n->type) { 459 case ROFFT_BLOCK: 460 case ROFFT_HEAD: 461 break; 462 case ROFFT_BODY: 463 term_newln(p); 464 465 /* 466 * Compatibility with a groff bug. 467 * The .HP macro uses the undocumented .tag request 468 * which causes a line break and cancels no-space 469 * mode even if there isn't any output. 470 */ 471 472 if (n->child == NULL) 473 term_vspace(p); 474 475 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND); 476 p->trailspace = 0; 477 p->tcol->offset = mt->offset; 478 p->tcol->rmargin = p->maxrmargin; 479 break; 480 default: 481 abort(); 482 } 483 } 484 485 static int 486 pre_PP(DECL_ARGS) 487 { 488 switch (n->type) { 489 case ROFFT_BLOCK: 490 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent); 491 print_bvspace(p, n, mt->pardist); 492 break; 493 case ROFFT_HEAD: 494 return 0; 495 case ROFFT_BODY: 496 p->tcol->offset = mt->offset; 497 break; 498 default: 499 abort(); 500 } 501 return 1; 502 } 503 504 static int 505 pre_IP(DECL_ARGS) 506 { 507 struct roffsu su; 508 const struct roff_node *nn; 509 int len; 510 511 switch (n->type) { 512 case ROFFT_BLOCK: 513 print_bvspace(p, n, mt->pardist); 514 return 1; 515 case ROFFT_HEAD: 516 p->flags |= TERMP_NOBREAK; 517 p->trailspace = 1; 518 break; 519 case ROFFT_BODY: 520 p->flags |= TERMP_NOSPACE; 521 break; 522 default: 523 abort(); 524 } 525 526 /* Calculate the offset from the optional second argument. */ 527 if ((nn = n->parent->head->child) != NULL && 528 (nn = nn->next) != NULL && 529 a2roffsu(nn->string, &su, SCALE_EN) != NULL) { 530 len = term_hen(p, &su); 531 if (len < 0 && (size_t)(-len) > mt->offset) 532 len = -mt->offset; 533 else if (len > SHRT_MAX) 534 len = term_len(p, p->defindent); 535 mt->lmargin[mt->lmargincur] = len; 536 } else 537 len = mt->lmargin[mt->lmargincur]; 538 539 switch (n->type) { 540 case ROFFT_HEAD: 541 p->tcol->offset = mt->offset; 542 p->tcol->rmargin = mt->offset + len; 543 if (n->child != NULL) 544 print_man_node(p, mt, n->child, meta); 545 return 0; 546 case ROFFT_BODY: 547 p->tcol->offset = mt->offset + len; 548 p->tcol->rmargin = p->maxrmargin; 549 break; 550 default: 551 abort(); 552 } 553 return 1; 554 } 555 556 static void 557 post_IP(DECL_ARGS) 558 { 559 switch (n->type) { 560 case ROFFT_BLOCK: 561 break; 562 case ROFFT_HEAD: 563 term_flushln(p); 564 p->flags &= ~TERMP_NOBREAK; 565 p->trailspace = 0; 566 p->tcol->rmargin = p->maxrmargin; 567 break; 568 case ROFFT_BODY: 569 term_newln(p); 570 p->tcol->offset = mt->offset; 571 break; 572 default: 573 abort(); 574 } 575 } 576 577 static int 578 pre_TP(DECL_ARGS) 579 { 580 struct roffsu su; 581 struct roff_node *nn; 582 int len; 583 584 switch (n->type) { 585 case ROFFT_BLOCK: 586 if (n->tok == MAN_TP) 587 print_bvspace(p, n, mt->pardist); 588 return 1; 589 case ROFFT_HEAD: 590 p->flags |= TERMP_NOBREAK | TERMP_BRTRSP; 591 p->trailspace = 1; 592 break; 593 case ROFFT_BODY: 594 p->flags |= TERMP_NOSPACE; 595 break; 596 default: 597 abort(); 598 } 599 600 /* Calculate offset. */ 601 602 if ((nn = n->parent->head->child) != NULL && 603 nn->string != NULL && ! (NODE_LINE & nn->flags) && 604 a2roffsu(nn->string, &su, SCALE_EN) != NULL) { 605 len = term_hen(p, &su); 606 if (len < 0 && (size_t)(-len) > mt->offset) 607 len = -mt->offset; 608 else if (len > SHRT_MAX) 609 len = term_len(p, p->defindent); 610 mt->lmargin[mt->lmargincur] = len; 611 } else 612 len = mt->lmargin[mt->lmargincur]; 613 614 switch (n->type) { 615 case ROFFT_HEAD: 616 p->tcol->offset = mt->offset; 617 p->tcol->rmargin = mt->offset + len; 618 619 /* Don't print same-line elements. */ 620 nn = n->child; 621 while (nn != NULL && (nn->flags & NODE_LINE) == 0) 622 nn = nn->next; 623 624 while (nn != NULL) { 625 print_man_node(p, mt, nn, meta); 626 nn = nn->next; 627 } 628 return 0; 629 case ROFFT_BODY: 630 p->tcol->offset = mt->offset + len; 631 p->tcol->rmargin = p->maxrmargin; 632 p->trailspace = 0; 633 p->flags &= ~(TERMP_NOBREAK | TERMP_BRTRSP); 634 break; 635 default: 636 abort(); 637 } 638 return 1; 639 } 640 641 static void 642 post_TP(DECL_ARGS) 643 { 644 switch (n->type) { 645 case ROFFT_BLOCK: 646 break; 647 case ROFFT_HEAD: 648 term_flushln(p); 649 break; 650 case ROFFT_BODY: 651 term_newln(p); 652 p->tcol->offset = mt->offset; 653 break; 654 default: 655 abort(); 656 } 657 } 658 659 static int 660 pre_SS(DECL_ARGS) 661 { 662 int i; 663 664 switch (n->type) { 665 case ROFFT_BLOCK: 666 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent); 667 mt->offset = term_len(p, p->defindent); 668 669 /* 670 * No vertical space before the first subsection 671 * and after an empty subsection. 672 */ 673 674 if ((n = roff_node_prev(n)) == NULL || 675 (n->tok == MAN_SS && roff_node_child(n->body) == NULL)) 676 break; 677 678 for (i = 0; i < mt->pardist; i++) 679 term_vspace(p); 680 break; 681 case ROFFT_HEAD: 682 term_fontrepl(p, TERMFONT_BOLD); 683 p->tcol->offset = term_len(p, 3); 684 p->tcol->rmargin = mt->offset; 685 p->trailspace = mt->offset; 686 p->flags |= TERMP_NOBREAK | TERMP_BRIND; 687 break; 688 case ROFFT_BODY: 689 p->tcol->offset = mt->offset; 690 p->tcol->rmargin = p->maxrmargin; 691 p->trailspace = 0; 692 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND); 693 break; 694 default: 695 break; 696 } 697 return 1; 698 } 699 700 static int 701 pre_SH(DECL_ARGS) 702 { 703 int i; 704 705 switch (n->type) { 706 case ROFFT_BLOCK: 707 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent); 708 mt->offset = term_len(p, p->defindent); 709 710 /* 711 * No vertical space before the first section 712 * and after an empty section. 713 */ 714 715 if ((n = roff_node_prev(n)) == NULL || 716 (n->tok == MAN_SH && roff_node_child(n->body) == NULL)) 717 break; 718 719 for (i = 0; i < mt->pardist; i++) 720 term_vspace(p); 721 break; 722 case ROFFT_HEAD: 723 term_fontrepl(p, TERMFONT_BOLD); 724 p->tcol->offset = 0; 725 p->tcol->rmargin = mt->offset; 726 p->trailspace = mt->offset; 727 p->flags |= TERMP_NOBREAK | TERMP_BRIND; 728 break; 729 case ROFFT_BODY: 730 p->tcol->offset = mt->offset; 731 p->tcol->rmargin = p->maxrmargin; 732 p->trailspace = 0; 733 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND); 734 break; 735 default: 736 abort(); 737 } 738 return 1; 739 } 740 741 static void 742 post_SH(DECL_ARGS) 743 { 744 switch (n->type) { 745 case ROFFT_BLOCK: 746 break; 747 case ROFFT_HEAD: 748 case ROFFT_BODY: 749 term_newln(p); 750 break; 751 default: 752 abort(); 753 } 754 } 755 756 static int 757 pre_RS(DECL_ARGS) 758 { 759 struct roffsu su; 760 761 switch (n->type) { 762 case ROFFT_BLOCK: 763 term_newln(p); 764 return 1; 765 case ROFFT_HEAD: 766 return 0; 767 case ROFFT_BODY: 768 break; 769 default: 770 abort(); 771 } 772 773 n = n->parent->head; 774 n->aux = SHRT_MAX + 1; 775 if (n->child == NULL) 776 n->aux = mt->lmargin[mt->lmargincur]; 777 else if (a2roffsu(n->child->string, &su, SCALE_EN) != NULL) 778 n->aux = term_hen(p, &su); 779 if (n->aux < 0 && (size_t)(-n->aux) > mt->offset) 780 n->aux = -mt->offset; 781 else if (n->aux > SHRT_MAX) 782 n->aux = term_len(p, p->defindent); 783 784 mt->offset += n->aux; 785 p->tcol->offset = mt->offset; 786 p->tcol->rmargin = p->maxrmargin; 787 788 if (++mt->lmarginsz < MAXMARGINS) 789 mt->lmargincur = mt->lmarginsz; 790 791 mt->lmargin[mt->lmargincur] = term_len(p, p->defindent); 792 return 1; 793 } 794 795 static void 796 post_RS(DECL_ARGS) 797 { 798 switch (n->type) { 799 case ROFFT_BLOCK: 800 case ROFFT_HEAD: 801 return; 802 case ROFFT_BODY: 803 break; 804 default: 805 abort(); 806 } 807 term_newln(p); 808 mt->offset -= n->parent->head->aux; 809 p->tcol->offset = mt->offset; 810 if (--mt->lmarginsz < MAXMARGINS) 811 mt->lmargincur = mt->lmarginsz; 812 } 813 814 static int 815 pre_SY(DECL_ARGS) 816 { 817 const struct roff_node *nn; 818 int len; 819 820 switch (n->type) { 821 case ROFFT_BLOCK: 822 if ((nn = roff_node_prev(n)) == NULL || nn->tok != MAN_SY) 823 print_bvspace(p, n, mt->pardist); 824 return 1; 825 case ROFFT_HEAD: 826 case ROFFT_BODY: 827 break; 828 default: 829 abort(); 830 } 831 832 nn = n->parent->head->child; 833 len = nn == NULL ? 1 : term_strlen(p, nn->string) + 1; 834 835 switch (n->type) { 836 case ROFFT_HEAD: 837 p->tcol->offset = mt->offset; 838 p->tcol->rmargin = mt->offset + len; 839 if (n->next->child == NULL || 840 (n->next->child->flags & NODE_NOFILL) == 0) 841 p->flags |= TERMP_NOBREAK; 842 term_fontrepl(p, TERMFONT_BOLD); 843 break; 844 case ROFFT_BODY: 845 mt->lmargin[mt->lmargincur] = len; 846 p->tcol->offset = mt->offset + len; 847 p->tcol->rmargin = p->maxrmargin; 848 p->flags |= TERMP_NOSPACE; 849 break; 850 default: 851 abort(); 852 } 853 return 1; 854 } 855 856 static void 857 post_SY(DECL_ARGS) 858 { 859 switch (n->type) { 860 case ROFFT_BLOCK: 861 break; 862 case ROFFT_HEAD: 863 term_flushln(p); 864 p->flags &= ~TERMP_NOBREAK; 865 break; 866 case ROFFT_BODY: 867 term_newln(p); 868 p->tcol->offset = mt->offset; 869 break; 870 default: 871 abort(); 872 } 873 } 874 875 static int 876 pre_UR(DECL_ARGS) 877 { 878 return n->type != ROFFT_HEAD; 879 } 880 881 static void 882 post_UR(DECL_ARGS) 883 { 884 if (n->type != ROFFT_BLOCK) 885 return; 886 887 term_word(p, "<"); 888 p->flags |= TERMP_NOSPACE; 889 890 if (n->child->child != NULL) 891 print_man_node(p, mt, n->child->child, meta); 892 893 p->flags |= TERMP_NOSPACE; 894 term_word(p, ">"); 895 } 896 897 static void 898 print_man_node(DECL_ARGS) 899 { 900 const struct man_term_act *act; 901 int c; 902 903 if (n->flags & NODE_ID) 904 term_tag_write(n, p->line); 905 906 switch (n->type) { 907 case ROFFT_TEXT: 908 /* 909 * If we have a blank line, output a vertical space. 910 * If we have a space as the first character, break 911 * before printing the line's data. 912 */ 913 if (*n->string == '\0') { 914 if (p->flags & TERMP_NONEWLINE) 915 term_newln(p); 916 else 917 term_vspace(p); 918 return; 919 } else if (*n->string == ' ' && n->flags & NODE_LINE && 920 (p->flags & TERMP_NONEWLINE) == 0) 921 term_newln(p); 922 else if (n->flags & NODE_DELIMC) 923 p->flags |= TERMP_NOSPACE; 924 925 term_word(p, n->string); 926 goto out; 927 case ROFFT_COMMENT: 928 return; 929 case ROFFT_EQN: 930 if ( ! (n->flags & NODE_LINE)) 931 p->flags |= TERMP_NOSPACE; 932 term_eqn(p, n->eqn); 933 if (n->next != NULL && ! (n->next->flags & NODE_LINE)) 934 p->flags |= TERMP_NOSPACE; 935 return; 936 case ROFFT_TBL: 937 if (p->tbl.cols == NULL) 938 term_vspace(p); 939 term_tbl(p, n->span); 940 return; 941 default: 942 break; 943 } 944 945 if (n->tok < ROFF_MAX) { 946 roff_term_pre(p, n); 947 return; 948 } 949 950 act = man_term_act(n->tok); 951 if ((act->flags & MAN_NOTEXT) == 0 && n->tok != MAN_SM) 952 term_fontrepl(p, TERMFONT_NONE); 953 954 c = 1; 955 if (act->pre != NULL) 956 c = (*act->pre)(p, mt, n, meta); 957 958 if (c && n->child != NULL) 959 print_man_nodelist(p, mt, n->child, meta); 960 961 if (act->post != NULL) 962 (*act->post)(p, mt, n, meta); 963 if ((act->flags & MAN_NOTEXT) == 0 && n->tok != MAN_SM) 964 term_fontrepl(p, TERMFONT_NONE); 965 966 out: 967 /* 968 * If we're in a literal context, make sure that words 969 * together on the same line stay together. This is a 970 * POST-printing call, so we check the NEXT word. Since 971 * -man doesn't have nested macros, we don't need to be 972 * more specific than this. 973 */ 974 if (n->flags & NODE_NOFILL && 975 ! (p->flags & (TERMP_NOBREAK | TERMP_NONEWLINE)) && 976 (n->next == NULL || n->next->flags & NODE_LINE)) { 977 p->flags |= TERMP_BRNEVER | TERMP_NOSPACE; 978 if (n->string != NULL && *n->string != '\0') 979 term_flushln(p); 980 else 981 term_newln(p); 982 p->flags &= ~TERMP_BRNEVER; 983 if (p->tcol->rmargin < p->maxrmargin && 984 n->parent->tok == MAN_HP) { 985 p->tcol->offset = p->tcol->rmargin; 986 p->tcol->rmargin = p->maxrmargin; 987 } 988 } 989 if (n->flags & NODE_EOS) 990 p->flags |= TERMP_SENTENCE; 991 } 992 993 static void 994 print_man_nodelist(DECL_ARGS) 995 { 996 while (n != NULL) { 997 print_man_node(p, mt, n, meta); 998 n = n->next; 999 } 1000 } 1001 1002 static void 1003 print_man_foot(struct termp *p, const struct roff_meta *meta) 1004 { 1005 char *title; 1006 size_t datelen, titlen; 1007 1008 assert(meta->title); 1009 assert(meta->msec); 1010 assert(meta->date); 1011 1012 term_fontrepl(p, TERMFONT_NONE); 1013 1014 if (meta->hasbody) 1015 term_vspace(p); 1016 1017 /* 1018 * Temporary, undocumented option to imitate mdoc(7) output. 1019 * In the bottom right corner, use the operating system 1020 * instead of the title. 1021 */ 1022 1023 if ( ! p->mdocstyle) { 1024 mandoc_asprintf(&title, "%s(%s)", 1025 meta->title, meta->msec); 1026 } else if (meta->os != NULL) { 1027 title = mandoc_strdup(meta->os); 1028 } else { 1029 title = mandoc_strdup(""); 1030 } 1031 datelen = term_strlen(p, meta->date); 1032 1033 /* Bottom left corner: operating system. */ 1034 1035 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK; 1036 p->trailspace = 1; 1037 p->tcol->offset = 0; 1038 p->tcol->rmargin = p->maxrmargin > datelen ? 1039 (p->maxrmargin + term_len(p, 1) - datelen) / 2 : 0; 1040 1041 if (meta->os) 1042 term_word(p, meta->os); 1043 term_flushln(p); 1044 1045 /* At the bottom in the middle: manual date. */ 1046 1047 p->tcol->offset = p->tcol->rmargin; 1048 titlen = term_strlen(p, title); 1049 p->tcol->rmargin = p->maxrmargin > titlen ? 1050 p->maxrmargin - titlen : 0; 1051 p->flags |= TERMP_NOSPACE; 1052 1053 term_word(p, meta->date); 1054 term_flushln(p); 1055 1056 /* Bottom right corner: manual title and section. */ 1057 1058 p->flags &= ~TERMP_NOBREAK; 1059 p->flags |= TERMP_NOSPACE; 1060 p->trailspace = 0; 1061 p->tcol->offset = p->tcol->rmargin; 1062 p->tcol->rmargin = p->maxrmargin; 1063 1064 term_word(p, title); 1065 term_flushln(p); 1066 1067 /* 1068 * Reset the terminal state for more output after the footer: 1069 * Some output modes, in particular PostScript and PDF, print 1070 * the header and the footer into a buffer such that it can be 1071 * reused for multiple output pages, then go on to format the 1072 * main text. 1073 */ 1074 1075 p->tcol->offset = 0; 1076 p->flags = 0; 1077 1078 free(title); 1079 } 1080 1081 static void 1082 print_man_head(struct termp *p, const struct roff_meta *meta) 1083 { 1084 const char *volume; 1085 char *title; 1086 size_t vollen, titlen; 1087 1088 assert(meta->title); 1089 assert(meta->msec); 1090 1091 volume = NULL == meta->vol ? "" : meta->vol; 1092 vollen = term_strlen(p, volume); 1093 1094 /* Top left corner: manual title and section. */ 1095 1096 mandoc_asprintf(&title, "%s(%s)", meta->title, meta->msec); 1097 titlen = term_strlen(p, title); 1098 1099 p->flags |= TERMP_NOBREAK | TERMP_NOSPACE; 1100 p->trailspace = 1; 1101 p->tcol->offset = 0; 1102 p->tcol->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ? 1103 (p->maxrmargin - vollen + term_len(p, 1)) / 2 : 1104 vollen < p->maxrmargin ? p->maxrmargin - vollen : 0; 1105 1106 term_word(p, title); 1107 term_flushln(p); 1108 1109 /* At the top in the middle: manual volume. */ 1110 1111 p->flags |= TERMP_NOSPACE; 1112 p->tcol->offset = p->tcol->rmargin; 1113 p->tcol->rmargin = p->tcol->offset + vollen + titlen < 1114 p->maxrmargin ? p->maxrmargin - titlen : p->maxrmargin; 1115 1116 term_word(p, volume); 1117 term_flushln(p); 1118 1119 /* Top right corner: title and section, again. */ 1120 1121 p->flags &= ~TERMP_NOBREAK; 1122 p->trailspace = 0; 1123 if (p->tcol->rmargin + titlen <= p->maxrmargin) { 1124 p->flags |= TERMP_NOSPACE; 1125 p->tcol->offset = p->tcol->rmargin; 1126 p->tcol->rmargin = p->maxrmargin; 1127 term_word(p, title); 1128 term_flushln(p); 1129 } 1130 1131 p->flags &= ~TERMP_NOSPACE; 1132 p->tcol->offset = 0; 1133 p->tcol->rmargin = p->maxrmargin; 1134 1135 /* 1136 * Groff prints three blank lines before the content. 1137 * Do the same, except in the temporary, undocumented 1138 * mode imitating mdoc(7) output. 1139 */ 1140 1141 term_vspace(p); 1142 free(title); 1143 } 1144