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