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