pr.c revision 132672 
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
39static 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
46static 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: head/usr.bin/pr/pr.c 132672 2004-07-26 20:24:59Z charnier $");
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 */
83int	pgnm;			/* starting page number */
84int	clcnt;			/* number of columns */
85int	colwd;			/* column data width - multiple columns */
86int	across;			/* mult col flag; write across page */
87int	dspace;			/* double space flag */
88char	inchar;			/* expand input char */
89int	ingap;			/* expand input gap */
90int	pausefst;		/* Pause before first page */
91int	pauseall;		/* Pause before each page */
92int	formfeed;		/* use formfeed as trailer */
93char	*header;		/* header name instead of file name */
94char	ochar;			/* contract output char */
95int	ogap;			/* contract output gap */
96int	lines;			/* number of lines per page */
97int	merge;			/* merge multiple files in output */
98char	nmchar;			/* line numbering append char */
99int	nmwd;			/* width of line number field */
100int	offst;			/* number of page offset spaces */
101int	nodiag;			/* do not report file open errors */
102char	schar;			/* text column separation character */
103int	sflag;			/* -s option for multiple columns */
104int	nohead;			/* do not write head and trailer */
105int	pgwd;			/* page width with multiple col output */
106const char *timefrmt;		/* time conversion string */
107
108/*
109 * misc globals
110 */
111FILE	*err;			/* error message file pointer */
112int	addone;			/* page length is odd with double space */
113int	errcnt;			/* error count on file processing */
114char	digs[] = "0123456789";	/* page number translation map */
115
116char	fnamedefault[] = FNAME;
117
118int
119main(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 */
150static void
151ttypause(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 */
171int
172onecol(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 */
316int
317vertcol(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 */
637int
638horzcol(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 */
780int
781mulfile(int argc, char *argv[])
782{
783	char *ptbf;
784	int j;
785	int pln;
786	int cnt;
787	char *lstdat;
788	int i;
789	FILE **fbuf;
790	int actf;
791	int lncnt;
792	int col;
793	int pagecnt;
794	int fproc;
795	char *buf;
796	char *hbuf;
797	char *ohbuf;
798	const char *fname;
799	int ips = 0;
800	int cps = 0;
801	int ops = 0;
802	int mor = 0;
803
804	/*
805	 * array of FILE *, one for each operand
806	 */
807	if ((fbuf = (FILE **)malloc((unsigned)clcnt*sizeof(FILE *))) == NULL) {
808		mfail();
809		return(1);
810	}
811
812	/*
813	 * page header
814	 */
815	if ((hbuf = malloc((unsigned)(HDBUF + offst)*sizeof(char))) == NULL) {
816		mfail();
817		return(1);
818	}
819	ohbuf = hbuf + offst;
820
821	/*
822	 * do not know how many columns yet. The number of operands provide an
823	 * upper bound on the number of columns. We use the number of files
824	 * we can open successfully to set the number of columns. The operation
825	 * of the merge operation (-m) in relation to unsuccesful file opens
826	 * is unspecified by posix.
827	 */
828	j = 0;
829	while (j < clcnt) {
830		if ((fbuf[j] = nxtfile(argc, argv, &fname, ohbuf, 1)) == NULL)
831			break;
832		if (pgnm && (inskip(fbuf[j], pgnm, lines)))
833			fbuf[j] = NULL;
834		++j;
835	}
836
837	/*
838	 * if no files, exit
839	 */
840	if (!j)
841		return(1);
842
843	/*
844	 * calculate page boundries based on open file count
845	 */
846	clcnt = j;
847	if (nmwd) {
848		colwd = (pgwd - clcnt - nmwd)/clcnt;
849		pgwd = ((colwd + 1) * clcnt) - nmwd - 2;
850	} else {
851		colwd = (pgwd + 1 - clcnt)/clcnt;
852		pgwd = ((colwd + 1) * clcnt) - 1;
853	}
854	if (colwd < 1) {
855		(void)fprintf(err,
856		  "pr: page width too small for %d columns\n", clcnt);
857		return(1);
858	}
859	actf = clcnt;
860	col = colwd + 1;
861
862	/*
863	 * line buffer
864	 */
865	if ((buf = malloc((unsigned)(pgwd+offst+1)*sizeof(char))) == NULL) {
866		mfail();
867		return(1);
868	}
869	if (offst) {
870		(void)memset(buf, (int)' ', offst);
871		(void)memset(hbuf, (int)' ', offst);
872	}
873	if (pgnm)
874		pagecnt = pgnm;
875	else
876		pagecnt = 1;
877	lncnt = 0;
878
879	/*
880	 * continue to loop while any file still has data
881	 */
882	while (actf > 0) {
883		ttypause(pagecnt);
884
885		/*
886		 * loop by line
887		 */
888		for (i = 0; i < lines; ++i) {
889			ptbf = buf + offst;
890			lstdat = ptbf;
891			if (nmwd) {
892				/*
893				 * add line number to line
894				 */
895				addnum(ptbf, nmwd, ++lncnt);
896				ptbf += nmwd;
897				*ptbf++ = nmchar;
898			}
899			j = 0;
900			fproc = 0;
901
902			/*
903			 * loop by column
904			 */
905			for (j = 0; j < clcnt; ++j) {
906				if (fbuf[j] == NULL) {
907					/*
908					 * empty column; EOF
909					 */
910					cnt = 0;
911				} else if ((cnt = inln(fbuf[j], ptbf, colwd,
912							&cps, 1, &mor)) < 0) {
913					/*
914					 * EOF hit; no data
915					 */
916					if (fbuf[j] != stdin)
917						(void)fclose(fbuf[j]);
918					fbuf[j] = NULL;
919					--actf;
920					cnt = 0;
921				} else {
922					/*
923					 * process file data
924					 */
925					ptbf += cnt;
926					lstdat = ptbf;
927					fproc++;
928				}
929
930				/*
931				 * if last ACTIVE column, done with line
932				 */
933				if (fproc >= actf)
934					break;
935
936				/*
937				 * pad to end of column
938				 */
939				if (sflag) {
940					*ptbf++ = schar;
941				} else if ((pln = col - cnt) > 0) {
942					(void)memset(ptbf, (int)' ', pln);
943					ptbf += pln;
944				}
945			}
946
947			/*
948			 * calculate data in line
949			 */
950			if ((j = lstdat - buf) <= offst)
951				break;
952
953			if (!i && !nohead && prhead(hbuf, fname, pagecnt))
954				return(1);
955
956			/*
957			 * output line
958			 */
959			if (otln(buf, j, &ips, &ops, 0))
960				return(1);
961
962			/*
963			 * if no more active files, done
964			 */
965			if (actf <= 0) {
966				++i;
967				break;
968			}
969		}
970
971		/*
972		 * pad to end of page
973		 */
974		if (i && prtail(lines-i, 0))
975			return(1);
976		++pagecnt;
977	}
978	if (eoptind < argc)
979		return(1);
980	return(0);
981}
982
983/*
984 * inln():	input a line of data (unlimited length lines supported)
985 *		Input is optionally expanded to spaces
986 *
987 *	inf:	file
988 *	buf:	buffer
989 *	lim:	buffer length
990 *	cps:	column positon 1st char in buffer (large line support)
991 *	trnc:	throw away data more than lim up to \n
992 *	mor:	set if more data in line (not truncated)
993 */
994int
995inln(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 */
1099int
1100otln(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 */
1236int
1237inskip(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 */
1264FILE *
1265nxtfile(int argc, char **argv, const char **fname, char *buf, int dt)
1266{
1267	FILE *inf = NULL;
1268	struct timeval tv;
1269	time_t tv_sec;
1270	struct timezone tz;
1271	struct tm *timeptr = NULL;
1272	struct stat statbuf;
1273	static int twice = -1;
1274
1275	++twice;
1276	if (eoptind >= argc) {
1277		/*
1278		 * no file listed; default, use standard input
1279		 */
1280		if (twice)
1281			return(NULL);
1282		clearerr(stdin);
1283		inf = stdin;
1284		if (header != NULL)
1285			*fname = header;
1286		else
1287			*fname = fnamedefault;
1288		if (nohead)
1289			return(inf);
1290		if (gettimeofday(&tv, &tz) < 0) {
1291			++errcnt;
1292			(void)fprintf(err, "pr: cannot get time of day, %s\n",
1293				strerror(errno));
1294			eoptind = argc - 1;
1295			return(NULL);
1296		}
1297		tv_sec = tv.tv_sec;
1298		timeptr = localtime(&tv_sec);
1299	}
1300	for (; eoptind < argc; ++eoptind) {
1301		if (strcmp(argv[eoptind], "-") == 0) {
1302			/*
1303			 * process a "-" for filename
1304			 */
1305			clearerr(stdin);
1306			inf = stdin;
1307			if (header != NULL)
1308				*fname = header;
1309			else
1310				*fname = fnamedefault;
1311			++eoptind;
1312			if (nohead || (dt && twice))
1313				return(inf);
1314			if (gettimeofday(&tv, &tz) < 0) {
1315				++errcnt;
1316				(void)fprintf(err,
1317					"pr: cannot get time of day, %s\n",
1318					strerror(errno));
1319				return(NULL);
1320			}
1321			tv_sec = tv.tv_sec;
1322			timeptr = localtime(&tv_sec);
1323		} else {
1324			/*
1325			 * normal file processing
1326			 */
1327			if ((inf = fopen(argv[eoptind], "r")) == NULL) {
1328				++errcnt;
1329				if (nodiag)
1330					continue;
1331				(void)fprintf(err, "pr: cannot open %s, %s\n",
1332					argv[eoptind], strerror(errno));
1333				continue;
1334			}
1335			if (header != NULL)
1336				*fname = header;
1337			else if (dt)
1338				*fname = fnamedefault;
1339			else
1340				*fname = argv[eoptind];
1341			++eoptind;
1342			if (nohead || (dt && twice))
1343				return(inf);
1344
1345			if (dt) {
1346				if (gettimeofday(&tv, &tz) < 0) {
1347					++errcnt;
1348					(void)fprintf(err,
1349					     "pr: cannot get time of day, %s\n",
1350					     strerror(errno));
1351					return(NULL);
1352				}
1353				tv_sec = tv.tv_sec;
1354				timeptr = localtime(&tv_sec);
1355			} else {
1356				if (fstat(fileno(inf), &statbuf) < 0) {
1357					++errcnt;
1358					(void)fclose(inf);
1359					(void)fprintf(err,
1360						"pr: cannot stat %s, %s\n",
1361						argv[eoptind], strerror(errno));
1362					return(NULL);
1363				}
1364				timeptr = localtime(&(statbuf.st_mtime));
1365			}
1366		}
1367		break;
1368	}
1369	if (inf == NULL)
1370		return(NULL);
1371
1372	/*
1373	 * set up time field used in header
1374	 */
1375	if (strftime(buf, HDBUF, timefrmt, timeptr) <= 0) {
1376		++errcnt;
1377		if (inf != stdin)
1378			(void)fclose(inf);
1379		(void)fputs("pr: time conversion failed\n", err);
1380		return(NULL);
1381	}
1382	return(inf);
1383}
1384
1385/*
1386 * addnum():	adds the line number to the column
1387 *		Truncates from the front or pads with spaces as required.
1388 *		Numbers are right justified.
1389 *
1390 *	buf	buffer to store the number
1391 *	wdth	width of buffer to fill
1392 *	line	line number
1393 *
1394 *		NOTE: numbers occupy part of the column. The posix
1395 *		spec does not specify if -i processing should or should not
1396 *		occur on number padding. The spec does say it occupies
1397 *		part of the column. The usage of addnum	currently treats
1398 *		numbers as part of the column so spaces may be replaced.
1399 */
1400void
1401addnum(char *buf, int wdth, int line)
1402{
1403	char *pt = buf + wdth;
1404
1405	do {
1406		*--pt = digs[line % 10];
1407		line /= 10;
1408	} while (line && (pt > buf));
1409
1410	/*
1411	 * pad with space as required
1412	 */
1413	while (pt > buf)
1414		*--pt = ' ';
1415}
1416
1417/*
1418 * prhead():	prints the top of page header
1419 *
1420 *	buf	buffer with time field (and offset)
1421 *	cnt	number of chars in buf
1422 *	fname	fname field for header
1423 *	pagcnt	page number
1424 */
1425int
1426prhead(char *buf, const char *fname, int pagcnt)
1427{
1428	int ips = 0;
1429	int ops = 0;
1430
1431	if ((putchar('\n') == EOF) || (putchar('\n') == EOF)) {
1432		pfail();
1433		return(1);
1434	}
1435	/*
1436	 * posix is not clear if the header is subject to line length
1437	 * restrictions. The specification for header line format
1438	 * in the spec clearly does not limit length. No pr currently
1439	 * restricts header length. However if we need to truncate in
1440	 * a reasonable way, adjust the length of the printf by
1441	 * changing HDFMT to allow a length max as an arguement printf.
1442	 * buf (which contains the offset spaces and time field could
1443	 * also be trimmed
1444	 *
1445	 * note only the offset (if any) is processed for tab expansion
1446	 */
1447	if (offst && otln(buf, offst, &ips, &ops, -1))
1448		return(1);
1449	(void)printf(HDFMT,buf+offst, fname, pagcnt);
1450	return(0);
1451}
1452
1453/*
1454 * prtail():	pad page with empty lines (if required) and print page trailer
1455 *		if requested
1456 *
1457 *	cnt	number of lines of padding needed
1458 *	incomp	was a '\n' missing from last line output
1459 */
1460int
1461prtail(int cnt, int incomp)
1462{
1463	if (nohead) {
1464		/*
1465		 * only pad with no headers when incomplete last line
1466		 */
1467		if (incomp &&
1468		    ((dspace && (putchar('\n') == EOF)) ||
1469		     (putchar('\n') == EOF))) {
1470			pfail();
1471			return(1);
1472		}
1473		/*
1474		 * but honor the formfeed request
1475		 */
1476		if (formfeed) {
1477			if (putchar('\f') == EOF) {
1478				pfail();
1479				return(1);
1480			}
1481		}
1482		return(0);
1483	}
1484	/*
1485	 * if double space output two \n
1486	 */
1487	if (dspace)
1488		cnt *= 2;
1489
1490	/*
1491	 * if an odd number of lines per page, add an extra \n
1492	 */
1493	if (addone)
1494		++cnt;
1495
1496	/*
1497	 * pad page
1498	 */
1499	if (formfeed) {
1500		if ((incomp && (putchar('\n') == EOF)) ||
1501		    (putchar('\f') == EOF)) {
1502			pfail();
1503			return(1);
1504		}
1505		return(0);
1506	}
1507	cnt += TAILLEN;
1508	while (--cnt >= 0) {
1509		if (putchar('\n') == EOF) {
1510			pfail();
1511			return(1);
1512		}
1513	}
1514	return(0);
1515}
1516
1517/*
1518 * terminate():	when a SIGINT is recvd
1519 */
1520void
1521terminate(int which_sig __unused)
1522{
1523	flsh_errs();
1524	exit(1);
1525}
1526
1527
1528/*
1529 * flsh_errs():	output saved up diagnostic messages after all normal
1530 *		processing has completed
1531 */
1532void
1533flsh_errs(void)
1534{
1535	char buf[BUFSIZ];
1536
1537	(void)fflush(stdout);
1538	(void)fflush(err);
1539	if (err == stderr)
1540		return;
1541	rewind(err);
1542	while (fgets(buf, BUFSIZ, err) != NULL)
1543		(void)fputs(buf, stderr);
1544}
1545
1546void
1547mfail(void)
1548{
1549	(void)fputs("pr: memory allocation failed\n", err);
1550}
1551
1552void
1553pfail(void)
1554{
1555	(void)fprintf(err, "pr: write failure, %s\n", strerror(errno));
1556}
1557
1558void
1559usage(void)
1560{
1561	(void)fputs(
1562	 "usage: pr [+page] [-col] [-adFfmprt] [-e[ch][gap]] [-h header]\n",
1563	 err);
1564	(void)fputs(
1565	 "          [-i[ch][gap]] [-l line] [-n[ch][width]] [-o offset]\n",err);
1566	(void)fputs(
1567	 "          [-L locale] [-s[ch]] [-w width] [-] [file ...]\n", err);
1568}
1569
1570/*
1571 * setup:	Validate command args, initialize and perform sanity
1572 *		checks on options
1573 */
1574int
1575setup(int argc, char *argv[])
1576{
1577	int c;
1578	int d_first;
1579	int eflag = 0;
1580	int iflag = 0;
1581	int wflag = 0;
1582	int cflag = 0;
1583	char *Lflag = NULL;
1584
1585	if (isatty(fileno(stdout))) {
1586		/*
1587		 * defer diagnostics until processing is done
1588		 */
1589		if ((err = tmpfile()) == NULL) {
1590		       err = stderr;
1591		       (void)fputs("Cannot defer diagnostic messages\n",stderr);
1592		       return(1);
1593		}
1594	} else
1595		err = stderr;
1596	while ((c = egetopt(argc, argv, "#adFfmrte?h:i?L:l:n?o:ps?w:")) != -1) {
1597		switch (c) {
1598		case '+':
1599			if ((pgnm = atoi(eoptarg)) < 1) {
1600			    (void)fputs("pr: +page number must be 1 or more\n",
1601				err);
1602			    return(1);
1603			}
1604			break;
1605		case '-':
1606			if ((clcnt = atoi(eoptarg)) < 1) {
1607			    (void)fputs("pr: -columns must be 1 or more\n",err);
1608			    return(1);
1609			}
1610			if (clcnt > 1)
1611				++cflag;
1612			break;
1613		case 'a':
1614			++across;
1615			break;
1616		case 'd':
1617			++dspace;
1618			break;
1619		case 'e':
1620			++eflag;
1621			if ((eoptarg != NULL) && !isdigit((unsigned char)*eoptarg))
1622				inchar = *eoptarg++;
1623			else
1624				inchar = INCHAR;
1625			if ((eoptarg != NULL) && isdigit((unsigned char)*eoptarg)) {
1626				if ((ingap = atoi(eoptarg)) < 0) {
1627					(void)fputs(
1628					"pr: -e gap must be 0 or more\n", err);
1629					return(1);
1630				}
1631				if (ingap == 0)
1632					ingap = INGAP;
1633			} else if ((eoptarg != NULL) && (*eoptarg != '\0')) {
1634				(void)fprintf(err,
1635				      "pr: invalid value for -e %s\n", eoptarg);
1636				return(1);
1637			} else
1638				ingap = INGAP;
1639			break;
1640		case 'f':
1641			++pausefst;
1642			/*FALLTHROUGH*/
1643		case 'F':
1644			++formfeed;
1645			break;
1646		case 'h':
1647			header = eoptarg;
1648			break;
1649		case 'i':
1650			++iflag;
1651			if ((eoptarg != NULL) && !isdigit((unsigned char)*eoptarg))
1652				ochar = *eoptarg++;
1653			else
1654				ochar = OCHAR;
1655			if ((eoptarg != NULL) && isdigit((unsigned char)*eoptarg)) {
1656				if ((ogap = atoi(eoptarg)) < 0) {
1657					(void)fputs(
1658					"pr: -i gap must be 0 or more\n", err);
1659					return(1);
1660				}
1661				if (ogap == 0)
1662					ogap = OGAP;
1663			} else if ((eoptarg != NULL) && (*eoptarg != '\0')) {
1664				(void)fprintf(err,
1665				      "pr: invalid value for -i %s\n", eoptarg);
1666				return(1);
1667			} else
1668				ogap = OGAP;
1669			break;
1670		case 'L':
1671			Lflag = eoptarg;
1672			break;
1673		case 'l':
1674			if (!isdigit((unsigned char)*eoptarg) || ((lines=atoi(eoptarg)) < 1)) {
1675				(void)fputs(
1676				 "pr: number of lines must be 1 or more\n",err);
1677				return(1);
1678			}
1679			break;
1680		case 'm':
1681			++merge;
1682			break;
1683		case 'n':
1684			if ((eoptarg != NULL) && !isdigit((unsigned char)*eoptarg))
1685				nmchar = *eoptarg++;
1686			else
1687				nmchar = NMCHAR;
1688			if ((eoptarg != NULL) && isdigit((unsigned char)*eoptarg)) {
1689				if ((nmwd = atoi(eoptarg)) < 1) {
1690					(void)fputs(
1691					"pr: -n width must be 1 or more\n",err);
1692					return(1);
1693				}
1694			} else if ((eoptarg != NULL) && (*eoptarg != '\0')) {
1695				(void)fprintf(err,
1696				      "pr: invalid value for -n %s\n", eoptarg);
1697				return(1);
1698			} else
1699				nmwd = NMWD;
1700			break;
1701		case 'o':
1702			if (!isdigit((unsigned char)*eoptarg) || ((offst = atoi(eoptarg))< 1)){
1703				(void)fputs("pr: -o offset must be 1 or more\n",
1704					err);
1705				return(1);
1706			}
1707			break;
1708		case 'p':
1709			++pauseall;
1710			break;
1711		case 'r':
1712			++nodiag;
1713			break;
1714		case 's':
1715			++sflag;
1716			if (eoptarg == NULL)
1717				schar = SCHAR;
1718			else {
1719				schar = *eoptarg++;
1720				if (*eoptarg != '\0') {
1721					(void)fprintf(err,
1722					    "pr: invalid value for -s %s\n",
1723					    eoptarg);
1724					return(1);
1725				}
1726			}
1727			break;
1728		case 't':
1729			++nohead;
1730			break;
1731		case 'w':
1732			++wflag;
1733			if (!isdigit((unsigned char)*eoptarg) || ((pgwd = atoi(eoptarg)) < 1)){
1734				(void)fputs(
1735				   "pr: -w width must be 1 or more \n",err);
1736				return(1);
1737			}
1738			break;
1739		case '?':
1740		default:
1741			return(1);
1742		}
1743	}
1744
1745	/*
1746	 * default and sanity checks
1747	 */
1748	if (!clcnt) {
1749		if (merge) {
1750			if ((clcnt = argc - eoptind) <= 1) {
1751				clcnt = CLCNT;
1752				merge = 0;
1753			}
1754		} else
1755			clcnt = CLCNT;
1756	}
1757	if (across) {
1758		if (clcnt == 1) {
1759			(void)fputs("pr: -a flag requires multiple columns\n",
1760				err);
1761			return(1);
1762		}
1763		if (merge) {
1764			(void)fputs("pr: -m cannot be used with -a\n", err);
1765			return(1);
1766		}
1767	}
1768	if (!wflag) {
1769		if (sflag)
1770			pgwd = SPGWD;
1771		else
1772			pgwd = PGWD;
1773	}
1774	if (cflag || merge) {
1775		if (!eflag) {
1776			inchar = INCHAR;
1777			ingap = INGAP;
1778		}
1779		if (!iflag) {
1780			ochar = OCHAR;
1781			ogap = OGAP;
1782		}
1783	}
1784	if (cflag) {
1785		if (merge) {
1786			(void)fputs(
1787			  "pr: -m cannot be used with multiple columns\n", err);
1788			return(1);
1789		}
1790		if (nmwd) {
1791			colwd = (pgwd + 1 - (clcnt * (nmwd + 2)))/clcnt;
1792			pgwd = ((colwd + nmwd + 2) * clcnt) - 1;
1793		} else {
1794			colwd = (pgwd + 1 - clcnt)/clcnt;
1795			pgwd = ((colwd + 1) * clcnt) - 1;
1796		}
1797		if (colwd < 1) {
1798			(void)fprintf(err,
1799			  "pr: page width is too small for %d columns\n",clcnt);
1800			return(1);
1801		}
1802	}
1803	if (!lines)
1804		lines = LINES;
1805
1806	/*
1807	 * make sure long enough for headers. if not disable
1808	 */
1809	if (lines <= HEADLEN + TAILLEN)
1810		++nohead;
1811	else if (!nohead)
1812		lines -= HEADLEN + TAILLEN;
1813
1814	/*
1815	 * adjust for double space on odd length pages
1816	 */
1817	if (dspace) {
1818		if (lines == 1)
1819			dspace = 0;
1820		else {
1821			if (lines & 1)
1822				++addone;
1823			lines /= 2;
1824		}
1825	}
1826
1827	(void) setlocale(LC_TIME, (Lflag != NULL) ? Lflag : "");
1828
1829	d_first = (*nl_langinfo(D_MD_ORDER) == 'd');
1830	timefrmt = strdup(d_first ? TIMEFMTD : TIMEFMTM);
1831
1832	return(0);
1833}
1834