xref: /illumos-gate/usr/src/cmd/pr/pr.c (revision 3d19b30e50b972b09ded7f37b8a5fc36d10588e6)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 *	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T
 *	All Rights Reserved
 */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*
 *	PR command (print files in pages and columns, with headings)
 *	2+head+2+page[56]+5
 */

#include <stdio.h>
#include <signal.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>
#include <limits.h>
#include <wchar.h>
#include <errno.h>

#define	ESC		'\033'
#define	LENGTH		66
#define	LINEW		72
#define	NUMW		5
#define	MARGIN		10
#define	DEFTAB		8
#define	NFILES		10
#define	STDINNAME()	nulls
#define	PROMPT()	(void) putc('\7', stderr) /* BEL */
#define	NOFILE		nulls
#define	ETABS		(Inpos % Etabn)
#define	NSEPC		'\t'
#define	HEAD		gettext("%s  %s Page %d\n\n\n"), date, head, Page
#define	cerror(S)	(void) fprintf(stderr, "pr: %s", gettext(S))
#define	done()		if (Ttyout) (void) chmod(Ttyout, Mode)
#define	ALL_NUMS(s)	(strspn(s, "0123456789") == strlen(s))
#define	REMOVE_ARG(argc, argp)					\
			{					\
				char	**p = argp;		\
				while (*p != NULL)		\
				{				\
					*p = *(p + 1);		\
					p++;			\
				}				\
				argc--;				\
			}
#define	SQUEEZE_ARG(argp, ind, n)					\
			{					\
				int	i;			\
				for (i = ind; argp[i]; i++)	\
					argp[i] = argp[i + n];	\
			}

/*
 *   ---date time format---
 *   b -- abbreviated month name
 *   e -- day of month
 *   H -- Hour (24 hour version)
 *   M -- Minute
 *   Y -- Year in the form ccyy
 */
#define	FORMAT		"%b %e %H:%M %Y"

typedef	int	ANY;
typedef	unsigned	int	UNS;
typedef	struct	{ FILE *f_f; char *f_name; wchar_t f_nextc; } FILS;
typedef	struct	{int fold; int skip; int eof; } foldinf;
typedef	struct	{ wchar_t *c_ptr, *c_ptr0; long c_lno; int c_skip; } *COLP;
typedef struct	err { struct err *e_nextp; char *e_mess; } ERR;

/*
 * Global data.
 */
static	FILS	*Files;
static	mode_t	Mode;
static	int	Multi = 0;
static	int	Nfiles = 0;
static	int	Error = 0;
static	char	nulls[] = "";
static	char	*Ttyout;
static	char	obuf[BUFSIZ];
static	char	time_buf[50];	/* array to hold the time and date */
static	long	Lnumb = 0;
static	FILE	*Ttyin = stdin;
static	int	Dblspace = 1;
static	int	Fpage = 1;
static	int	Formfeed = 0;
static	int	Length = LENGTH;
static	int	Linew = 0;
static	int	Offset = 0;
static	int	Ncols = 0;
static	int	Pause = 0;
static	wchar_t	Sepc = 0;
static	int	Colw;
static	int	Plength;
static	int	Margin = MARGIN;
static	int	Numw;
static	int	Nsepc = NSEPC;
static	int	Report = 1;
static	int	Etabn = 0;
static	wchar_t	Etabc = '\t';
static	int	Itabn = 0;
static	wchar_t	Itabc = '\t';
static	int	fold = 0;
static	int	foldcol = 0;
static	int	alleof = 0;
static	char	*Head = NULL;
static	wchar_t *Buffer = NULL, *Bufend, *Bufptr;
static	UNS	Buflen;
static	COLP	Colpts;
static	foldinf	*Fcol;
static	int	Page;
static	wchar_t	C = '\0';
static	int	Nspace;
static	int	Inpos;
static	int	Outpos;
static	int	Lcolpos;
static	int	Pcolpos;
static	int	Line;
static	ERR	*Err = NULL;
static	ERR	*Lasterr = (ERR *)&Err;
static	int	mbcurmax = 1;

/*
 * Function prototypes.
 */
static	void	onintr();
static	ANY	*getspace();
static	int	findopt(int, char **);
static	void	fixtty();
static	char 	*GETDATE();
static	char	*ffiler(char *);
static	int	print(char *);
static	void	putpage();
static	void	foldpage();
static	void	nexbuf();
static	void	foldbuf();
static	void	balance(int);
static	int	readbuf(wchar_t **, int, COLP);
static	wint_t	get(int);
static	int	put(wchar_t);
static	void	putspace();
static	void	unget(int);
static	FILE	*mustopen(char *, FILS *);
static	void	die(char *);
static	void	errprint();
static	void	usage(int);
static wint_t	_fgetwc_pr(FILE *, int *);
static size_t	freadw(wchar_t *, size_t, FILE *);


