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