1 /*-
2 * Copyright (c) 1991 Keith Muller.
3 * Copyright (c) 1993
4 * The Regents of the University of California. All rights reserved.
5 *
6 * This code is derived from software contributed to Berkeley by
7 * Keith Muller of the University of California, San Diego.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed by the University of
20 * California, Berkeley and its contributors.
21 * 4. Neither the name of the University nor the names of its contributors
22 * may be used to endorse or promote products derived from this software
23 * without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 */
37
38 #ifndef lint
39 static const char copyright[] =
40 "@(#) Copyright (c) 1993\n\
41 The Regents of the University of California. All rights reserved.\n";
42 #endif /* not lint */
43
44 #if 0
45 #ifndef lint
46 static char sccsid[] = "@(#)pr.c 8.2 (Berkeley) 4/16/94";
47 #endif /* not lint */
48 #endif
49
50 #include <sys/cdefs.h>
51 __FBSDID("$FreeBSD$");
52
53 #include <sys/types.h>
54 #include <sys/time.h>
55 #include <sys/stat.h>
56
57 #include <ctype.h>
58 #include <errno.h>
59 #include <langinfo.h>
60 #include <locale.h>
61 #include <signal.h>
62 #include <stdio.h>
63 #include <stdlib.h>
64 #include <string.h>
65 #include <unistd.h>
66
67 #include "pr.h"
68 #include "extern.h"
69
70 /*
71 * pr: a printing and pagination filter. If multiple input files
72 * are specified, each is read, formatted, and written to standard
73 * output. By default, input is separated into 66-line pages, each
74 * with a header that includes the page number, date, time and the
75 * files pathname.
76 *
77 * Complies with posix P1003.2/D11
78 */
79
80 /*
81 * parameter variables
82 */
83 static int pgnm; /* starting page number */
84 static int clcnt; /* number of columns */
85 static int colwd; /* column data width - multiple columns */
86 static int across; /* mult col flag; write across page */
87 static int dspace; /* double space flag */
88 static char inchar; /* expand input char */
89 static int ingap; /* expand input gap */
90 static int pausefst; /* Pause before first page */
91 static int pauseall; /* Pause before each page */
92 static int formfeed; /* use formfeed as trailer */
93 static char *header; /* header name instead of file name */
94 static char ochar; /* contract output char */
95 static int ogap; /* contract output gap */
96 static int lines; /* number of lines per page */
97 static int merge; /* merge multiple files in output */
98 static char nmchar; /* line numbering append char */
99 static int nmwd; /* width of line number field */
100 static int offst; /* number of page offset spaces */
101 static int nodiag; /* do not report file open errors */
102 static char schar; /* text column separation character */
103 static int sflag; /* -s option for multiple columns */
104 static int nohead; /* do not write head and trailer */
105 static int pgwd; /* page width with multiple col output */
106 static const char *timefrmt; /* time conversion string */
107
108 /*
109 * misc globals
110 */
111 static FILE *err; /* error message file pointer */
112 static int addone; /* page length is odd with double space */
113 static int errcnt; /* error count on file processing */
114 static char digs[] = "0123456789"; /* page number translation map */
115
116 static char fnamedefault[] = FNAME;
117
118 int
main(int argc,char * argv[])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
ttypause(int pagecnt)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
onecol(int argc,char * argv[])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
vertcol(int argc,char * argv[])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
horzcol(int argc,char * argv[])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
mulfile(int argc,char * argv[])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 unsuccessful 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 boundaries 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 position 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
inln(FILE * inf,char * buf,int lim,int * cps,int trnc,int * mor)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
otln(char * buf,int cnt,int * svips,int * svops,int mor)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
inskip(FILE * inf,int pgcnt,int lncnt)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 *
nxtfile(int argc,char ** argv,const char ** fname,char * buf,int dt)1265 nxtfile(int argc, char **argv, const char **fname, char *buf, int dt)
1266 {
1267 FILE *inf = NULL;
1268 time_t tv_sec;
1269 struct tm *timeptr = NULL;
1270 struct stat statbuf;
1271 static int twice = -1;
1272
1273 ++twice;
1274 if (eoptind >= argc) {
1275 /*
1276 * no file listed; default, use standard input
1277 */
1278 if (twice)
1279 return(NULL);
1280 clearerr(stdin);
1281 inf = stdin;
1282 if (header != NULL)
1283 *fname = header;
1284 else
1285 *fname = fnamedefault;
1286 if (nohead)
1287 return(inf);
1288 if ((tv_sec = time(NULL)) == -1) {
1289 ++errcnt;
1290 (void)fprintf(err, "pr: cannot get time of day, %s\n",
1291 strerror(errno));
1292 eoptind = argc - 1;
1293 return(NULL);
1294 }
1295 timeptr = localtime(&tv_sec);
1296 }
1297 for (; eoptind < argc; ++eoptind) {
1298 if (strcmp(argv[eoptind], "-") == 0) {
1299 /*
1300 * process a "-" for filename
1301 */
1302 clearerr(stdin);
1303 inf = stdin;
1304 if (header != NULL)
1305 *fname = header;
1306 else
1307 *fname = fnamedefault;
1308 ++eoptind;
1309 if (nohead || (dt && twice))
1310 return(inf);
1311 if ((tv_sec = time(NULL)) == -1) {
1312 ++errcnt;
1313 (void)fprintf(err,
1314 "pr: cannot get time of day, %s\n",
1315 strerror(errno));
1316 return(NULL);
1317 }
1318 timeptr = localtime(&tv_sec);
1319 } else {
1320 /*
1321 * normal file processing
1322 */
1323 if ((inf = fopen(argv[eoptind], "r")) == NULL) {
1324 ++errcnt;
1325 if (nodiag)
1326 continue;
1327 (void)fprintf(err, "pr: cannot open %s, %s\n",
1328 argv[eoptind], strerror(errno));
1329 continue;
1330 }
1331 if (header != NULL)
1332 *fname = header;
1333 else if (dt)
1334 *fname = fnamedefault;
1335 else
1336 *fname = argv[eoptind];
1337 ++eoptind;
1338 if (nohead || (dt && twice))
1339 return(inf);
1340
1341 if (dt) {
1342 if ((tv_sec = time(NULL)) == -1) {
1343 ++errcnt;
1344 (void)fprintf(err,
1345 "pr: cannot get time of day, %s\n",
1346 strerror(errno));
1347 return(NULL);
1348 }
1349 timeptr = localtime(&tv_sec);
1350 } else {
1351 if (fstat(fileno(inf), &statbuf) < 0) {
1352 ++errcnt;
1353 (void)fclose(inf);
1354 (void)fprintf(err,
1355 "pr: cannot stat %s, %s\n",
1356 argv[eoptind], strerror(errno));
1357 return(NULL);
1358 }
1359 timeptr = localtime(&(statbuf.st_mtime));
1360 }
1361 }
1362 break;
1363 }
1364 if (inf == NULL)
1365 return(NULL);
1366
1367 /*
1368 * set up time field used in header
1369 */
1370 if (strftime(buf, HDBUF, timefrmt, timeptr) <= 0) {
1371 ++errcnt;
1372 if (inf != stdin)
1373 (void)fclose(inf);
1374 (void)fputs("pr: time conversion failed\n", err);
1375 return(NULL);
1376 }
1377 return(inf);
1378 }
1379
1380 /*
1381 * addnum(): adds the line number to the column
1382 * Truncates from the front or pads with spaces as required.
1383 * Numbers are right justified.
1384 *
1385 * buf buffer to store the number
1386 * wdth width of buffer to fill
1387 * line line number
1388 *
1389 * NOTE: numbers occupy part of the column. The posix
1390 * spec does not specify if -i processing should or should not
1391 * occur on number padding. The spec does say it occupies
1392 * part of the column. The usage of addnum currently treats
1393 * numbers as part of the column so spaces may be replaced.
1394 */
1395 void
addnum(char * buf,int wdth,int line)1396 addnum(char *buf, int wdth, int line)
1397 {
1398 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
prhead(char * buf,const char * fname,int pagcnt)1421 prhead(char *buf, const char *fname, int pagcnt)
1422 {
1423 int ips = 0;
1424 int ops = 0;
1425
1426 if ((putchar('\n') == EOF) || (putchar('\n') == EOF)) {
1427 pfail();
1428 return(1);
1429 }
1430 /*
1431 * posix is not clear if the header is subject to line length
1432 * restrictions. The specification for header line format
1433 * in the spec clearly does not limit length. No pr currently
1434 * restricts header length. However if we need to truncate in
1435 * a reasonable way, adjust the length of the printf by
1436 * changing HDFMT to allow a length max as an argument to printf.
1437 * buf (which contains the offset spaces and time field could
1438 * also be trimmed
1439 *
1440 * note only the offset (if any) is processed for tab expansion
1441 */
1442 if (offst && otln(buf, offst, &ips, &ops, -1))
1443 return(1);
1444 (void)printf(HDFMT,buf+offst, fname, pagcnt);
1445 return(0);
1446 }
1447
1448 /*
1449 * prtail(): pad page with empty lines (if required) and print page trailer
1450 * if requested
1451 *
1452 * cnt number of lines of padding needed
1453 * incomp was a '\n' missing from last line output
1454 */
1455 int
prtail(int cnt,int incomp)1456 prtail(int cnt, int incomp)
1457 {
1458 if (nohead) {
1459 /*
1460 * only pad with no headers when incomplete last line
1461 */
1462 if (incomp &&
1463 ((dspace && (putchar('\n') == EOF)) ||
1464 (putchar('\n') == EOF))) {
1465 pfail();
1466 return(1);
1467 }
1468 /*
1469 * but honor the formfeed request
1470 */
1471 if (formfeed) {
1472 if (putchar('\f') == EOF) {
1473 pfail();
1474 return(1);
1475 }
1476 }
1477 return(0);
1478 }
1479 /*
1480 * if double space output two \n
1481 */
1482 if (dspace)
1483 cnt *= 2;
1484
1485 /*
1486 * if an odd number of lines per page, add an extra \n
1487 */
1488 if (addone)
1489 ++cnt;
1490
1491 /*
1492 * pad page
1493 */
1494 if (formfeed) {
1495 if ((incomp && (putchar('\n') == EOF)) ||
1496 (putchar('\f') == EOF)) {
1497 pfail();
1498 return(1);
1499 }
1500 return(0);
1501 }
1502 cnt += TAILLEN;
1503 while (--cnt >= 0) {
1504 if (putchar('\n') == EOF) {
1505 pfail();
1506 return(1);
1507 }
1508 }
1509 return(0);
1510 }
1511
1512 /*
1513 * terminate(): when a SIGINT is recvd
1514 */
1515 void
terminate(int which_sig __unused)1516 terminate(int which_sig __unused)
1517 {
1518 flsh_errs();
1519 exit(1);
1520 }
1521
1522
1523 /*
1524 * flsh_errs(): output saved up diagnostic messages after all normal
1525 * processing has completed
1526 */
1527 void
flsh_errs(void)1528 flsh_errs(void)
1529 {
1530 char buf[BUFSIZ];
1531
1532 (void)fflush(stdout);
1533 (void)fflush(err);
1534 if (err == stderr)
1535 return;
1536 rewind(err);
1537 while (fgets(buf, BUFSIZ, err) != NULL)
1538 (void)fputs(buf, stderr);
1539 }
1540
1541 void
mfail(void)1542 mfail(void)
1543 {
1544 (void)fputs("pr: memory allocation failed\n", err);
1545 }
1546
1547 void
pfail(void)1548 pfail(void)
1549 {
1550 (void)fprintf(err, "pr: write failure, %s\n", strerror(errno));
1551 }
1552
1553 void
usage(void)1554 usage(void)
1555 {
1556 (void)fputs(
1557 "usage: pr [+page] [-col] [-adFfmprt] [-e[ch][gap]] [-h header]\n",
1558 err);
1559 (void)fputs(
1560 " [-i[ch][gap]] [-l line] [-n[ch][width]] [-o offset]\n",err);
1561 (void)fputs(
1562 " [-L locale] [-s[ch]] [-w width] [-] [file ...]\n", err);
1563 }
1564
1565 /*
1566 * setup: Validate command args, initialize and perform sanity
1567 * checks on options
1568 */
1569 int
setup(int argc,char * argv[])1570 setup(int argc, char *argv[])
1571 {
1572 int c;
1573 int d_first;
1574 int eflag = 0;
1575 int iflag = 0;
1576 int wflag = 0;
1577 int cflag = 0;
1578 char *Lflag = NULL;
1579
1580 if (isatty(fileno(stdout))) {
1581 /*
1582 * defer diagnostics until processing is done
1583 */
1584 if ((err = tmpfile()) == NULL) {
1585 err = stderr;
1586 (void)fputs("Cannot defer diagnostic messages\n",stderr);
1587 return(1);
1588 }
1589 } else
1590 err = stderr;
1591 while ((c = egetopt(argc, argv, "#adFfmrte?h:i?L:l:n?o:ps?w:")) != -1) {
1592 switch (c) {
1593 case '+':
1594 if ((pgnm = atoi(eoptarg)) < 1) {
1595 (void)fputs("pr: +page number must be 1 or more\n",
1596 err);
1597 return(1);
1598 }
1599 break;
1600 case '-':
1601 if ((clcnt = atoi(eoptarg)) < 1) {
1602 (void)fputs("pr: -columns must be 1 or more\n",err);
1603 return(1);
1604 }
1605 if (clcnt > 1)
1606 ++cflag;
1607 break;
1608 case 'a':
1609 ++across;
1610 break;
1611 case 'd':
1612 ++dspace;
1613 break;
1614 case 'e':
1615 ++eflag;
1616 if ((eoptarg != NULL) && !isdigit((unsigned char)*eoptarg))
1617 inchar = *eoptarg++;
1618 else
1619 inchar = INCHAR;
1620 if ((eoptarg != NULL) && isdigit((unsigned char)*eoptarg)) {
1621 if ((ingap = atoi(eoptarg)) < 0) {
1622 (void)fputs(
1623 "pr: -e gap must be 0 or more\n", err);
1624 return(1);
1625 }
1626 if (ingap == 0)
1627 ingap = INGAP;
1628 } else if ((eoptarg != NULL) && (*eoptarg != '\0')) {
1629 (void)fprintf(err,
1630 "pr: invalid value for -e %s\n", eoptarg);
1631 return(1);
1632 } else
1633 ingap = INGAP;
1634 break;
1635 case 'f':
1636 ++pausefst;
1637 /*FALLTHROUGH*/
1638 case 'F':
1639 ++formfeed;
1640 break;
1641 case 'h':
1642 header = eoptarg;
1643 break;
1644 case 'i':
1645 ++iflag;
1646 if ((eoptarg != NULL) && !isdigit((unsigned char)*eoptarg))
1647 ochar = *eoptarg++;
1648 else
1649 ochar = OCHAR;
1650 if ((eoptarg != NULL) && isdigit((unsigned char)*eoptarg)) {
1651 if ((ogap = atoi(eoptarg)) < 0) {
1652 (void)fputs(
1653 "pr: -i gap must be 0 or more\n", err);
1654 return(1);
1655 }
1656 if (ogap == 0)
1657 ogap = OGAP;
1658 } else if ((eoptarg != NULL) && (*eoptarg != '\0')) {
1659 (void)fprintf(err,
1660 "pr: invalid value for -i %s\n", eoptarg);
1661 return(1);
1662 } else
1663 ogap = OGAP;
1664 break;
1665 case 'L':
1666 Lflag = eoptarg;
1667 break;
1668 case 'l':
1669 if (!isdigit((unsigned char)*eoptarg) || ((lines=atoi(eoptarg)) < 1)) {
1670 (void)fputs(
1671 "pr: number of lines must be 1 or more\n",err);
1672 return(1);
1673 }
1674 break;
1675 case 'm':
1676 ++merge;
1677 break;
1678 case 'n':
1679 if ((eoptarg != NULL) && !isdigit((unsigned char)*eoptarg))
1680 nmchar = *eoptarg++;
1681 else
1682 nmchar = NMCHAR;
1683 if ((eoptarg != NULL) && isdigit((unsigned char)*eoptarg)) {
1684 if ((nmwd = atoi(eoptarg)) < 1) {
1685 (void)fputs(
1686 "pr: -n width must be 1 or more\n",err);
1687 return(1);
1688 }
1689 } else if ((eoptarg != NULL) && (*eoptarg != '\0')) {
1690 (void)fprintf(err,
1691 "pr: invalid value for -n %s\n", eoptarg);
1692 return(1);
1693 } else
1694 nmwd = NMWD;
1695 break;
1696 case 'o':
1697 if (!isdigit((unsigned char)*eoptarg) || ((offst = atoi(eoptarg))< 1)){
1698 (void)fputs("pr: -o offset must be 1 or more\n",
1699 err);
1700 return(1);
1701 }
1702 break;
1703 case 'p':
1704 ++pauseall;
1705 break;
1706 case 'r':
1707 ++nodiag;
1708 break;
1709 case 's':
1710 ++sflag;
1711 if (eoptarg == NULL)
1712 schar = SCHAR;
1713 else {
1714 schar = *eoptarg++;
1715 if (*eoptarg != '\0') {
1716 (void)fprintf(err,
1717 "pr: invalid value for -s %s\n",
1718 eoptarg);
1719 return(1);
1720 }
1721 }
1722 break;
1723 case 't':
1724 ++nohead;
1725 break;
1726 case 'w':
1727 ++wflag;
1728 if (!isdigit((unsigned char)*eoptarg) || ((pgwd = atoi(eoptarg)) < 1)){
1729 (void)fputs(
1730 "pr: -w width must be 1 or more \n",err);
1731 return(1);
1732 }
1733 break;
1734 case '?':
1735 default:
1736 return(1);
1737 }
1738 }
1739
1740 /*
1741 * default and sanity checks
1742 */
1743 if (!clcnt) {
1744 if (merge) {
1745 if ((clcnt = argc - eoptind) <= 1) {
1746 clcnt = CLCNT;
1747 merge = 0;
1748 }
1749 } else
1750 clcnt = CLCNT;
1751 }
1752 if (across) {
1753 if (clcnt == 1) {
1754 (void)fputs("pr: -a flag requires multiple columns\n",
1755 err);
1756 return(1);
1757 }
1758 if (merge) {
1759 (void)fputs("pr: -m cannot be used with -a\n", err);
1760 return(1);
1761 }
1762 }
1763 if (!wflag) {
1764 if (sflag)
1765 pgwd = SPGWD;
1766 else
1767 pgwd = PGWD;
1768 }
1769 if (cflag || merge) {
1770 if (!eflag) {
1771 inchar = INCHAR;
1772 ingap = INGAP;
1773 }
1774 if (!iflag) {
1775 ochar = OCHAR;
1776 ogap = OGAP;
1777 }
1778 }
1779 if (cflag) {
1780 if (merge) {
1781 (void)fputs(
1782 "pr: -m cannot be used with multiple columns\n", err);
1783 return(1);
1784 }
1785 if (nmwd) {
1786 colwd = (pgwd + 1 - (clcnt * (nmwd + 2)))/clcnt;
1787 pgwd = ((colwd + nmwd + 2) * clcnt) - 1;
1788 } else {
1789 colwd = (pgwd + 1 - clcnt)/clcnt;
1790 pgwd = ((colwd + 1) * clcnt) - 1;
1791 }
1792 if (colwd < 1) {
1793 (void)fprintf(err,
1794 "pr: page width is too small for %d columns\n",clcnt);
1795 return(1);
1796 }
1797 }
1798 if (!lines)
1799 lines = LINES;
1800
1801 /*
1802 * make sure long enough for headers. if not disable
1803 */
1804 if (lines <= HEADLEN + TAILLEN)
1805 ++nohead;
1806 else if (!nohead)
1807 lines -= HEADLEN + TAILLEN;
1808
1809 /*
1810 * adjust for double space on odd length pages
1811 */
1812 if (dspace) {
1813 if (lines == 1)
1814 dspace = 0;
1815 else {
1816 if (lines & 1)
1817 ++addone;
1818 lines /= 2;
1819 }
1820 }
1821
1822 (void) setlocale(LC_TIME, (Lflag != NULL) ? Lflag : "");
1823
1824 d_first = (*nl_langinfo(D_MD_ORDER) == 'd');
1825 timefrmt = strdup(d_first ? TIMEFMTD : TIMEFMTM);
1826
1827 return(0);
1828 }
1829