int
main(int argc, char **argv)
{
	FILS	fstr[NFILES];
	int	nfdone = 0;


	/* Get locale variables for environment */
	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
#define	TEXT_DOMAIN "SYS_TEST"	/* Use this only if it weren't */
#endif
	(void) textdomain(TEXT_DOMAIN);

	mbcurmax = MB_CUR_MAX;
	Files = fstr;
	for (argc = findopt(argc, argv); argc > 0; --argc, ++argv) {
		if (Multi == 'm') {
			if (Nfiles >= NFILES - 1) die("too many files");
			if (mustopen(*argv, &Files[Nfiles++]) == NULL)
				++nfdone;	/* suppress printing */
		} else {
			if (print(*argv))
				(void) fclose(Files->f_f);
			++nfdone;
		}
	}
	if (!nfdone)	/* no files named, use stdin */
		(void) print(NOFILE);	/* on GCOS, use current file, if any */

	if (Report) {
		errprint();	/* print accumulated error reports */
		exit(Error);
	}

	return (Error);
}


/*
 * findopt() returns argc modified to be the number of explicitly supplied
 * filenames, including '-', the explicit request to use stdin.
 * argc == 0 implies that no filenames were supplied and stdin should be used.
 * Options are striped from argv and only file names are returned.
 */

