man_term.c revision 1.1.1.1
1 /* $Vendor-Id: man_term.c,v 1.41 2009/10/18 19:17:14 kristaps Exp $ */ 2 /* 3 * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps (at) kth.se> 4 * 5 * Permission to use, copy, modify, and distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 #include <sys/types.h> 18 19 #include <assert.h> 20 #include <ctype.h> 21 #include <err.h> 22 #include <stdio.h> 23 #include <stdlib.h> 24 #include <string.h> 25 26 #include "out.h" 27 #include "man.h" 28 #include "term.h" 29 #include "chars.h" 30 #include "main.h" 31 32 #define INDENT 7 33 #define HALFINDENT 3 34 35 struct mtermp { 36 int fl; 37 #define MANT_LITERAL (1 << 0) 38 /* 39 * Default amount to indent the left margin after leading text 40 * has been printed (e.g., `HP' left-indent, `TP' and `IP' body 41 * indent). This needs to be saved because `HP' and so on, if 42 * not having a specified value, must default. 43 * 44 * Note that this is the indentation AFTER the left offset, so 45 * the total offset is usually offset + lmargin. 46 */ 47 size_t lmargin; 48 /* 49 * The default offset, i.e., the amount between any text and the 50 * page boundary. 51 */ 52 size_t offset; 53 }; 54 55 #define DECL_ARGS struct termp *p, \ 56 struct mtermp *mt, \ 57 const struct man_node *n, \ 58 const struct man_meta *m 59 60 struct termact { 61 int (*pre)(DECL_ARGS); 62 void (*post)(DECL_ARGS); 63 }; 64 65 #ifdef __linux__ 66 extern size_t strlcpy(char *, const char *, size_t); 67 extern size_t strlcat(char *, const char *, size_t); 68 #endif 69 70 static int arg2width(const struct man_node *); 71 static int arg2height(const struct man_node *); 72 73 static void print_head(struct termp *, 74 const struct man_meta *); 75 static void print_body(DECL_ARGS); 76 static void print_node(DECL_ARGS); 77 static void print_foot(struct termp *, 78 const struct man_meta *); 79 static void print_bvspace(struct termp *, 80 const struct man_node *); 81 82 static int pre_B(DECL_ARGS); 83 static int pre_BI(DECL_ARGS); 84 static int pre_HP(DECL_ARGS); 85 static int pre_I(DECL_ARGS); 86 static int pre_IP(DECL_ARGS); 87 static int pre_IR(DECL_ARGS); 88 static int pre_PP(DECL_ARGS); 89 static int pre_RB(DECL_ARGS); 90 static int pre_RI(DECL_ARGS); 91 static int pre_RS(DECL_ARGS); 92 static int pre_SH(DECL_ARGS); 93 static int pre_SS(DECL_ARGS); 94 static int pre_TP(DECL_ARGS); 95 static int pre_br(DECL_ARGS); 96 static int pre_fi(DECL_ARGS); 97 static int pre_ign(DECL_ARGS); 98 static int pre_nf(DECL_ARGS); 99 static int pre_r(DECL_ARGS); 100 static int pre_sp(DECL_ARGS); 101 102 static void post_B(DECL_ARGS); 103 static void post_I(DECL_ARGS); 104 static void post_IP(DECL_ARGS); 105 static void post_HP(DECL_ARGS); 106 static void post_RS(DECL_ARGS); 107 static void post_SH(DECL_ARGS); 108 static void post_SS(DECL_ARGS); 109 static void post_TP(DECL_ARGS); 110 static void post_i(DECL_ARGS); 111 112 static const struct termact termacts[MAN_MAX] = { 113 { pre_br, NULL }, /* br */ 114 { NULL, NULL }, /* TH */ 115 { pre_SH, post_SH }, /* SH */ 116 { pre_SS, post_SS }, /* SS */ 117 { pre_TP, post_TP }, /* TP */ 118 { pre_PP, NULL }, /* LP */ 119 { pre_PP, NULL }, /* PP */ 120 { pre_PP, NULL }, /* P */ 121 { pre_IP, post_IP }, /* IP */ 122 { pre_HP, post_HP }, /* HP */ 123 { NULL, NULL }, /* SM */ 124 { pre_B, post_B }, /* SB */ 125 { pre_BI, NULL }, /* BI */ 126 { pre_BI, NULL }, /* IB */ 127 { pre_RB, NULL }, /* BR */ 128 { pre_RB, NULL }, /* RB */ 129 { NULL, NULL }, /* R */ 130 { pre_B, post_B }, /* B */ 131 { pre_I, post_I }, /* I */ 132 { pre_IR, NULL }, /* IR */ 133 { pre_RI, NULL }, /* RI */ 134 { NULL, NULL }, /* na */ 135 { pre_I, post_i }, /* i */ 136 { pre_sp, NULL }, /* sp */ 137 { pre_nf, NULL }, /* nf */ 138 { pre_fi, NULL }, /* fi */ 139 { pre_r, NULL }, /* r */ 140 { NULL, NULL }, /* RE */ 141 { pre_RS, post_RS }, /* RS */ 142 { pre_ign, NULL }, /* DT */ 143 { pre_ign, NULL }, /* UC */ 144 }; 145 146 147 148 void 149 terminal_man(void *arg, const struct man *man) 150 { 151 struct termp *p; 152 const struct man_node *n; 153 const struct man_meta *m; 154 struct mtermp mt; 155 156 p = (struct termp *)arg; 157 158 if (NULL == p->symtab) 159 switch (p->enc) { 160 case (TERMENC_ASCII): 161 p->symtab = chars_init(CHARS_ASCII); 162 break; 163 default: 164 abort(); 165 /* NOTREACHED */ 166 } 167 168 n = man_node(man); 169 m = man_meta(man); 170 171 print_head(p, m); 172 p->flags |= TERMP_NOSPACE; 173 174 mt.fl = 0; 175 mt.lmargin = INDENT; 176 mt.offset = INDENT; 177 178 if (n->child) 179 print_body(p, &mt, n->child, m); 180 print_foot(p, m); 181 } 182 183 184 static int 185 arg2height(const struct man_node *n) 186 { 187 struct roffsu su; 188 189 assert(MAN_TEXT == n->type); 190 assert(n->string); 191 if ( ! a2roffsu(n->string, &su, SCALE_VS)) 192 SCALE_VS_INIT(&su, strlen(n->string)); 193 194 return((int)term_vspan(&su)); 195 } 196 197 198 static int 199 arg2width(const struct man_node *n) 200 { 201 struct roffsu su; 202 203 assert(MAN_TEXT == n->type); 204 assert(n->string); 205 if ( ! a2roffsu(n->string, &su, SCALE_BU)) 206 return(-1); 207 208 return((int)term_hspan(&su)); 209 } 210 211 212 static void 213 print_bvspace(struct termp *p, const struct man_node *n) 214 { 215 term_newln(p); 216 217 if (NULL == n->prev) 218 return; 219 220 if (MAN_SS == n->prev->tok) 221 return; 222 if (MAN_SH == n->prev->tok) 223 return; 224 225 term_vspace(p); 226 } 227 228 229 /* ARGSUSED */ 230 static int 231 pre_ign(DECL_ARGS) 232 { 233 234 return(0); 235 } 236 237 238 /* ARGSUSED */ 239 static int 240 pre_I(DECL_ARGS) 241 { 242 243 p->under++; 244 return(1); 245 } 246 247 248 /* ARGSUSED */ 249 static int 250 pre_r(DECL_ARGS) 251 { 252 253 p->bold = p->under = 0; 254 return(1); 255 } 256 257 258 /* ARGSUSED */ 259 static void 260 post_i(DECL_ARGS) 261 { 262 263 if (n->nchild) 264 p->under--; 265 } 266 267 268 /* ARGSUSED */ 269 static void 270 post_I(DECL_ARGS) 271 { 272 273 p->under--; 274 } 275 276 277 /* ARGSUSED */ 278 static int 279 pre_fi(DECL_ARGS) 280 { 281 282 mt->fl &= ~MANT_LITERAL; 283 return(1); 284 } 285 286 287 /* ARGSUSED */ 288 static int 289 pre_nf(DECL_ARGS) 290 { 291 292 term_newln(p); 293 mt->fl |= MANT_LITERAL; 294 return(1); 295 } 296 297 298 /* ARGSUSED */ 299 static int 300 pre_IR(DECL_ARGS) 301 { 302 const struct man_node *nn; 303 int i; 304 305 for (i = 0, nn = n->child; nn; nn = nn->next, i++) { 306 if ( ! (i % 2)) 307 p->under++; 308 if (i > 0) 309 p->flags |= TERMP_NOSPACE; 310 print_node(p, mt, nn, m); 311 if ( ! (i % 2)) 312 p->under--; 313 } 314 return(0); 315 } 316 317 318 /* ARGSUSED */ 319 static int 320 pre_RB(DECL_ARGS) 321 { 322 const struct man_node *nn; 323 int i; 324 325 for (i = 0, nn = n->child; nn; nn = nn->next, i++) { 326 if (i % 2 && MAN_RB == n->tok) 327 p->bold++; 328 else if ( ! (i % 2) && MAN_RB != n->tok) 329 p->bold++; 330 331 if (i > 0) 332 p->flags |= TERMP_NOSPACE; 333 334 print_node(p, mt, nn, m); 335 336 if (i % 2 && MAN_RB == n->tok) 337 p->bold--; 338 else if ( ! (i % 2) && MAN_RB != n->tok) 339 p->bold--; 340 } 341 return(0); 342 } 343 344 345 /* ARGSUSED */ 346 static int 347 pre_RI(DECL_ARGS) 348 { 349 const struct man_node *nn; 350 int i; 351 352 for (i = 0, nn = n->child; nn; nn = nn->next, i++) { 353 if ( ! (i % 2)) 354 p->under++; 355 if (i > 0) 356 p->flags |= TERMP_NOSPACE; 357 print_node(p, mt, nn, m); 358 if ( ! (i % 2)) 359 p->under--; 360 } 361 return(0); 362 } 363 364 365 /* ARGSUSED */ 366 static int 367 pre_BI(DECL_ARGS) 368 { 369 const struct man_node *nn; 370 int i; 371 372 for (i = 0, nn = n->child; nn; nn = nn->next, i++) { 373 if (i % 2 && MAN_BI == n->tok) 374 p->under++; 375 else if (i % 2) 376 p->bold++; 377 else if (MAN_BI == n->tok) 378 p->bold++; 379 else 380 p->under++; 381 382 if (i) 383 p->flags |= TERMP_NOSPACE; 384 print_node(p, mt, nn, m); 385 386 if (i % 2 && MAN_BI == n->tok) 387 p->under--; 388 else if (i % 2) 389 p->bold--; 390 else if (MAN_BI == n->tok) 391 p->bold--; 392 else 393 p->under--; 394 } 395 return(0); 396 } 397 398 399 /* ARGSUSED */ 400 static int 401 pre_B(DECL_ARGS) 402 { 403 404 p->bold++; 405 return(1); 406 } 407 408 409 /* ARGSUSED */ 410 static void 411 post_B(DECL_ARGS) 412 { 413 414 p->bold--; 415 } 416 417 418 /* ARGSUSED */ 419 static int 420 pre_sp(DECL_ARGS) 421 { 422 int i, len; 423 424 len = n->child ? arg2height(n->child) : 1; 425 426 if (0 == len) 427 term_newln(p); 428 for (i = 0; i < len; i++) 429 term_vspace(p); 430 431 return(0); 432 } 433 434 435 /* ARGSUSED */ 436 static int 437 pre_br(DECL_ARGS) 438 { 439 440 term_newln(p); 441 return(0); 442 } 443 444 445 /* ARGSUSED */ 446 static int 447 pre_HP(DECL_ARGS) 448 { 449 size_t len; 450 int ival; 451 const struct man_node *nn; 452 453 switch (n->type) { 454 case (MAN_BLOCK): 455 print_bvspace(p, n); 456 return(1); 457 case (MAN_BODY): 458 p->flags |= TERMP_NOBREAK; 459 p->flags |= TERMP_TWOSPACE; 460 break; 461 default: 462 return(0); 463 } 464 465 len = mt->lmargin; 466 ival = -1; 467 468 /* Calculate offset. */ 469 470 if (NULL != (nn = n->parent->head->child)) 471 if ((ival = arg2width(nn)) >= 0) 472 len = (size_t)ival; 473 474 if (0 == len) 475 len = 1; 476 477 p->offset = mt->offset; 478 p->rmargin = mt->offset + len; 479 480 if (ival >= 0) 481 mt->lmargin = (size_t)ival; 482 483 return(1); 484 } 485 486 487 /* ARGSUSED */ 488 static void 489 post_HP(DECL_ARGS) 490 { 491 492 switch (n->type) { 493 case (MAN_BLOCK): 494 term_flushln(p); 495 break; 496 case (MAN_BODY): 497 term_flushln(p); 498 p->flags &= ~TERMP_NOBREAK; 499 p->flags &= ~TERMP_TWOSPACE; 500 p->offset = mt->offset; 501 p->rmargin = p->maxrmargin; 502 break; 503 default: 504 break; 505 } 506 } 507 508 509 /* ARGSUSED */ 510 static int 511 pre_PP(DECL_ARGS) 512 { 513 514 switch (n->type) { 515 case (MAN_BLOCK): 516 mt->lmargin = INDENT; 517 print_bvspace(p, n); 518 break; 519 default: 520 p->offset = mt->offset; 521 break; 522 } 523 524 return(1); 525 } 526 527 528 /* ARGSUSED */ 529 static int 530 pre_IP(DECL_ARGS) 531 { 532 const struct man_node *nn; 533 size_t len; 534 int ival; 535 536 switch (n->type) { 537 case (MAN_BODY): 538 p->flags |= TERMP_NOLPAD; 539 p->flags |= TERMP_NOSPACE; 540 break; 541 case (MAN_HEAD): 542 p->flags |= TERMP_NOBREAK; 543 p->flags |= TERMP_TWOSPACE; 544 break; 545 case (MAN_BLOCK): 546 print_bvspace(p, n); 547 /* FALLTHROUGH */ 548 default: 549 return(1); 550 } 551 552 len = mt->lmargin; 553 ival = -1; 554 555 /* Calculate offset. */ 556 557 if (NULL != (nn = n->parent->head->child)) 558 if (NULL != (nn = nn->next)) { 559 for ( ; nn->next; nn = nn->next) 560 /* Do nothing. */ ; 561 if ((ival = arg2width(nn)) >= 0) 562 len = (size_t)ival; 563 } 564 565 switch (n->type) { 566 case (MAN_HEAD): 567 /* Handle zero-width lengths. */ 568 if (0 == len) 569 len = 1; 570 571 p->offset = mt->offset; 572 p->rmargin = mt->offset + len; 573 if (ival < 0) 574 break; 575 576 /* Set the saved left-margin. */ 577 mt->lmargin = (size_t)ival; 578 579 /* Don't print the length value. */ 580 for (nn = n->child; nn->next; nn = nn->next) 581 print_node(p, mt, nn, m); 582 return(0); 583 case (MAN_BODY): 584 p->offset = mt->offset + len; 585 p->rmargin = p->maxrmargin; 586 break; 587 default: 588 break; 589 } 590 591 return(1); 592 } 593 594 595 /* ARGSUSED */ 596 static void 597 post_IP(DECL_ARGS) 598 { 599 600 switch (n->type) { 601 case (MAN_HEAD): 602 term_flushln(p); 603 p->flags &= ~TERMP_NOBREAK; 604 p->flags &= ~TERMP_TWOSPACE; 605 p->rmargin = p->maxrmargin; 606 break; 607 case (MAN_BODY): 608 term_flushln(p); 609 p->flags &= ~TERMP_NOLPAD; 610 break; 611 default: 612 break; 613 } 614 } 615 616 617 /* ARGSUSED */ 618 static int 619 pre_TP(DECL_ARGS) 620 { 621 const struct man_node *nn; 622 size_t len; 623 int ival; 624 625 switch (n->type) { 626 case (MAN_HEAD): 627 p->flags |= TERMP_NOBREAK; 628 p->flags |= TERMP_TWOSPACE; 629 break; 630 case (MAN_BODY): 631 p->flags |= TERMP_NOLPAD; 632 p->flags |= TERMP_NOSPACE; 633 break; 634 case (MAN_BLOCK): 635 print_bvspace(p, n); 636 /* FALLTHROUGH */ 637 default: 638 return(1); 639 } 640 641 len = (size_t)mt->lmargin; 642 ival = -1; 643 644 /* Calculate offset. */ 645 646 if (NULL != (nn = n->parent->head->child)) 647 if (NULL != nn->next) 648 if ((ival = arg2width(nn)) >= 0) 649 len = (size_t)ival; 650 651 switch (n->type) { 652 case (MAN_HEAD): 653 /* Handle zero-length properly. */ 654 if (0 == len) 655 len = 1; 656 657 p->offset = mt->offset; 658 p->rmargin = mt->offset + len; 659 660 /* Don't print same-line elements. */ 661 for (nn = n->child; nn; nn = nn->next) 662 if (nn->line > n->line) 663 print_node(p, mt, nn, m); 664 665 if (ival >= 0) 666 mt->lmargin = (size_t)ival; 667 668 return(0); 669 case (MAN_BODY): 670 p->offset = mt->offset + len; 671 p->rmargin = p->maxrmargin; 672 break; 673 default: 674 break; 675 } 676 677 return(1); 678 } 679 680 681 /* ARGSUSED */ 682 static void 683 post_TP(DECL_ARGS) 684 { 685 686 switch (n->type) { 687 case (MAN_HEAD): 688 term_flushln(p); 689 p->flags &= ~TERMP_NOBREAK; 690 p->flags &= ~TERMP_TWOSPACE; 691 p->rmargin = p->maxrmargin; 692 break; 693 case (MAN_BODY): 694 term_flushln(p); 695 p->flags &= ~TERMP_NOLPAD; 696 break; 697 default: 698 break; 699 } 700 } 701 702 703 /* ARGSUSED */ 704 static int 705 pre_SS(DECL_ARGS) 706 { 707 708 switch (n->type) { 709 case (MAN_BLOCK): 710 mt->lmargin = INDENT; 711 mt->offset = INDENT; 712 /* If following a prior empty `SS', no vspace. */ 713 if (n->prev && MAN_SS == n->prev->tok) 714 if (NULL == n->prev->body->child) 715 break; 716 if (NULL == n->prev) 717 break; 718 term_vspace(p); 719 break; 720 case (MAN_HEAD): 721 p->bold++; 722 p->offset = HALFINDENT; 723 break; 724 case (MAN_BODY): 725 p->offset = mt->offset; 726 break; 727 default: 728 break; 729 } 730 731 return(1); 732 } 733 734 735 /* ARGSUSED */ 736 static void 737 post_SS(DECL_ARGS) 738 { 739 740 switch (n->type) { 741 case (MAN_HEAD): 742 term_newln(p); 743 p->bold--; 744 break; 745 case (MAN_BODY): 746 term_newln(p); 747 break; 748 default: 749 break; 750 } 751 } 752 753 754 /* ARGSUSED */ 755 static int 756 pre_SH(DECL_ARGS) 757 { 758 759 switch (n->type) { 760 case (MAN_BLOCK): 761 mt->lmargin = INDENT; 762 mt->offset = INDENT; 763 /* If following a prior empty `SH', no vspace. */ 764 if (n->prev && MAN_SH == n->prev->tok) 765 if (NULL == n->prev->body->child) 766 break; 767 term_vspace(p); 768 break; 769 case (MAN_HEAD): 770 p->bold++; 771 p->offset = 0; 772 break; 773 case (MAN_BODY): 774 p->offset = mt->offset; 775 break; 776 default: 777 break; 778 } 779 780 return(1); 781 } 782 783 784 /* ARGSUSED */ 785 static void 786 post_SH(DECL_ARGS) 787 { 788 789 switch (n->type) { 790 case (MAN_HEAD): 791 term_newln(p); 792 p->bold--; 793 break; 794 case (MAN_BODY): 795 term_newln(p); 796 break; 797 default: 798 break; 799 } 800 } 801 802 803 /* ARGSUSED */ 804 static int 805 pre_RS(DECL_ARGS) 806 { 807 const struct man_node *nn; 808 int ival; 809 810 switch (n->type) { 811 case (MAN_BLOCK): 812 term_newln(p); 813 return(1); 814 case (MAN_HEAD): 815 return(0); 816 default: 817 break; 818 } 819 820 if (NULL == (nn = n->parent->head->child)) { 821 mt->offset = mt->lmargin + INDENT; 822 p->offset = mt->offset; 823 return(1); 824 } 825 826 if ((ival = arg2width(nn)) < 0) 827 return(1); 828 829 mt->offset = INDENT + (size_t)ival; 830 p->offset = mt->offset; 831 832 return(1); 833 } 834 835 836 /* ARGSUSED */ 837 static void 838 post_RS(DECL_ARGS) 839 { 840 841 switch (n->type) { 842 case (MAN_BLOCK): 843 mt->offset = mt->lmargin = INDENT; 844 break; 845 default: 846 term_newln(p); 847 p->offset = INDENT; 848 break; 849 } 850 } 851 852 853 static void 854 print_node(DECL_ARGS) 855 { 856 int c, sz; 857 858 c = 1; 859 860 switch (n->type) { 861 case(MAN_TEXT): 862 if (0 == *n->string) { 863 term_vspace(p); 864 break; 865 } 866 /* 867 * Note! This is hacky. Here, we recognise the `\c' 868 * escape embedded in so many -man pages. It's supposed 869 * to remove the subsequent space, so we mark NOSPACE if 870 * it's encountered in the string. 871 */ 872 sz = (int)strlen(n->string); 873 term_word(p, n->string); 874 if (sz >= 2 && n->string[sz - 1] == 'c' && 875 n->string[sz - 2] == '\\') 876 p->flags |= TERMP_NOSPACE; 877 /* FIXME: this means that macro lines are munged! */ 878 if (MANT_LITERAL & mt->fl) { 879 p->flags |= TERMP_NOSPACE; 880 term_flushln(p); 881 } 882 break; 883 default: 884 if (termacts[n->tok].pre) 885 c = (*termacts[n->tok].pre)(p, mt, n, m); 886 break; 887 } 888 889 if (c && n->child) 890 print_body(p, mt, n->child, m); 891 892 if (MAN_TEXT != n->type) 893 if (termacts[n->tok].post) 894 (*termacts[n->tok].post)(p, mt, n, m); 895 } 896 897 898 static void 899 print_body(DECL_ARGS) 900 { 901 902 print_node(p, mt, n, m); 903 if ( ! n->next) 904 return; 905 print_body(p, mt, n->next, m); 906 } 907 908 909 static void 910 print_foot(struct termp *p, const struct man_meta *meta) 911 { 912 struct tm *tm; 913 char buf[BUFSIZ]; 914 915 tm = localtime(&meta->date); 916 917 if (0 == strftime(buf, p->rmargin, "%B %d, %Y", tm)) 918 (void)strlcpy(buf, "(invalid date)", BUFSIZ); 919 920 term_vspace(p); 921 922 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK; 923 p->rmargin = p->maxrmargin - strlen(buf); 924 p->offset = 0; 925 926 if (meta->source) 927 term_word(p, meta->source); 928 if (meta->source) 929 term_word(p, ""); 930 term_flushln(p); 931 932 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; 933 p->offset = p->rmargin; 934 p->rmargin = p->maxrmargin; 935 p->flags &= ~TERMP_NOBREAK; 936 937 term_word(p, buf); 938 term_flushln(p); 939 } 940 941 942 static void 943 print_head(struct termp *p, const struct man_meta *meta) 944 { 945 char *buf, *title; 946 947 p->rmargin = p->maxrmargin; 948 p->offset = 0; 949 950 if (NULL == (buf = malloc(p->rmargin))) 951 err(EXIT_FAILURE, "malloc"); 952 if (NULL == (title = malloc(p->rmargin))) 953 err(EXIT_FAILURE, "malloc"); 954 955 if (meta->vol) 956 (void)strlcpy(buf, meta->vol, p->rmargin); 957 else 958 *buf = 0; 959 960 (void)snprintf(title, p->rmargin, "%s(%d)", 961 meta->title, meta->msec); 962 963 p->offset = 0; 964 p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2; 965 p->flags |= TERMP_NOBREAK | TERMP_NOSPACE; 966 967 term_word(p, title); 968 term_flushln(p); 969 970 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; 971 p->offset = p->rmargin; 972 p->rmargin = p->maxrmargin - strlen(title); 973 974 term_word(p, buf); 975 term_flushln(p); 976 977 p->offset = p->rmargin; 978 p->rmargin = p->maxrmargin; 979 p->flags &= ~TERMP_NOBREAK; 980 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; 981 982 term_word(p, title); 983 term_flushln(p); 984 985 p->rmargin = p->maxrmargin; 986 p->offset = 0; 987 p->flags &= ~TERMP_NOSPACE; 988 989 free(title); 990 free(buf); 991 } 992 993
Indexes created Mon Oct 26 00:26:21 UTC 2026