1 /*- 2 * Copyright (c) 1991 Keith Muller. 3 * Copyright (c) 1993 4 * The Regents of the University of California. All rights reserved. 5 * 6 * This code is derived from software contributed to Berkeley by 7 * Keith Muller of the University of California, San Diego. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed by the University of 20 * California, Berkeley and its contributors. 21 * 4. Neither the name of the University nor the names of its contributors 22 * may be used to endorse or promote products derived from this software 23 * without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 * SUCH DAMAGE. 36 */ 37 38 #ifndef lint 39 static const char copyright[] = 40 "@(#) Copyright (c) 1993\n\ 41 The Regents of the University of California. All rights reserved.\n"; 42 #endif /* not lint */ 43 44 #if 0 45 #ifndef lint 46 static char sccsid[] = "@(#)pr.c 8.2 (Berkeley) 4/16/94"; 47 #endif /* not lint */ 48 #endif 49 50 #include <sys/cdefs.h> 51 __FBSDID("$FreeBSD$"); 52 53 #include <sys/types.h> 54 #include <sys/time.h> 55 #include <sys/stat.h> 56 57 #include <ctype.h> 58 #include <errno.h> 59 #include <langinfo.h> 60 #include <locale.h> 61 #include <signal.h> 62 #include <stdio.h> 63 #include <stdlib.h> 64 #include <string.h> 65 #include <unistd.h> 66 67 #include "pr.h" 68 #include "extern.h" 69 70 /* 71 * pr: a printing and pagination filter. If multiple input files 72 * are specified, each is read, formatted, and written to standard 73 * output. By default, input is separated into 66-line pages, each 74 * with a header that includes the page number, date, time and the 75 * files pathname. 76 * 77 * Complies with posix P1003.2/D11 78 */ 79 80 /* 81 * parameter variables 82 */ 83 static int pgnm; /* starting page number */ 84 static int clcnt; /* number of columns */ 85 static int colwd; /* column data width - multiple columns */ 86 static int across; /* mult col flag; write across page */ 87 static int dspace; /* double space flag */ 88 static char inchar; /* expand input char */ 89 static int ingap; /* expand input gap */ 90 static int pausefst; /* Pause before first page */ 91 static int pauseall; /* Pause before each page */ 92 static int formfeed; /* use formfeed as trailer */ 93 static char *header; /* header name instead of file name */ 94 static char ochar; /* contract output char */ 95 static int ogap; /* contract output gap */ 96 static int lines; /* number of lines per page */ 97 static int merge; /* merge multiple files in output */ 98 static char nmchar; /* line numbering append char */ 99 static int nmwd; /* width of line number field */ 100 static int offst; /* number of page offset spaces */ 101 static int nodiag; /* do not report file open errors */ 102 static char schar; /* text column separation character */ 103 static int sflag; /* -s option for multiple columns */ 104 static int nohead; /* do not write head and trailer */ 105 static int pgwd; /* page width with multiple col output */ 106 static char *timefrmt; /* time conversion string */ 107 108 /* 109 * misc globals 110 */ 111 static FILE *err; /* error message file pointer */ 112 static int addone; /* page length is odd with double space */ 113 static int errcnt; /* error count on file processing */ 114 static char digs[] = "0123456789"; /* page number translation map */ 115 116 static char fnamedefault[] = FNAME; 117 118 int 119 main(int argc, char *argv[]) 120 { 121 int ret_val; 122 123 if (signal(SIGINT, SIG_IGN) != SIG_IGN) 124 (void)signal(SIGINT, terminate); 125 ret_val = setup(argc, argv); 126 if (!ret_val) { 127 /* 128 * select the output format based on options 129 */ 130 if (merge) 131 ret_val = mulfile(argc, argv); 132 else if (clcnt == 1) 133 ret_val = onecol(argc, argv); 134 else if (across) 135 ret_val = horzcol(argc, argv); 136 else 137 ret_val = vertcol(argc, argv); 138 free(timefrmt); 139 } else 140 usage(); 141 flsh_errs(); 142 if (errcnt || ret_val) 143 exit(1); 144 return(0); 145 } 146 147 /* 148 * Check if we should pause and write an alert character and wait for a 149 * carriage return on /dev/tty. 150 */ 151 static void 152 ttypause(int pagecnt) 153 { 154 int pch; 155 FILE *ttyfp; 156 157 if ((pauseall || (pausefst && pagecnt == 1)) && 158 isatty(STDOUT_FILENO)) { 159 if ((ttyfp = fopen("/dev/tty", "r")) != NULL) { 160 (void)putc('\a', stderr); 161 while ((pch = getc(ttyfp)) != '\n' && pch != EOF) 162 ; 163 (void)fclose(ttyfp); 164 } 165 } 166 } 167 168 /* 169 * onecol: print files with only one column of output. 170 * Line length is unlimited. 171 */ 172 int 173 onecol(int argc, char *argv[]) 174 { 175 int cnt = -1; 176 int off; 177 int lrgln; 178 int linecnt; 179 int num; 180 int lncnt; 181 int pagecnt; 182 int ips; 183 int ops; 184 int cps; 185 char *obuf; 186 char *lbuf; 187 char *nbuf; 188 char *hbuf; 189 char *ohbuf; 190 FILE *inf; 191 const char *fname; 192 int mor; 193 194 if (nmwd) 195 num = nmwd + 1; 196 else 197 num = 0; 198 off = num + offst; 199 200 /* 201 * allocate line buffer 202 */ 203 if ((obuf = malloc((unsigned)(LBUF + off)*sizeof(char))) == NULL) { 204 mfail(); 205 return(1); 206 } 207 /* 208 * allocate header buffer 209 */ 210 if ((hbuf = malloc((unsigned)(HDBUF + offst)*sizeof(char))) == NULL) { 211 free(obuf); 212 mfail(); 213 return(1); 214 } 215 216 ohbuf = hbuf + offst; 217 nbuf = obuf + offst; 218 lbuf = nbuf + num; 219 if (num) 220 nbuf[--num] = nmchar; 221 if (offst) { 222 (void)memset(obuf, (int)' ', offst); 223 (void)memset(hbuf, (int)' ', offst); 224 } 225 226 /* 227 * loop by file 228 */ 229 while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL) { 230 if (pgnm) { 231 /* 232 * skip to specified page 233 */ 234 if (inskip(inf, pgnm, lines)) 235 continue; 236 pagecnt = pgnm; 237 } else 238 pagecnt = 1; 239 lncnt = 0; 240 241 /* 242 * loop by page 243 */ 244 for(;;) { 245 linecnt = 0; 246 lrgln = 0; 247 ops = 0; 248 ips = 0; 249 cps = 0; 250 251 ttypause(pagecnt); 252 253 /* 254 * loop by line 255 */ 256 while (linecnt < lines) { 257 /* 258 * input next line 259 */ 260 if ((cnt = inln(inf,lbuf,LBUF,&cps,0,&mor)) < 0) 261 break; 262 if (!linecnt && !nohead && 263 prhead(hbuf, fname, pagecnt)) 264 goto err; 265 266 /* 267 * start of new line. 268 */ 269 if (!lrgln) { 270 if (num) 271 addnum(nbuf, num, ++lncnt); 272 if (otln(obuf,cnt+off, &ips, &ops, mor)) 273 goto err; 274 } else if (otln(lbuf, cnt, &ips, &ops, mor)) 275 goto err; 276 277 /* 278 * if line bigger than buffer, get more 279 */ 280 if (mor) { 281 lrgln = 1; 282 continue; 283 } 284 285 /* 286 * whole line rcvd. reset tab proc. state 287 */ 288 ++linecnt; 289 lrgln = 0; 290 ops = 0; 291 ips = 0; 292 } 293 294 /* 295 * fill to end of page 296 */ 297 if (linecnt && prtail(lines-linecnt-lrgln, lrgln)) 298 goto err; 299 300 /* 301 * On EOF go to next file 302 */ 303 if (cnt < 0) 304 break; 305 ++pagecnt; 306 } 307 if (inf != stdin) 308 (void)fclose(inf); 309 } 310 if (eoptind < argc) 311 goto err; 312 free(hbuf); 313 free(obuf); 314 return(0); 315 err: 316 free(hbuf); 317 free(obuf); 318 return(1); 319 } 320 321 /* 322 * vertcol: print files with more than one column of output down a page 323 */ 324 int 325 vertcol(int argc, char *argv[]) 326 { 327 char *ptbf; 328 char **lstdat = NULL; 329 int i; 330 int j; 331 int cnt = -1; 332 int pln; 333 int *indy = NULL; 334 int cvc; 335 int *lindy = NULL; 336 int lncnt; 337 int stp; 338 int pagecnt; 339 int col = colwd + 1; 340 int mxlen = pgwd + offst + 1; 341 int mclcnt = clcnt - 1; 342 struct vcol *vc = NULL; 343 int mvc; 344 int tvc; 345 int cw = nmwd + 1; 346 int fullcol; 347 char *buf = NULL; 348 char *hbuf = NULL; 349 char *ohbuf; 350 const char *fname; 351 FILE *inf; 352 int ips = 0; 353 int cps = 0; 354 int ops = 0; 355 int mor = 0; 356 int retval = 1; 357 358 /* 359 * allocate page buffer 360 */ 361 if ((buf = malloc((unsigned)lines*mxlen*sizeof(char))) == NULL) { 362 mfail(); 363 return(1); 364 } 365 366 /* 367 * allocate page header 368 */ 369 if ((hbuf = malloc((unsigned)(HDBUF + offst)*sizeof(char))) == NULL) { 370 mfail(); 371 goto out; 372 } 373 ohbuf = hbuf + offst; 374 if (offst) 375 (void)memset(hbuf, (int)' ', offst); 376 377 /* 378 * col pointers when no headers 379 */ 380 mvc = lines * clcnt; 381 if ((vc = 382 (struct vcol *)malloc((unsigned)mvc*sizeof(struct vcol))) == NULL) { 383 mfail(); 384 goto out; 385 } 386 387 /* 388 * pointer into page where last data per line is located 389 */ 390 if ((lstdat = (char **)malloc((unsigned)lines*sizeof(char *))) == NULL){ 391 mfail(); 392 goto out; 393 } 394 395 /* 396 * fast index lookups to locate start of lines 397 */ 398 if ((indy = (int *)malloc((unsigned)lines*sizeof(int))) == NULL) { 399 mfail(); 400 goto out; 401 } 402 if ((lindy = (int *)malloc((unsigned)lines*sizeof(int))) == NULL) { 403 mfail(); 404 goto out; 405 } 406 407 if (nmwd) 408 fullcol = col + cw; 409 else 410 fullcol = col; 411 412 /* 413 * initialize buffer lookup indexes and offset area 414 */ 415 for (j = 0; j < lines; ++j) { 416 lindy[j] = j * mxlen; 417 indy[j] = lindy[j] + offst; 418 if (offst) { 419 ptbf = buf + lindy[j]; 420 (void)memset(ptbf, (int)' ', offst); 421 ptbf += offst; 422 } else 423 ptbf = buf + indy[j]; 424 lstdat[j] = ptbf; 425 } 426 427 /* 428 * loop by file 429 */ 430 while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL) { 431 if (pgnm) { 432 /* 433 * skip to requested page 434 */ 435 if (inskip(inf, pgnm, lines)) 436 continue; 437 pagecnt = pgnm; 438 } else 439 pagecnt = 1; 440 lncnt = 0; 441 442 /* 443 * loop by page 444 */ 445 for(;;) { 446 ttypause(pagecnt); 447 448 /* 449 * loop by column 450 */ 451 cvc = 0; 452 for (i = 0; i < clcnt; ++i) { 453 j = 0; 454 /* 455 * if last column, do not pad 456 */ 457 if (i == mclcnt) 458 stp = 1; 459 else 460 stp = 0; 461 /* 462 * loop by line 463 */ 464 for(;;) { 465 /* 466 * is this first column 467 */ 468 if (!i) { 469 ptbf = buf + indy[j]; 470 lstdat[j] = ptbf; 471 } else 472 ptbf = lstdat[j]; 473 vc[cvc].pt = ptbf; 474 475 /* 476 * add number 477 */ 478 if (nmwd) { 479 addnum(ptbf, nmwd, ++lncnt); 480 ptbf += nmwd; 481 *ptbf++ = nmchar; 482 } 483 484 /* 485 * input next line 486 */ 487 cnt = inln(inf,ptbf,colwd,&cps,1,&mor); 488 vc[cvc++].cnt = cnt; 489 if (cnt < 0) 490 break; 491 ptbf += cnt; 492 493 /* 494 * pad all but last column on page 495 */ 496 if (!stp) { 497 /* 498 * pad to end of column 499 */ 500 if (sflag) 501 *ptbf++ = schar; 502 else if ((pln = col-cnt) > 0) { 503 (void)memset(ptbf, 504 (int)' ',pln); 505 ptbf += pln; 506 } 507 } 508 /* 509 * remember last char in line 510 */ 511 lstdat[j] = ptbf; 512 if (++j >= lines) 513 break; 514 } 515 if (cnt < 0) 516 break; 517 } 518 519 /* 520 * when -t (no header) is specified the spec requires 521 * the min number of lines. The last page may not have 522 * balanced length columns. To fix this we must reorder 523 * the columns. This is a very slow technique so it is 524 * only used under limited conditions. Without -t, the 525 * balancing of text columns is unspecified. To NOT 526 * balance the last page, add the global variable 527 * nohead to the if statement below e.g. 528 * 529 * if ((cnt < 0) && nohead && cvc ...... 530 */ 531 --cvc; 532 533 /* 534 * check to see if last page needs to be reordered 535 */ 536 if ((cnt < 0) && cvc && ((mvc-cvc) >= clcnt)){ 537 pln = cvc/clcnt; 538 if (cvc % clcnt) 539 ++pln; 540 541 /* 542 * print header 543 */ 544 if (!nohead && prhead(hbuf, fname, pagecnt)) 545 goto out; 546 for (i = 0; i < pln; ++i) { 547 ips = 0; 548 ops = 0; 549 if (offst && 550 otln(buf,offst,&ips,&ops,1)) 551 goto out; 552 tvc = i; 553 554 for (j = 0; j < clcnt; ++j) { 555 /* 556 * determine column length 557 */ 558 if (j == mclcnt) { 559 /* 560 * last column 561 */ 562 cnt = vc[tvc].cnt; 563 if (nmwd) 564 cnt += cw; 565 } else if (sflag) { 566 /* 567 * single ch between 568 */ 569 cnt = vc[tvc].cnt + 1; 570 if (nmwd) 571 cnt += cw; 572 } else 573 cnt = fullcol; 574 if (otln(vc[tvc].pt, cnt, &ips, 575 &ops, 1)) 576 goto out; 577 tvc += pln; 578 if (tvc >= cvc) 579 break; 580 } 581 /* 582 * terminate line 583 */ 584 if (otln(buf, 0, &ips, &ops, 0)) 585 goto out; 586 } 587 /* 588 * pad to end of page 589 */ 590 if (prtail((lines - pln), 0)) 591 goto out; 592 /* 593 * done with output, go to next file 594 */ 595 break; 596 } 597 598 /* 599 * determine how many lines to output 600 */ 601 if (i > 0) 602 pln = lines; 603 else 604 pln = j; 605 606 /* 607 * print header 608 */ 609 if (pln && !nohead && prhead(hbuf, fname, pagecnt)) 610 goto out; 611 612 /* 613 * output each line 614 */ 615 for (i = 0; i < pln; ++i) { 616 ptbf = buf + lindy[i]; 617 if ((j = lstdat[i] - ptbf) <= offst) 618 break; 619 if (otln(ptbf, j, &ips, &ops, 0)) 620 goto out; 621 } 622 623 /* 624 * pad to end of page 625 */ 626 if (pln && prtail((lines - pln), 0)) 627 goto out; 628 629 /* 630 * if EOF go to next file 631 */ 632 if (cnt < 0) 633 break; 634 ++pagecnt; 635 } 636 if (inf != stdin) 637 (void)fclose(inf); 638 } 639 if (eoptind < argc) 640 goto out; 641 retval = 0; 642 out: 643 free(lindy); 644 free(indy); 645 free(lstdat); 646 free(vc); 647 free(hbuf); 648 free(buf); 649 return(retval); 650 } 651 652 /* 653 * horzcol: print files with more than one column of output across a page 654 */ 655 int 656 horzcol(int argc, char *argv[]) 657 { 658 char *ptbf; 659 int pln; 660 int cnt = -1; 661 char *lstdat; 662 int col = colwd + 1; 663 int j; 664 int i; 665 int lncnt; 666 int pagecnt; 667 char *buf; 668 char *hbuf; 669 char *ohbuf; 670 const char *fname; 671 FILE *inf; 672 int ips = 0; 673 int cps = 0; 674 int ops = 0; 675 int mor = 0; 676 677 if ((buf = malloc((unsigned)(pgwd+offst+1)*sizeof(char))) == NULL) { 678 mfail(); 679 return(1); 680 } 681 682 /* 683 * page header 684 */ 685 if ((hbuf = malloc((unsigned)(HDBUF + offst)*sizeof(char))) == NULL) { 686 free(buf); 687 mfail(); 688 return(1); 689 } 690 ohbuf = hbuf + offst; 691 if (offst) { 692 (void)memset(buf, (int)' ', offst); 693 (void)memset(hbuf, (int)' ', offst); 694 } 695 696 /* 697 * loop by file 698 */ 699 while ((inf = nxtfile(argc, argv, &fname, ohbuf, 0)) != NULL) { 700 if (pgnm) { 701 if (inskip(inf, pgnm, lines)) 702 continue; 703 pagecnt = pgnm; 704 } else 705 pagecnt = 1; 706 lncnt = 0; 707 708 /* 709 * loop by page 710 */ 711 for(;;) { 712 ttypause(pagecnt); 713 714 /* 715 * loop by line 716 */ 717 for (i = 0; i < lines; ++i) { 718 ptbf = buf + offst; 719 lstdat = ptbf; 720 j = 0; 721 /* 722 * loop by col 723 */ 724 for(;;) { 725 if (nmwd) { 726 /* 727 * add number to column 728 */ 729 addnum(ptbf, nmwd, ++lncnt); 730 ptbf += nmwd; 731 *ptbf++ = nmchar; 732 } 733 /* 734 * input line 735 */ 736 if ((cnt = inln(inf,ptbf,colwd,&cps,1, 737 &mor)) < 0) 738 break; 739 ptbf += cnt; 740 lstdat = ptbf; 741 742 /* 743 * if last line skip padding 744 */ 745 if (++j >= clcnt) 746 break; 747 748 /* 749 * pad to end of column 750 */ 751 if (sflag) 752 *ptbf++ = schar; 753 else if ((pln = col - cnt) > 0) { 754 (void)memset(ptbf,(int)' ',pln); 755 ptbf += pln; 756 } 757 } 758 759 /* 760 * determine line length 761 */ 762 if ((j = lstdat - buf) <= offst) 763 break; 764 if (!i && !nohead && 765 prhead(hbuf, fname, pagecnt)) 766 goto err; 767 /* 768 * output line 769 */ 770 if (otln(buf, j, &ips, &ops, 0)) 771 goto err; 772 } 773 774 /* 775 * pad to end of page 776 */ 777 if (i && prtail(lines-i, 0)) 778 goto err; 779 780 /* 781 * if EOF go to next file 782 */ 783 if (cnt < 0) 784 break; 785 ++pagecnt; 786 } 787 if (inf != stdin) 788 (void)fclose(inf); 789 } 790 if (eoptind < argc) 791 goto err; 792 free(hbuf); 793 free(buf); 794 return(0); 795 err: 796 free(hbuf); 797 free(buf); 798 return(1); 799 } 800 801 /* 802 * mulfile: print files with more than one column of output and 803 * more than one file concurrently 804 */ 805 int 806 mulfile(int argc, char *argv[]) 807 { 808 char *ptbf; 809 int j; 810 int pln; 811 int cnt; 812 char *lstdat; 813 int i; 814 FILE **fbuf = NULL; 815 int actf; 816 int lncnt; 817 int col; 818 int pagecnt; 819 int fproc; 820 char *buf = NULL; 821 char *hbuf = NULL; 822 char *ohbuf; 823 const char *fname; 824 int ips = 0; 825 int cps = 0; 826 int ops = 0; 827 int mor = 0; 828 int retval = 1; 829 830 /* 831 * array of FILE *, one for each operand 832 */ 833 if ((fbuf = (FILE **)malloc((unsigned)clcnt*sizeof(FILE *))) == NULL) { 834 mfail(); 835 goto out; 836 } 837 838 /* 839 * page header 840 */ 841 if ((hbuf = malloc((unsigned)(HDBUF + offst)*sizeof(char))) == NULL) { 842 mfail(); 843 goto out; 844 } 845 ohbuf = hbuf + offst; 846 847 /* 848 * do not know how many columns yet. The number of operands provide an 849 * upper bound on the number of columns. We use the number of files 850 * we can open successfully to set the number of columns. The operation 851 * of the merge operation (-m) in relation to unsuccessful file opens 852 * is unspecified by posix. 853 */ 854 j = 0; 855 while (j < clcnt) { 856 if ((fbuf[j] = nxtfile(argc, argv, &fname, ohbuf, 1)) == NULL) 857 break; 858 if (pgnm && (inskip(fbuf[j], pgnm, lines))) 859 fbuf[j] = NULL; 860 ++j; 861 } 862 863 /* 864 * if no files, exit 865 */ 866 if (!j) 867 goto out; 868 869 /* 870 * calculate page boundaries based on open file count 871 */ 872 clcnt = j; 873 if (nmwd) { 874 colwd = (pgwd - clcnt - nmwd)/clcnt; 875 pgwd = ((colwd + 1) * clcnt) - nmwd - 2; 876 } else { 877 colwd = (pgwd + 1 - clcnt)/clcnt; 878 pgwd = ((colwd + 1) * clcnt) - 1; 879 } 880 if (colwd < 1) { 881 (void)fprintf(err, 882 "pr: page width too small for %d columns\n", clcnt); 883 goto out; 884 } 885 actf = clcnt; 886 col = colwd + 1; 887 888 /* 889 * line buffer 890 */ 891 if ((buf = malloc((unsigned)(pgwd+offst+1)*sizeof(char))) == NULL) { 892 mfail(); 893 goto out; 894 } 895 if (offst) { 896 (void)memset(buf, (int)' ', offst); 897 (void)memset(hbuf, (int)' ', offst); 898 } 899 if (pgnm) 900 pagecnt = pgnm; 901 else 902 pagecnt = 1; 903 lncnt = 0; 904 905 /* 906 * continue to loop while any file still has data 907 */ 908 while (actf > 0) { 909 ttypause(pagecnt); 910 911 /* 912 * loop by line 913 */ 914 for (i = 0; i < lines; ++i) { 915 ptbf = buf + offst; 916 lstdat = ptbf; 917 if (nmwd) { 918 /* 919 * add line number to line 920 */ 921 addnum(ptbf, nmwd, ++lncnt); 922 ptbf += nmwd; 923 *ptbf++ = nmchar; 924 } 925 j = 0; 926 fproc = 0; 927 928 /* 929 * loop by column 930 */ 931 for (j = 0; j < clcnt; ++j) { 932 if (fbuf[j] == NULL) { 933 /* 934 * empty column; EOF 935 */ 936 cnt = 0; 937 } else if ((cnt = inln(fbuf[j], ptbf, colwd, 938 &cps, 1, &mor)) < 0) { 939 /* 940 * EOF hit; no data 941 */ 942 if (fbuf[j] != stdin) 943 (void)fclose(fbuf[j]); 944 fbuf[j] = NULL; 945 --actf; 946 cnt = 0; 947 } else { 948 /* 949 * process file data 950 */ 951 ptbf += cnt; 952 lstdat = ptbf; 953 fproc++; 954 } 955 956 /* 957 * if last ACTIVE column, done with line 958 */ 959 if (fproc >= actf) 960 break; 961 962 /* 963 * pad to end of column 964 */ 965 if (sflag) { 966 *ptbf++ = schar; 967 } else if ((pln = col - cnt) > 0) { 968 (void)memset(ptbf, (int)' ', pln); 969 ptbf += pln; 970 } 971 } 972 973 /* 974 * calculate data in line 975 */ 976 if ((j = lstdat - buf) <= offst) 977 break; 978 979 if (!i && !nohead && prhead(hbuf, fname, pagecnt)) 980 goto out; 981 982 /* 983 * output line 984 */ 985 if (otln(buf, j, &ips, &ops, 0)) 986 goto out; 987 988 /* 989 * if no more active files, done 990 */ 991 if (actf <= 0) { 992 ++i; 993 break; 994 } 995 } 996 997 /* 998 * pad to end of page 999 */ 1000 if (i && prtail(lines-i, 0)) 1001 goto out; 1002 ++pagecnt; 1003 } 1004 if (eoptind < argc) 1005 goto out; 1006 retval = 0; 1007 out: 1008 free(buf); 1009 free(hbuf); 1010 free(fbuf); 1011 return(retval); 1012 } 1013 1014 /* 1015 * inln(): input a line of data (unlimited length lines supported) 1016 * Input is optionally expanded to spaces 1017 * 1018 * inf: file 1019 * buf: buffer 1020 * lim: buffer length 1021 * cps: column position 1st char in buffer (large line support) 1022 * trnc: throw away data more than lim up to \n 1023 * mor: set if more data in line (not truncated) 1024 */ 1025 int 1026 inln(FILE *inf, char *buf, int lim, int *cps, int trnc, int *mor) 1027 { 1028 int col; 1029 int gap = ingap; 1030 int ch = EOF; 1031 char *ptbuf; 1032 int chk = (int)inchar; 1033 1034 ptbuf = buf; 1035 1036 if (gap) { 1037 /* 1038 * expanding input option 1039 */ 1040 while ((--lim >= 0) && ((ch = getc(inf)) != EOF)) { 1041 /* 1042 * is this the input "tab" char 1043 */ 1044 if (ch == chk) { 1045 /* 1046 * expand to number of spaces 1047 */ 1048 col = (ptbuf - buf) + *cps; 1049 col = gap - (col % gap); 1050 1051 /* 1052 * if more than this line, push back 1053 */ 1054 if ((col > lim) && (ungetc(ch, inf) == EOF)) 1055 return(1); 1056 1057 /* 1058 * expand to spaces 1059 */ 1060 while ((--col >= 0) && (--lim >= 0)) 1061 *ptbuf++ = ' '; 1062 continue; 1063 } 1064 if (ch == '\n') 1065 break; 1066 *ptbuf++ = ch; 1067 } 1068 } else { 1069 /* 1070 * no expansion 1071 */ 1072 while ((--lim >= 0) && ((ch = getc(inf)) != EOF)) { 1073 if (ch == '\n') 1074 break; 1075 *ptbuf++ = ch; 1076 } 1077 } 1078 col = ptbuf - buf; 1079 if (ch == EOF) { 1080 *mor = 0; 1081 *cps = 0; 1082 if (!col) 1083 return(-1); 1084 return(col); 1085 } 1086 if (ch == '\n') { 1087 /* 1088 * entire line processed 1089 */ 1090 *mor = 0; 1091 *cps = 0; 1092 return(col); 1093 } 1094 1095 /* 1096 * line was larger than limit 1097 */ 1098 if (trnc) { 1099 /* 1100 * throw away rest of line 1101 */ 1102 while ((ch = getc(inf)) != EOF) { 1103 if (ch == '\n') 1104 break; 1105 } 1106 *cps = 0; 1107 *mor = 0; 1108 } else { 1109 /* 1110 * save column offset if not truncated 1111 */ 1112 *cps += col; 1113 *mor = 1; 1114 } 1115 1116 return(col); 1117 } 1118 1119 /* 1120 * otln(): output a line of data. (Supports unlimited length lines) 1121 * output is optionally contracted to tabs 1122 * 1123 * buf: output buffer with data 1124 * cnt: number of chars of valid data in buf 1125 * svips: buffer input column position (for large lines) 1126 * svops: buffer output column position (for large lines) 1127 * mor: output line not complete in this buf; more data to come. 1128 * 1 is more, 0 is complete, -1 is no \n's 1129 */ 1130 int 1131 otln(char *buf, int cnt, int *svips, int *svops, int mor) 1132 { 1133 int ops; /* last col output */ 1134 int ips; /* last col in buf examined */ 1135 int gap = ogap; 1136 int tbps; 1137 char *endbuf; 1138 1139 if (ogap) { 1140 /* 1141 * contracting on output 1142 */ 1143 endbuf = buf + cnt; 1144 ops = *svops; 1145 ips = *svips; 1146 while (buf < endbuf) { 1147 /* 1148 * count number of spaces and ochar in buffer 1149 */ 1150 if (*buf == ' ') { 1151 ++ips; 1152 ++buf; 1153 continue; 1154 } 1155 1156 /* 1157 * simulate ochar processing 1158 */ 1159 if (*buf == ochar) { 1160 ips += gap - (ips % gap); 1161 ++buf; 1162 continue; 1163 } 1164 1165 /* 1166 * got a non space char; contract out spaces 1167 */ 1168 while (ips - ops > 1) { 1169 /* 1170 * use as many ochar as will fit 1171 */ 1172 if ((tbps = ops + gap - (ops % gap)) > ips) 1173 break; 1174 if (putchar(ochar) == EOF) { 1175 pfail(); 1176 return(1); 1177 } 1178 ops = tbps; 1179 } 1180 1181 while (ops < ips) { 1182 /* 1183 * finish off with spaces 1184 */ 1185 if (putchar(' ') == EOF) { 1186 pfail(); 1187 return(1); 1188 } 1189 ++ops; 1190 } 1191 1192 /* 1193 * output non space char 1194 */ 1195 if (putchar(*buf++) == EOF) { 1196 pfail(); 1197 return(1); 1198 } 1199 ++ips; 1200 ++ops; 1201 } 1202 1203 if (mor > 0) { 1204 /* 1205 * if incomplete line, save position counts 1206 */ 1207 *svops = ops; 1208 *svips = ips; 1209 return(0); 1210 } 1211 1212 if (mor < 0) { 1213 while (ips - ops > 1) { 1214 /* 1215 * use as many ochar as will fit 1216 */ 1217 if ((tbps = ops + gap - (ops % gap)) > ips) 1218 break; 1219 if (putchar(ochar) == EOF) { 1220 pfail(); 1221 return(1); 1222 } 1223 ops = tbps; 1224 } 1225 while (ops < ips) { 1226 /* 1227 * finish off with spaces 1228 */ 1229 if (putchar(' ') == EOF) { 1230 pfail(); 1231 return(1); 1232 } 1233 ++ops; 1234 } 1235 return(0); 1236 } 1237 } else { 1238 /* 1239 * output is not contracted 1240 */ 1241 if (cnt && (fwrite(buf, sizeof(char), cnt, stdout) <= 0)) { 1242 pfail(); 1243 return(1); 1244 } 1245 if (mor != 0) 1246 return(0); 1247 } 1248 1249 /* 1250 * process line end and double space as required 1251 */ 1252 if ((putchar('\n') == EOF) || (dspace && (putchar('\n') == EOF))) { 1253 pfail(); 1254 return(1); 1255 } 1256 return(0); 1257 } 1258 1259 /* 1260 * inskip(): skip over pgcnt pages with lncnt lines per page 1261 * file is closed at EOF (if not stdin). 1262 * 1263 * inf FILE * to read from 1264 * pgcnt number of pages to skip 1265 * lncnt number of lines per page 1266 */ 1267 int 1268 inskip(FILE *inf, int pgcnt, int lncnt) 1269 { 1270 int c; 1271 int cnt; 1272 1273 while(--pgcnt > 0) { 1274 cnt = lncnt; 1275 while ((c = getc(inf)) != EOF) { 1276 if ((c == '\n') && (--cnt == 0)) 1277 break; 1278 } 1279 if (c == EOF) { 1280 if (inf != stdin) 1281 (void)fclose(inf); 1282 return(1); 1283 } 1284 } 1285 return(0); 1286 } 1287 1288 /* 1289 * nxtfile: returns a FILE * to next file in arg list and sets the 1290 * time field for this file (or current date). 1291 * 1292 * buf array to store proper date for the header. 1293 * dt if set skips the date processing (used with -m) 1294 */ 1295 FILE * 1296 nxtfile(int argc, char **argv, const char **fname, char *buf, int dt) 1297 { 1298 FILE *inf = NULL; 1299 time_t tv_sec; 1300 struct tm *timeptr = NULL; 1301 struct stat statbuf; 1302 static int twice = -1; 1303 1304 ++twice; 1305 if (eoptind >= argc) { 1306 /* 1307 * no file listed; default, use standard input 1308 */ 1309 if (twice) 1310 return(NULL); 1311 clearerr(stdin); 1312 inf = stdin; 1313 if (header != NULL) 1314 *fname = header; 1315 else 1316 *fname = fnamedefault; 1317 if (nohead) 1318 return(inf); 1319 if ((tv_sec = time(NULL)) == -1) { 1320 ++errcnt; 1321 (void)fprintf(err, "pr: cannot get time of day, %s\n", 1322 strerror(errno)); 1323 eoptind = argc - 1; 1324 return(NULL); 1325 } 1326 timeptr = localtime(&tv_sec); 1327 } 1328 for (; eoptind < argc; ++eoptind) { 1329 if (strcmp(argv[eoptind], "-") == 0) { 1330 /* 1331 * process a "-" for filename 1332 */ 1333 clearerr(stdin); 1334 inf = stdin; 1335 if (header != NULL) 1336 *fname = header; 1337 else 1338 *fname = fnamedefault; 1339 ++eoptind; 1340 if (nohead || (dt && twice)) 1341 return(inf); 1342 if ((tv_sec = time(NULL)) == -1) { 1343 ++errcnt; 1344 (void)fprintf(err, 1345 "pr: cannot get time of day, %s\n", 1346 strerror(errno)); 1347 return(NULL); 1348 } 1349 timeptr = localtime(&tv_sec); 1350 } else { 1351 /* 1352 * normal file processing 1353 */ 1354 if ((inf = fopen(argv[eoptind], "r")) == NULL) { 1355 ++errcnt; 1356 if (nodiag) 1357 continue; 1358 (void)fprintf(err, "pr: cannot open %s, %s\n", 1359 argv[eoptind], strerror(errno)); 1360 continue; 1361 } 1362 if (header != NULL) 1363 *fname = header; 1364 else if (dt) 1365 *fname = fnamedefault; 1366 else 1367 *fname = argv[eoptind]; 1368 ++eoptind; 1369 if (nohead || (dt && twice)) 1370 return(inf); 1371 1372 if (dt) { 1373 if ((tv_sec = time(NULL)) == -1) { 1374 ++errcnt; 1375 (void)fprintf(err, 1376 "pr: cannot get time of day, %s\n", 1377 strerror(errno)); 1378 fclose(inf); 1379 return(NULL); 1380 } 1381 timeptr = localtime(&tv_sec); 1382 } else { 1383 if (fstat(fileno(inf), &statbuf) < 0) { 1384 ++errcnt; 1385 (void)fclose(inf); 1386 (void)fprintf(err, 1387 "pr: cannot stat %s, %s\n", 1388 argv[eoptind], strerror(errno)); 1389 return(NULL); 1390 } 1391 timeptr = localtime(&(statbuf.st_mtime)); 1392 } 1393 } 1394 break; 1395 } 1396 if (inf == NULL) 1397 return(NULL); 1398 1399 /* 1400 * set up time field used in header 1401 */ 1402 if (strftime(buf, HDBUF, timefrmt, timeptr) <= 0) { 1403 ++errcnt; 1404 if (inf != stdin) 1405 (void)fclose(inf); 1406 (void)fputs("pr: time conversion failed\n", err); 1407 return(NULL); 1408 } 1409 return(inf); 1410 } 1411 1412 /* 1413 * addnum(): adds the line number to the column 1414 * Truncates from the front or pads with spaces as required. 1415 * Numbers are right justified. 1416 * 1417 * buf buffer to store the number 1418 * wdth width of buffer to fill 1419 * line line number 1420 * 1421 * NOTE: numbers occupy part of the column. The posix 1422 * spec does not specify if -i processing should or should not 1423 * occur on number padding. The spec does say it occupies 1424 * part of the column. The usage of addnum currently treats 1425 * numbers as part of the column so spaces may be replaced. 1426 */ 1427 void 1428 addnum(char *buf, int wdth, int line) 1429 { 1430 char *pt = buf + wdth; 1431 1432 do { 1433 *--pt = digs[line % 10]; 1434 line /= 10; 1435 } while (line && (pt > buf)); 1436 1437 /* 1438 * pad with space as required 1439 */ 1440 while (pt > buf) 1441 *--pt = ' '; 1442 } 1443 1444 /* 1445 * prhead(): prints the top of page header 1446 * 1447 * buf buffer with time field (and offset) 1448 * cnt number of chars in buf 1449 * fname fname field for header 1450 * pagcnt page number 1451 */ 1452 int 1453 prhead(char *buf, const char *fname, int pagcnt) 1454 { 1455 int ips = 0; 1456 int ops = 0; 1457 1458 if ((putchar('\n') == EOF) || (putchar('\n') == EOF)) { 1459 pfail(); 1460 return(1); 1461 } 1462 /* 1463 * posix is not clear if the header is subject to line length 1464 * restrictions. The specification for header line format 1465 * in the spec clearly does not limit length. No pr currently 1466 * restricts header length. However if we need to truncate in 1467 * a reasonable way, adjust the length of the printf by 1468 * changing HDFMT to allow a length max as an argument to printf. 1469 * buf (which contains the offset spaces and time field could 1470 * also be trimmed 1471 * 1472 * note only the offset (if any) is processed for tab expansion 1473 */ 1474 if (offst && otln(buf, offst, &ips, &ops, -1)) 1475 return(1); 1476 (void)printf(HDFMT,buf+offst, fname, pagcnt); 1477 return(0); 1478 } 1479 1480 /* 1481 * prtail(): pad page with empty lines (if required) and print page trailer 1482 * if requested 1483 * 1484 * cnt number of lines of padding needed 1485 * incomp was a '\n' missing from last line output 1486 */ 1487 int 1488 prtail(int cnt, int incomp) 1489 { 1490 if (nohead) { 1491 /* 1492 * only pad with no headers when incomplete last line 1493 */ 1494 if (incomp && 1495 ((dspace && (putchar('\n') == EOF)) || 1496 (putchar('\n') == EOF))) { 1497 pfail(); 1498 return(1); 1499 } 1500 /* 1501 * but honor the formfeed request 1502 */ 1503 if (formfeed) { 1504 if (putchar('\f') == EOF) { 1505 pfail(); 1506 return(1); 1507 } 1508 } 1509 return(0); 1510 } 1511 /* 1512 * if double space output two \n 1513 */ 1514 if (dspace) 1515 cnt *= 2; 1516 1517 /* 1518 * if an odd number of lines per page, add an extra \n 1519 */ 1520 if (addone) 1521 ++cnt; 1522 1523 /* 1524 * pad page 1525 */ 1526 if (formfeed) { 1527 if ((incomp && (putchar('\n') == EOF)) || 1528 (putchar('\f') == EOF)) { 1529 pfail(); 1530 return(1); 1531 } 1532 return(0); 1533 } 1534 cnt += TAILLEN; 1535 while (--cnt >= 0) { 1536 if (putchar('\n') == EOF) { 1537 pfail(); 1538 return(1); 1539 } 1540 } 1541 return(0); 1542 } 1543 1544 /* 1545 * terminate(): when a SIGINT is recvd 1546 */ 1547 void 1548 terminate(int which_sig __unused) 1549 { 1550 flsh_errs(); 1551 exit(1); 1552 } 1553 1554 1555 /* 1556 * flsh_errs(): output saved up diagnostic messages after all normal 1557 * processing has completed 1558 */ 1559 void 1560 flsh_errs(void) 1561 { 1562 char buf[BUFSIZ]; 1563 1564 (void)fflush(stdout); 1565 (void)fflush(err); 1566 if (err == stderr) 1567 return; 1568 rewind(err); 1569 while (fgets(buf, BUFSIZ, err) != NULL) 1570 (void)fputs(buf, stderr); 1571 } 1572 1573 void 1574 mfail(void) 1575 { 1576 (void)fputs("pr: memory allocation failed\n", err); 1577 } 1578 1579 void 1580 pfail(void) 1581 { 1582 (void)fprintf(err, "pr: write failure, %s\n", strerror(errno)); 1583 } 1584 1585 void 1586 usage(void) 1587 { 1588 (void)fputs( 1589 "usage: pr [+page] [-col] [-adFfmprt] [-e[ch][gap]] [-h header]\n", 1590 err); 1591 (void)fputs( 1592 " [-i[ch][gap]] [-l line] [-n[ch][width]] [-o offset]\n",err); 1593 (void)fputs( 1594 " [-L locale] [-s[ch]] [-w width] [-] [file ...]\n", err); 1595 } 1596 1597 /* 1598 * setup: Validate command args, initialize and perform sanity 1599 * checks on options 1600 */ 1601 int 1602 setup(int argc, char *argv[]) 1603 { 1604 int c; 1605 int d_first; 1606 int eflag = 0; 1607 int iflag = 0; 1608 int wflag = 0; 1609 int cflag = 0; 1610 char *Lflag = NULL; 1611 1612 if (isatty(fileno(stdout))) { 1613 /* 1614 * defer diagnostics until processing is done 1615 */ 1616 if ((err = tmpfile()) == NULL) { 1617 err = stderr; 1618 (void)fputs("Cannot defer diagnostic messages\n",stderr); 1619 return(1); 1620 } 1621 } else 1622 err = stderr; 1623 while ((c = egetopt(argc, argv, "#adFfmrte?h:i?L:l:n?o:ps?w:")) != -1) { 1624 switch (c) { 1625 case '+': 1626 if ((pgnm = atoi(eoptarg)) < 1) { 1627 (void)fputs("pr: +page number must be 1 or more\n", 1628 err); 1629 return(1); 1630 } 1631 break; 1632 case '-': 1633 if ((clcnt = atoi(eoptarg)) < 1) { 1634 (void)fputs("pr: -columns must be 1 or more\n",err); 1635 return(1); 1636 } 1637 if (clcnt > 1) 1638 ++cflag; 1639 break; 1640 case 'a': 1641 ++across; 1642 break; 1643 case 'd': 1644 ++dspace; 1645 break; 1646 case 'e': 1647 ++eflag; 1648 if ((eoptarg != NULL) && !isdigit((unsigned char)*eoptarg)) 1649 inchar = *eoptarg++; 1650 else 1651 inchar = INCHAR; 1652 if ((eoptarg != NULL) && isdigit((unsigned char)*eoptarg)) { 1653 if ((ingap = atoi(eoptarg)) < 0) { 1654 (void)fputs( 1655 "pr: -e gap must be 0 or more\n", err); 1656 return(1); 1657 } 1658 if (ingap == 0) 1659 ingap = INGAP; 1660 } else if ((eoptarg != NULL) && (*eoptarg != '\0')) { 1661 (void)fprintf(err, 1662 "pr: invalid value for -e %s\n", eoptarg); 1663 return(1); 1664 } else 1665 ingap = INGAP; 1666 break; 1667 case 'f': 1668 ++pausefst; 1669 /*FALLTHROUGH*/ 1670 case 'F': 1671 ++formfeed; 1672 break; 1673 case 'h': 1674 header = eoptarg; 1675 break; 1676 case 'i': 1677 ++iflag; 1678 if ((eoptarg != NULL) && !isdigit((unsigned char)*eoptarg)) 1679 ochar = *eoptarg++; 1680 else 1681 ochar = OCHAR; 1682 if ((eoptarg != NULL) && isdigit((unsigned char)*eoptarg)) { 1683 if ((ogap = atoi(eoptarg)) < 0) { 1684 (void)fputs( 1685 "pr: -i gap must be 0 or more\n", err); 1686 return(1); 1687 } 1688 if (ogap == 0) 1689 ogap = OGAP; 1690 } else if ((eoptarg != NULL) && (*eoptarg != '\0')) { 1691 (void)fprintf(err, 1692 "pr: invalid value for -i %s\n", eoptarg); 1693 return(1); 1694 } else 1695 ogap = OGAP; 1696 break; 1697 case 'L': 1698 Lflag = eoptarg; 1699 break; 1700 case 'l': 1701 if (!isdigit((unsigned char)*eoptarg) || ((lines=atoi(eoptarg)) < 1)) { 1702 (void)fputs( 1703 "pr: number of lines must be 1 or more\n",err); 1704 return(1); 1705 } 1706 break; 1707 case 'm': 1708 ++merge; 1709 break; 1710 case 'n': 1711 if ((eoptarg != NULL) && !isdigit((unsigned char)*eoptarg)) 1712 nmchar = *eoptarg++; 1713 else 1714 nmchar = NMCHAR; 1715 if ((eoptarg != NULL) && isdigit((unsigned char)*eoptarg)) { 1716 if ((nmwd = atoi(eoptarg)) < 1) { 1717 (void)fputs( 1718 "pr: -n width must be 1 or more\n",err); 1719 return(1); 1720 } 1721 } else if ((eoptarg != NULL) && (*eoptarg != '\0')) { 1722 (void)fprintf(err, 1723 "pr: invalid value for -n %s\n", eoptarg); 1724 return(1); 1725 } else 1726 nmwd = NMWD; 1727 break; 1728 case 'o': 1729 if (!isdigit((unsigned char)*eoptarg) || ((offst = atoi(eoptarg))< 1)){ 1730 (void)fputs("pr: -o offset must be 1 or more\n", 1731 err); 1732 return(1); 1733 } 1734 break; 1735 case 'p': 1736 ++pauseall; 1737 break; 1738 case 'r': 1739 ++nodiag; 1740 break; 1741 case 's': 1742 ++sflag; 1743 if (eoptarg == NULL) 1744 schar = SCHAR; 1745 else { 1746 schar = *eoptarg++; 1747 if (*eoptarg != '\0') { 1748 (void)fprintf(err, 1749 "pr: invalid value for -s %s\n", 1750 eoptarg); 1751 return(1); 1752 } 1753 } 1754 break; 1755 case 't': 1756 ++nohead; 1757 break; 1758 case 'w': 1759 ++wflag; 1760 if ((eoptarg == NULL ) || 1761 !isdigit((unsigned char)*eoptarg) || 1762 ((pgwd = atoi(eoptarg)) < 1)){ 1763 (void)fputs( 1764 "pr: -w width must be 1 or more \n",err); 1765 return(1); 1766 } 1767 break; 1768 case '?': 1769 default: 1770 return(1); 1771 } 1772 } 1773 1774 /* 1775 * default and sanity checks 1776 */ 1777 if (!clcnt) { 1778 if (merge) { 1779 if ((clcnt = argc - eoptind) <= 1) { 1780 clcnt = CLCNT; 1781 merge = 0; 1782 } 1783 } else 1784 clcnt = CLCNT; 1785 } 1786 if (across) { 1787 if (clcnt == 1) { 1788 (void)fputs("pr: -a flag requires multiple columns\n", 1789 err); 1790 return(1); 1791 } 1792 if (merge) { 1793 (void)fputs("pr: -m cannot be used with -a\n", err); 1794 return(1); 1795 } 1796 } 1797 if (!wflag) { 1798 if (sflag) 1799 pgwd = SPGWD; 1800 else 1801 pgwd = PGWD; 1802 } 1803 if (cflag || merge) { 1804 if (!eflag) { 1805 inchar = INCHAR; 1806 ingap = INGAP; 1807 } 1808 if (!iflag) { 1809 ochar = OCHAR; 1810 ogap = OGAP; 1811 } 1812 } 1813 if (cflag) { 1814 if (merge) { 1815 (void)fputs( 1816 "pr: -m cannot be used with multiple columns\n", err); 1817 return(1); 1818 } 1819 if (nmwd) { 1820 colwd = (pgwd + 1 - (clcnt * (nmwd + 2)))/clcnt; 1821 pgwd = ((colwd + nmwd + 2) * clcnt) - 1; 1822 } else { 1823 colwd = (pgwd + 1 - clcnt)/clcnt; 1824 pgwd = ((colwd + 1) * clcnt) - 1; 1825 } 1826 if (colwd < 1) { 1827 (void)fprintf(err, 1828 "pr: page width is too small for %d columns\n",clcnt); 1829 return(1); 1830 } 1831 } 1832 if (!lines) 1833 lines = LINES; 1834 1835 /* 1836 * make sure long enough for headers. if not disable 1837 */ 1838 if (lines <= HEADLEN + TAILLEN) 1839 ++nohead; 1840 else if (!nohead) 1841 lines -= HEADLEN + TAILLEN; 1842 1843 /* 1844 * adjust for double space on odd length pages 1845 */ 1846 if (dspace) { 1847 if (lines == 1) 1848 dspace = 0; 1849 else { 1850 if (lines & 1) 1851 ++addone; 1852 lines /= 2; 1853 } 1854 } 1855 1856 (void) setlocale(LC_TIME, (Lflag != NULL) ? Lflag : ""); 1857 1858 d_first = (*nl_langinfo(D_MD_ORDER) == 'd'); 1859 timefrmt = strdup(d_first ? TIMEFMTD : TIMEFMTM); 1860 1861 return(0); 1862 } 1863