static	int
findopt(int argc, char **argv)
{
	int	eargc = 0;
	int	c;
	int	mflg = 0;
	int	aflg = 0;
	int	optnum;
	int	argv_ind;
	int	end_opt;
	int	i;
	int	isarg = 0;

	fixtty();

	/* Handle page number option */
	for (optnum = 1, end_opt = 0; optnum < argc && !end_opt; optnum++) {
		switch (*argv[optnum]) {
		case '+':
			/* check for all digits */
			if (strlen(&argv[optnum][1]) !=
			    strspn(&argv[optnum][1], "0123456789")) {
				(void) fprintf(stderr, gettext(
				    "pr: Badly formed number\n"));
				exit(1);
			}

			if ((Fpage = (int)strtol(&argv[optnum][1],
			    (char **)NULL, 10)) < 0) {
				(void) fprintf(stderr, gettext(
				    "pr: Badly formed number\n"));
				exit(1);
			}
			REMOVE_ARG(argc, &argv[optnum]);
			optnum--;
			break;

		case '-':
			/* Check for end of options */
			if (argv[optnum][1] == '-') {
				end_opt++;
				break;
			}

			if (argv[optnum][1] == 'h' || argv[optnum][1] == 'l' ||
			    argv[optnum][1] == 'o' || argv[optnum][1] == 'w')
				isarg = 1;
			else
				isarg = 0;

			break;

		default:
			if (isarg == 0)
				end_opt++;
			else
				isarg = 0;
			break;
		}
	}

	/*
	 * Handle options with optional arguments.
	 * If optional arguments are present they may not be separated
	 * from the option letter.
	 */

	for (optnum = 1; optnum < argc; optnum++) {
		if (argv[optnum][0] == '-' && argv[optnum][1] == '-')
			/* End of options */
			break;

		if (argv[optnum][0] == '-' && argv[optnum][1] == '\0')
			/* stdin file name */
			continue;

		if (argv[optnum][0] != '-')
			/* not option */
			continue;

		for (argv_ind = 1; argv[optnum][argv_ind] != '\0'; argv_ind++) {
			switch (argv[optnum][argv_ind]) {
			case 'e':
				SQUEEZE_ARG(argv[optnum], argv_ind, 1);
				if ((c = argv[optnum][argv_ind]) != '\0' &&
				    !isdigit(c)) {
					int	r;
					wchar_t	wc;
					r = mbtowc(&wc, &argv[optnum][argv_ind],
						mbcurmax);
					if (r == -1) {
						(void) fprintf(stderr, gettext(
"pr: Illegal character in -e option\n"));
						exit(1);
					}
					Etabc = wc;
					SQUEEZE_ARG(argv[optnum], argv_ind, r);
				}
				if (isdigit(argv[optnum][argv_ind])) {
					Etabn = (int)strtol(&argv[optnum]
					    [argv_ind], (char **)NULL, 10);
					while (isdigit(argv[optnum][argv_ind]))
					    SQUEEZE_ARG(argv[optnum],
							argv_ind, 1);
				}
				if (Etabn <= 0)
					Etabn = DEFTAB;
				argv_ind--;
				break;

			case 'i':
				SQUEEZE_ARG(argv[optnum], argv_ind, 1);
				if ((c = argv[optnum][argv_ind]) != '\0' &&
				    !isdigit(c)) {
					int	r;
					wchar_t	wc;
					r = mbtowc(&wc, &argv[optnum][argv_ind],
						mbcurmax);
					if (r == -1) {
						(void) fprintf(stderr, gettext(
"pr: Illegal character in -i option\n"));
						exit(1);
					}
					Itabc = wc;
					SQUEEZE_ARG(argv[optnum], argv_ind, r);
				}
				if (isdigit(argv[optnum][argv_ind])) {
					Itabn = (int)strtol(&argv[optnum]
					    [argv_ind], (char **)NULL, 10);
					while (isdigit(argv[optnum][argv_ind]))
					    SQUEEZE_ARG(argv[optnum],
							argv_ind, 1);
				}
				if (Itabn <= 0)
					Itabn = DEFTAB;
				argv_ind--;
				break;


			case 'n':
				++Lnumb;
				SQUEEZE_ARG(argv[optnum], argv_ind, 1);
				if ((c = argv[optnum][argv_ind]) != '\0' &&
				    !isdigit(c)) {
					int	r;
					wchar_t	wc;
					r = mbtowc(&wc, &argv[optnum][argv_ind],
						mbcurmax);
					if (r == -1) {
						(void) fprintf(stderr, gettext(
"pr: Illegal character in -n option\n"));
						exit(1);
					}
					Nsepc = wc;
					SQUEEZE_ARG(argv[optnum], argv_ind, r);
				}
				if (isdigit(argv[optnum][argv_ind])) {
					Numw = (int)strtol(&argv[optnum]
					    [argv_ind], (char **)NULL, 10);
					while (isdigit(argv[optnum][argv_ind]))
					    SQUEEZE_ARG(argv[optnum],
							argv_ind, 1);
				}
				argv_ind--;
				if (!Numw)
					Numw = NUMW;
				break;

			case 's':
				SQUEEZE_ARG(argv[optnum], argv_ind, 1);
				if ((Sepc = argv[optnum][argv_ind]) == '\0')
					Sepc = '\t';
				else {
					int	r;
					wchar_t	wc;
					r = mbtowc(&wc, &argv[optnum][argv_ind],
						mbcurmax);
					if (r == -1) {
						(void) fprintf(stderr, gettext(
"pr: Illegal character in -s option\n"));
						exit(1);
					}
					Sepc = wc;
					SQUEEZE_ARG(argv[optnum], argv_ind, r);
				}
				argv_ind--;
				break;

			default:
				break;
			}
		}
		if (argv[optnum][0] == '-' && argv[optnum][1] == '\0') {
			REMOVE_ARG(argc, &argv[optnum]);
			optnum--;
		}
	}

	/* Now get the other options */
	while ((c = getopt(argc, argv, "0123456789adfFh:l:mo:prtw:"))
	    != EOF) {
		switch (c) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			Ncols *= 10;
			Ncols += c - '0';
			break;

		case 'a':
			aflg++;
			if (!Multi)
				Multi = c;
			break;

		case 'd':
			Dblspace = 2;
			break;

		case 'f':
			++Formfeed;
			++Pause;
			break;

		case 'h':
			Head = optarg;
			break;

		case 'l':
			if (strlen(optarg) != strspn(optarg, "0123456789"))
				usage(1);
			Length = (int)strtol(optarg, (char **)NULL, 10);
			break;

		case 'm':
			mflg++;
			Multi = c;
			break;

		case 'o':
			if (strlen(optarg) != strspn(optarg, "0123456789"))
				usage(1);
			Offset = (int)strtol(optarg, (char **)NULL, 10);
			break;

		case 'p':
			++Pause;
			break;

		case 'r':
			Report = 0;
			break;

		case 't':
			Margin = 0;
			break;

		case 'w':
			if (strlen(optarg) != strspn(optarg, "0123456789"))
				usage(1);
			Linew = (int)strtol(optarg, (char **)NULL, 10);
			break;

		case 'F':
#ifdef	XPG4
			++Formfeed;
#else
			fold++;
#endif
			break;

		case '?':
			usage(2);
			break;

		default :
			usage(2);
		}
	}

	/* Count the file names and strip options */
	for (i = 1; i < argc; i++) {
		/* Check for explicit stdin */
		if ((argv[i][0] == '-') && (argv[i][1] == '\0')) {
			argv[eargc++][0] = '\0';
			REMOVE_ARG(argc, &argv[i]);
			if (i < optind)
				optind--;
		}
	}
	for (i = eargc; optind < argc; i++, optind++) {
		argv[i] = argv[optind];
		eargc++;
	}

	/* Check options */
	if (Ncols == 0)
		Ncols = 1;

	if (mflg && (Ncols > 1)) {
		(void) fprintf(stderr,
		    gettext("pr: only one of either -m or -column allowed\n"));
		usage(1);
	}

	if (Ncols == 1 && fold)
		Multi = 'm';

	if (Length <= 0)
		Length = LENGTH;

	if (Length <= Margin)
		Margin = 0;

	Plength = Length - Margin/2;

	if (Multi == 'm')
		Ncols = eargc;

	switch (Ncols) {
	case 0:
		Ncols = 1;
		break;

	case 1:
		break;

	default:
		if (Etabn == 0)	/* respect explicit tab specification */
			Etabn = DEFTAB;
		if (Itabn == 0)
			Itabn = DEFTAB;
	}

	if ((Fcol = (foldinf *) malloc(sizeof (foldinf) * Ncols)) == NULL) {
		(void) fprintf(stderr, gettext("pr: malloc failed\n"));
		exit(1);
	}
	for (i = 0; i < Ncols; i++)
		Fcol[i].fold = Fcol[i].skip = 0;

	if (Linew == 0)
		Linew = Ncols != 1 && Sepc == 0 ? LINEW : 512;

	if (Lnumb) {
		int numw;

		if (Nsepc == '\t') {
			if (Itabn == 0)
				numw = Numw + DEFTAB - (Numw % DEFTAB);
			else
				numw = Numw + Itabn - (Numw % Itabn);
		} else {
			numw = Numw + ((iswprint(Nsepc)) ? 1 : 0);
		}
		Linew -= (Multi == 'm') ? numw : numw * Ncols;
	}

	if ((Colw = (Linew - Ncols + 1)/Ncols) < 1)
		die("width too small");

	if (Ncols != 1 && Multi == 0) {
		/* Buflen should take the number of wide characters */
		/* Not the size for Buffer */
		Buflen = ((UNS) (Plength / Dblspace + 1)) *
		    2 * (Linew + 1);
		/* Should allocate Buflen * sizeof (wchar_t) */
		Buffer = (wchar_t *)getspace(Buflen * sizeof (wchar_t));
		Bufptr = Bufend = &Buffer[Buflen];
		Colpts = (COLP) getspace((UNS) ((Ncols + 1) *
		    sizeof (*Colpts)));
		Colpts[0].c_lno = 0;
	}

	/* is stdin not a tty? */
	if (Ttyout && (Pause || Formfeed) && !ttyname(fileno(stdin)))
		Ttyin = fopen("/dev/tty", "r");

	return (eargc);
}


