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