static	int
print(char *name)
{
	static	int	notfirst = 0;
	char	*date = NULL;
	char	*head = NULL;
	int	c;

	if (Multi != 'm' && mustopen(name, &Files[0]) == NULL)
		return (0);
	if (Multi == 'm' && Nfiles == 0 && mustopen(name, &Files[0]) == NULL)
		die("cannot open stdin");
	if (Buffer)
		(void) ungetwc(Files->f_nextc, Files->f_f);
	if (Lnumb)
		Lnumb = 1;
	for (Page = 0; ; putpage()) {
		if (C == WEOF && !(fold && Buffer))
			break;
		if (Buffer)
			nexbuf();
		Inpos = 0;
		if (get(0) == WEOF)
			break;
		(void) fflush(stdout);
		if (++Page >= Fpage) {
			/* Pause if -p and not first page */
			if (Ttyout && Pause && !notfirst++) {
				PROMPT();	/* prompt with bell and pause */
				while ((c = getc(Ttyin)) != EOF && c != '\n')
					;
			}
			if (Margin == 0)
				continue;
			if (date == NULL)
				date = GETDATE();
			if (head == NULL)
				head = Head != NULL ? Head :
				    Nfiles < 2 ? Files->f_name : nulls;
			(void) printf("\n\n");
			Nspace = Offset;
			putspace();
			(void) printf(HEAD);
		}
	}
	C = '\0';
	return (1);
}


static	void
putpage()
{
	int	colno;

	if (fold) {
		foldpage();
		return;
	}
	for (Line = Margin / 2; ; (void) get(0)) {
		for (Nspace = Offset, colno = 0, Outpos = 0; C != '\f'; ) {
			if (Lnumb && (C != WEOF) &&
			    (((colno == 0) && (Multi == 'm')) ||
			    (Multi != 'm'))) {
				if (Page >= Fpage) {
					putspace();
					(void) printf("%*ld%wc", Numw, Buffer ?
					    Colpts[colno].c_lno++ :
					    Lnumb, Nsepc);

					/* Move Outpos for number field */
					Outpos += Numw;
					if (Nsepc == '\t')
						Outpos +=
						    DEFTAB - (Outpos % DEFTAB);
					else
						Outpos++;
				}
				++Lnumb;
			}
			for (Lcolpos = 0, Pcolpos = 0;
			    C != '\n' && C != '\f' && C != WEOF;
			    (void) get(colno))
				(void) put(C);

			if ((C == WEOF) || (++colno == Ncols) ||
			    ((C == '\n') && (get(colno) == WEOF)))
				break;

			if (Sepc)
				(void) put(Sepc);
			else if ((Nspace += Colw - Lcolpos + 1) < 1)
				Nspace = 1;
		}

		if (C == WEOF) {
			if (Margin != 0)
				break;
			if (colno != 0)
				(void) put('\n');
			return;
		}
		if (C == '\f')
			break;
		(void) put('\n');
		if (Dblspace == 2 && Line < Plength)
			(void) put('\n');
		if (Line >= Plength)
			break;
	}
	if (Formfeed)
		(void) put('\f');
	else
		while (Line < Length)
			(void) put('\n');
}


static	void
foldpage()
{
	int	colno;
	int	keep;
	int	i;
	int	pLcolpos;
	static	int	sl;

	for (Line = Margin / 2; ; (void) get(0)) {
		for (Nspace = Offset, colno = 0, Outpos = 0; C != '\f'; ) {
			if (Lnumb && Multi == 'm' && foldcol) {
				if (!Fcol[colno].skip) {
					unget(colno);
					putspace();
					if (!colno) {
						for (i = 0; i <= Numw; i++)
							(void) printf(" ");
						(void) printf("%wc", Nsepc);
					}
					for (i = 0; i <= Colw; i++)
						(void) printf(" ");
					(void) put(Sepc);
					if (++colno == Ncols)
						break;
					(void) get(colno);
					continue;
				} else if (!colno)
					Lnumb = sl;
			}

			if (Lnumb && (C != WEOF) &&
			    ((colno == 0 && Multi == 'm') || (Multi != 'm'))) {
				if (Page >= Fpage) {
					putspace();
					if ((foldcol &&
					    Fcol[colno].skip && Multi != 'a') ||
					    (Fcol[0].fold && Multi == 'a') ||
					    (Buffer && Colpts[colno].c_skip)) {
						for (i = 0; i < Numw; i++)
							(void) printf(" ");
						(void) printf("%wc", Nsepc);
						if (Buffer) {
							Colpts[colno].c_lno++;
							Colpts[colno].c_skip =
							    0;
						}
					}
					else
					(void) printf("%*ld%wc", Numw, Buffer ?
					    Colpts[colno].c_lno++ :
					    Lnumb, Nsepc);
				}
				sl = Lnumb++;
			}
			pLcolpos = 0;
			for (Lcolpos = 0, Pcolpos = 0;
			    C != '\n' && C != '\f' && C != WEOF;
			    (void) get(colno)) {
				if (put(C)) {
					unget(colno);
					Fcol[(Multi == 'a') ? 0 : colno].fold
					    = 1;
					break;
				} else if (Multi == 'a') {
					Fcol[0].fold = 0;
				}
				pLcolpos = Lcolpos;
			}
			if (Buffer) {
				alleof = 1;
				for (i = 0; i < Ncols; i++)
					if (!Fcol[i].eof)
						alleof = 0;
				if (alleof || ++colno == Ncols)
					break;
			} else if (C == EOF || ++colno == Ncols)
				break;
			keep = C;
			(void) get(colno);
			if (keep == '\n' && C == WEOF)
				break;
			if (Sepc)
				(void) put(Sepc);
			else if ((Nspace += Colw - pLcolpos + 1) < 1)
				Nspace = 1;
		}
		foldcol = 0;
		if (Lnumb && Multi != 'a') {
			for (i = 0; i < Ncols; i++) {
				Fcol[i].skip = Fcol[i].fold;
				foldcol +=  Fcol[i].fold;
				Fcol[i].fold = 0;
			}
		}
		if (C == WEOF) {
			if (Margin != 0)
				break;
			if (colno != 0)
				(void) put('\n');
			return;
		}
		if (C == '\f')
			break;
		(void) put('\n');
		(void) fflush(stdout);
		if (Dblspace == 2 && Line < Plength)
			(void) put('\n');
		if (Line >= Plength)
			break;
	}
	if (Formfeed)
		(void) put('\f');
	else while (Line < Length)
		(void) put('\n');
}


static	void
nexbuf()
{
	wchar_t	*s = Buffer;
	COLP	p = Colpts;
	int	j;
	int	c;
	int	bline = 0;
	wchar_t	wc;

	if (fold) {
		foldbuf();
		return;
	}
	for (; ; ) {
		p->c_ptr0 = p->c_ptr = s;
		if (p == &Colpts[Ncols])
			return;
		(p++)->c_lno = Lnumb + bline;
		for (j = (Length - Margin)/Dblspace; --j >= 0; ++bline) {
			for (Inpos = 0; ; ) {
				errno = 0;
				wc = _fgetwc_pr(Files->f_f, &c);
				if (wc == WEOF) {
					/* If there is an illegal character, */
					/* handle it as a byte sequence. */
					if (errno == EILSEQ) {
						if (Inpos < Colw - 1) {
							*s = c;
							if (++s >= Bufend)
die("page-buffer overflow");
						}
						Inpos++;
						Error++;
						return;
					} else {
						/* Real EOF */
for (*s = WEOF; p <= &Colpts[Ncols]; ++p)
	p->c_ptr0 = p->c_ptr = s;
						balance(bline);
						return;
					}
				}

				if (isascii(wc)) {
					if (isprint(wc))
						Inpos++;
				} else if (iswprint(wc)) {
					Inpos += wcwidth(wc);
				}

				if (Inpos <= Colw || wc == '\n') {
					*s = wc;
					if (++s >= Bufend)
						die("page-buffer overflow");
				}
				if (wc == '\n')
					break;
				switch (wc) {
				case '\b':
					if (Inpos == 0)
						--s;

					/*FALLTHROUGH*/

				case ESC:
					if (Inpos > 0)
						--Inpos;
				}
			}
		}
	}
}


static	void
foldbuf()
{
	int	num;
	int	i;
	int	colno = 0;
	int	size = Buflen;
	wchar_t	*s;
	wchar_t	*d;
	COLP	p = Colpts;

	for (i = 0; i < Ncols; i++)
		Fcol[i].eof = 0;
	d = Buffer;
	if (Bufptr != Bufend) {
		s = Bufptr;
		while (s < Bufend)
			*d++ = *s++;
		size -= (Bufend - Bufptr);
	}
	Bufptr = Buffer;
	p->c_ptr0 = p->c_ptr = Buffer;
	if (p->c_lno == 0) {
		p->c_lno = Lnumb;
		p->c_skip = 0;
	} else {
		p->c_lno = Colpts[Ncols-1].c_lno;
		p->c_skip = Colpts[Ncols].c_skip;
		if (p->c_skip)
			p->c_lno--;
	}
	if ((num = freadw(d, size, Files->f_f)) != size) {
		for (*(d+num) = WEOF; (++p) <= &Colpts[Ncols]; ) {
			p->c_ptr0 = p->c_ptr = (d+num);
		}
		balance(0);
		return;
	}
	i = (Length - Margin) / Dblspace;
	do {
		(void) readbuf(&Bufptr, i, p++);
	} while (++colno < Ncols);
}


static	void
balance(int bline)	/* line balancing for last page */
{
	wchar_t	*s = Buffer;
	COLP	p = Colpts;
	int	colno = 0;
	int	j;
	int	c;
	int	l;
	int	lines;

	if (!fold) {
		c = bline % Ncols;
		l = (bline + Ncols - 1)/Ncols;
		bline = 0;
		do {
			for (j = 0; j < l; ++j)
				while (*s++ != '\n')
					;
			(++p)->c_lno = Lnumb + (bline += l);
			p->c_ptr0 = p->c_ptr = s;
			if (++colno == c)
				--l;
		} while (colno < Ncols - 1);
	} else {
		lines = readbuf(&s, 0, 0);
		l = (lines + Ncols - 1)/Ncols;
		if (l > ((Length - Margin) / Dblspace)) {
			l = (Length - Margin) / Dblspace;
			c = Ncols;
		} else {
			c = lines % Ncols;
		}
		s = Buffer;
		do {
			(void) readbuf(&s, l, p++);
			if (++colno == c)
				--l;
		} while (colno < Ncols);
		Bufptr = s;
	}
}


static	int
readbuf(wchar_t **s, int lincol, COLP p)
{
	int	lines = 0;
	int	chars = 0;
	int	width;
	int	nls = 0;
	int	move;
	int	skip = 0;
	int	decr = 0;

	width = (Ncols == 1) ? Linew : Colw;
	while (**s != WEOF) {
		switch (**s) {
			case '\n':
				lines++; nls++; chars = 0; skip = 0;
				break;

			case '\b':
			case ESC:
				if (chars) chars--;
				break;

			case '\t':
				move = Itabn - ((chars + Itabn) % Itabn);
				move = (move < width-chars) ? move :
				    width-chars;
				chars += move;
				/* FALLTHROUGH */

			default:
				if (isascii(**s)) {
					if (isprint(**s))
						chars++;
				} else if (iswprint(**s)) {
					chars += wcwidth(**s);
				}
		}
		if (chars > width) {
			lines++;
			skip++;
			decr++;
			chars = 0;
		}
		if (lincol && lines == lincol) {
			(p+1)->c_lno = p->c_lno + nls;
			(++p)->c_skip = skip;
			if (**s == '\n') (*s)++;
			p->c_ptr0 = p->c_ptr = (wchar_t *)*s;
			return (0);
		}
		if (decr)
			decr = 0;
		else
			(*s)++;
	}
	return (lines);
}


static	wint_t
get(int colno)
{
	static	int	peekc = 0;
	COLP	p;
	FILS	*q;
	int	c;
	wchar_t		wc, w;

	if (peekc) {
		peekc = 0;
		wc = Etabc;
	} else if (Buffer) {
		p = &Colpts[colno];
		if (p->c_ptr >= (p+1)->c_ptr0)
			wc = WEOF;
		else if ((wc = *p->c_ptr) != WEOF)
			++p->c_ptr;
		if (fold && wc == WEOF)
			Fcol[colno].eof = 1;
	} else if ((wc =
		(q = &Files[Multi == 'a' ? 0 : colno])->f_nextc) == WEOF) {
		for (q = &Files[Nfiles]; --q >= Files && q->f_nextc == WEOF; )
			;
		if (q >= Files)
			wc = '\n';
	} else {
		errno = 0;
		w = _fgetwc_pr(q->f_f, &c);
		if (w == WEOF && errno == EILSEQ) {
			q->f_nextc = (wchar_t)c;
		} else {
			q->f_nextc = w;
		}
	}

	if (Etabn != 0 && wc == Etabc) {
		++Inpos;
		peekc = ETABS;
		wc = ' ';
		return (C = wc);
	}

	if (wc == WEOF)
		return (C = wc);

	if (isascii(wc)) {
		if (isprint(wc)) {
			Inpos++;
			return (C = wc);
		}
	} else if (iswprint(wc)) {
		Inpos += wcwidth(wc);
		return (C = wc);
	}

	switch (wc) {
	case '\b':
	case ESC:
		if (Inpos > 0)
			--Inpos;
		break;
	case '\f':
		if (Ncols == 1)
			break;
		wc = '\n';
		/* FALLTHROUGH */
	case '\n':
	case '\r':
		Inpos = 0;
		break;
	}
	return (C = wc);
}


static	int
put(wchar_t wc)
{
	int	move = 0;
	int	width = Colw;
	int	sp = Lcolpos;

	if (fold && Ncols == 1)
		width = Linew;

	switch (wc) {
	case ' ':
		/* If column not full or this is separator char */
		if ((!fold && Ncols < 2) || (Lcolpos < width) ||
		    ((Sepc == wc) && (Lcolpos == width))) {
			++Nspace;
			++Lcolpos;
		}
		if (fold && sp == Lcolpos)
			if (Lcolpos >= width)
				return (1);

		return (0);

	case '\t':
		if (Itabn == 0)
			break;

		/* If column not full or this is separator char */
		if ((Lcolpos < width) ||
		    ((Sepc == wc) && (Lcolpos == width))) {
			move = Itabn - ((Lcolpos + Itabn) % Itabn);
			move = (move < width-Lcolpos) ? move : width-Lcolpos;
			Nspace += move;
			Lcolpos += move;
		}
		if (fold && sp == Lcolpos)
			if (Lcolpos >= width)
				return (1);
		return (0);

	case '\b':
		if (Lcolpos == 0)
			return (0);
		if (Nspace > 0) {
			--Nspace;
			--Lcolpos;
			return (0);
		}
		if (Lcolpos > Pcolpos) {
			--Lcolpos;
			return (0);
		}

		/*FALLTHROUGH*/

	case ESC:
		move = -1;
		break;

	case '\n':
		++Line;

		/*FALLTHROUGH*/

	case '\r':
	case '\f':
		Pcolpos = 0;
		Lcolpos = 0;
		Nspace = 0;
		Outpos = 0;
		/* FALLTHROUGH */
	default:
		if (isascii(wc)) {
			if (isprint(wc))
				move = 1;
			else
				move = 0;
		} else if (iswprint(wc)) {
			move = wcwidth(wc);
		} else {
			move = 0;
		}
		break;
	}
	if (Page < Fpage)
		return (0);
	if (Lcolpos > 0 || move > 0)
		Lcolpos += move;

	putspace();

	/* If column not full or this is separator char */
	if ((!fold && Ncols < 2) || (Lcolpos <= width) ||
	    ((Sepc == wc) && (Lcolpos > width))) {
		(void) fputwc(wc, stdout);
		Outpos += move;
		Pcolpos = Lcolpos;
	}

	if (fold && Lcolpos > width)
		return (1);

	return (0);
}


static	void
putspace(void)
{
	int nc = 0;

	for (; Nspace > 0; Outpos += nc, Nspace -= nc) {
#ifdef XPG4
		/* XPG4:  -i:  replace multiple SPACE chars with tab chars */
		if ((Nspace >= 2 && Itabn > 0 &&
			Nspace >= (nc = Itabn - Outpos % Itabn)) && !fold) {
#else
		/* Solaris:  -i:  replace white space with tab chars */
		if ((Itabn > 0 && Nspace >= (nc = Itabn - Outpos % Itabn)) &&
			!fold) {
#endif
			(void) fputwc(Itabc, stdout);
		} else {
			nc = 1;
			(void) putchar(' ');
		}
	}
}


static	void
unget(int colno)
{
	if (Buffer) {
		if (*(Colpts[colno].c_ptr-1) != '\t')
			--(Colpts[colno].c_ptr);
		if (Colpts[colno].c_lno)
			Colpts[colno].c_lno--;
	} else {
		if ((Multi == 'm' && colno == 0) || Multi != 'm')
			if (Lnumb && !foldcol)
				Lnumb--;
		colno = (Multi == 'a') ? 0 : colno;
		(void) ungetwc(Files[colno].f_nextc, Files[colno].f_f);
		Files[colno].f_nextc = C;
	}
}


/*
 * Defer message about failure to open file to prevent messing up
 * alignment of page with tear perforations or form markers.
 * Treat empty file as special case and report as diagnostic.
 */

static	FILE *
mustopen(char *s, FILS *f)
{
	char	*empty_file_msg = gettext("%s -- empty file");
	int	c;

	if (*s == '\0') {
		f->f_name = STDINNAME();
		f->f_f = stdin;
	} else if ((f->f_f = fopen(f->f_name = s, "r")) == NULL) {
		s = ffiler(f->f_name);
		s = strcpy((char *)getspace((UNS) strlen(s) + 1), s);
	}
	if (f->f_f != NULL) {
		errno = 0;
		f->f_nextc = _fgetwc_pr(f->f_f, &c);
		if (f->f_nextc != WEOF) {
			return (f->f_f);
		} else {	/* WEOF */
			if (errno == EILSEQ) {
				f->f_nextc = (wchar_t)c;
				return (f->f_f);
			}
			if (Multi == 'm')
				return (f->f_f);
		}
		(void) sprintf(s = (char *)getspace((UNS) strlen(f->f_name)
		    + 1 + (UNS) strlen(empty_file_msg)),
		    empty_file_msg, f->f_name);
		(void) fclose(f->f_f);
	}
	Error = 1;
	if (Report)
		if (Ttyout) {	/* accumulate error reports */
			Lasterr = Lasterr->e_nextp =
			    (ERR *) getspace((UNS) sizeof (ERR));
			Lasterr->e_nextp = NULL;
			Lasterr->e_mess = s;
		} else {	/* ok to print error report now */
			cerror(s);
			(void) putc('\n', stderr);
		}
	return ((FILE *)NULL);
}


static	ANY *
getspace(UNS n)
{
	ANY *t;

	if ((t = (ANY *) malloc(n)) == NULL)
		die("out of space");
	return (t);
}


static	void
die(char *s)
{
	++Error;
	errprint();
	cerror(s);
	(void) putc('\n', stderr);
	exit(1);

	/*NOTREACHED*/
}


static	void
errprint()	/* print accumulated error reports */
{
	(void) fflush(stdout);
	for (; Err != NULL; Err = Err->e_nextp) {
		cerror(Err->e_mess);
		(void) putc('\n', stderr);
	}
	done();
}


static	void
fixtty()
{
	struct stat sbuf;

	setbuf(stdout, obuf);
	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
		(void) signal(SIGINT, onintr);
	if (Ttyout = ttyname(fileno(stdout))) {	/* is stdout a tty? */
		(void) stat(Ttyout, &sbuf);
		Mode = sbuf.st_mode;		/* save permissions */
		(void) chmod(Ttyout, (S_IREAD|S_IWRITE));
	}
}


static	void
onintr()
{
	++Error;
	errprint();
	_exit(1);
}


static	char *
GETDATE()	/* return date file was last modified */
{
	static	char	*now = NULL;
	static	struct	stat	sbuf;
	static	struct	stat	nbuf;

	if (Nfiles > 1 || Files->f_name == nulls) {
		if (now == NULL) {
			(void) time(&nbuf.st_mtime);
			(void) cftime(time_buf,
				dcgettext(NULL, FORMAT, LC_TIME),
			    &nbuf.st_mtime);
			now = time_buf;
		}
		return (now);
	} else {
		(void) stat(Files->f_name, &sbuf);
		(void) cftime(time_buf, dcgettext(NULL, FORMAT, LC_TIME),
			&sbuf.st_mtime);
		return (time_buf);
	}
}


static	char *
ffiler(char *s)
{
	static char buf[100];

	(void) sprintf(buf, gettext("can't open %s"), s);
	return (buf);
}


static	void
usage(int rc)
{
	(void) fprintf(stderr, gettext(
"usage: pr [-# [-w #] [-a]] [-e[c][#]] [-i[c][#]] [-drtfp] [-n[c][#]]  \\\n"
"          [-o #] [-l #] [-s[char]] [-h header] [-F] [+#] [file ...]\n\n"
"       pr [-m [-w #]] [-e[c][#]] [-i[c][#]] [-drtfp] [-n[c][#]] [-0 #] \\\n"
"          [-l #] [-s[char]] [-h header] [-F] [+#] file1 file2 ...\n"
));
	exit(rc);
}

static wint_t
_fgetwc_pr(FILE *f, int *ic)
{
	int	i;
	int	len;
	char	mbuf[MB_LEN_MAX];
	int	c;
	wchar_t	wc;

	c = getc(f);

	if (c == EOF)
		return (WEOF);
	if (mbcurmax == 1 || isascii(c)) {
		return ((wint_t)c);
	}
	mbuf[0] = (char)c;
	for (i = 1; i < mbcurmax; i++) {
		c = getc(f);
		if (c == EOF) {
			break;
		} else {
			mbuf[i] = (char)c;
		}
	}
	mbuf[i] = 0;

	len = mbtowc(&wc, mbuf, i);
	if (len == -1) {
		/* Illegal character */
		/* Set the first byte to *ic */
		*ic = mbuf[0];
		/* Push back remaining characters */
		for (i--; i > 0; i--) {
			(void) ungetc(mbuf[i], f);
		}
		errno = EILSEQ;
		return (WEOF);
	} else {
		/* Push back over-read characters */
		for (i--; i >= len; i--) {
			(void) ungetc(mbuf[i], f);
		}
		return ((wint_t)wc);
	}
}

static size_t
freadw(wchar_t *ptr, size_t nitems, FILE *f)
{
	size_t	i;
	size_t	ret;
	int	c;
	wchar_t	*p;
	wint_t	wc;

	if (feof(f)) {
		return (0);
	}

	p = ptr;
	ret = 0;
	for (i = 0; i < nitems; i++) {
		errno = 0;
		wc = _fgetwc_pr(f, &c);
		if (wc == WEOF) {
			if (errno == EILSEQ) {
				*p++ = (wchar_t)c;
				ret++;
			} else {
				return (ret);
			}
		} else {
			*p++ = (wchar_t)wc;
			ret++;
		}
	}
	return (ret);
}