/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (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

 */

/*

 * Use is subject to license terms.

 */

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

/*	  All Rights Reserved  	*/

#include <signal.h>

#include <setjmp.h>

#include <sys/types.h>

#include <sys/dirent.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <ctype.h>

#include <stdio.h>

#include <wchar.h>

#include <curses.h>

#include <term.h>

#include <errno.h>

#include <stdlib.h>

#include <regexpr.h>

#include <limits.h>

#include <locale.h>

#include <wctype.h> /* iswprint() */

#include <string.h>

#include <unistd.h>

#include <wait.h>

#include <libw.h>

#include <regexpr.h>

/*

 *	pg -- paginator for crt terminals

 *

 *	Includes the ability to display pages that have

 *	already passed by. Also gives the user the ability

 *	to search forward and backwards for regular expressions.

 *	This works for piped input by copying to a temporary file,

 *	and resolving backreferences from there.

 *

 *	Note:	The reason that there are so many commands to do

 *		the same types of things is to try to accommodate

 *		users of other paginators.

 */

#define	LINSIZ	1024

#define	QUIT	'\034'

#define	BOF	(EOF - 1)	/* Begining of File */

#define	STOP    (EOF - 2)

#define	PROMPTSIZE	256

/*

 * Function definitions

 */

static	void	lineset(int);

static	char	*setprompt();

static	int	set_state(int *, wchar_t, char *);

static	void	help();

static	void	copy_file(FILE *, FILE *);

static	void	re_error(int);

static	void	save_input(FILE *);

static	void	save_pipe();

static	void	newdol(FILE *);

static	void	erase_line(int);

static	void	kill_line();

static	void	doclear();

static	void	sopr(char *, int);

static	void	prompt(char *);

static	void	error(char *);

static	void	terminit();

static	void	compact();

static	off_t	getline(FILE *);

static	int	mrdchar();

static	off_t	find(int, off_t);

static	int	search(char *, off_t);

static	FILE	*checkf(char *);

static	int	skipf(int);

static	int	readch();

static	int	ttyin();

static	int	number();

static	int	command(char *);

static	int	screen(char *);

static	int	fgetputc();

static 	char	*pg_strchr();

struct line {			/* how line addresses are stored */

	off_t	l_addr;		/* file offset */

	off_t	l_no;		/* line number in file */

};

typedef	struct line	LINE;

static	LINE	*zero = NULL,	/* first line */

		*dot,		/* current line */

		*dol,		/* last line */

		*contig;	/* where contiguous (non-aged) lines start */

static	long	nlall;		/* room for how many LINEs in memory */

static	FILE	*in_file,	/* current input stream */

		*tmp_fin,	/* pipe temporary file in */

		*tmp_fou;	/* pipe temporary file out */

static	char	tmp_name[] = "/tmp/pgXXXXXX";

static	short	sign;		/* sign of command input */

static	int	fnum,		/* which file argument we're in */

		pipe_in,	/* set when stdin is a pipe */

		out_is_tty;	/* set if stdout is a tty */

static	pid_t	my_pgid;

static	void	on_brk(),

		end_it();

static	short	brk_hit;	/* interrupt handling is pending flag */

static	int	window = 0;	/* window size in lines */

static	short	eof_pause = 1;	/* pause w/ prompt at end of files */

static	short	rmode = 0;	/* deny shell escape in restricted mode */

static	short	soflag = 0;	/* output all messages in standout mode */

static	short	promptlen;	/* length of the current prompt */

static	short	firstf = 1;	/* set before first file has been processed */

static	short	inwait,		/* set while waiting for user input */

		errors;		/* set if error message has been printed. */

				/* if so, need to erase it and prompt */

static	char	**fnames;

static	short	status = 0;	/* set > 0 if error detected */

static	short	fflag = 0;	/* set if the f option is used */

static	short	nflag = 0;	/* set for "no newline" input option */

static	short	clropt = 0;	/* set if the clear option is used */

static	int	initopt = 0;	/* set if the line option is used */

static	int	srchopt = 0;	/* set if the search option is used */

static	int	initline;

static	char	initbuf[BUFSIZ];

static	wchar_t	leave_search = L't';

				/* where on the page to leave a found string */

static	short	nfiles;

static	char	*shell;

static	char	*promptstr = ":";

static  off_t	nchars;			/* return from getline in find() */

static	jmp_buf	restore;

static	char	Line[LINSIZ+2];

static	int	catch_susp;

static	void	onsusp();

struct screen_stat {

	off_t	first_line;

	off_t	last_line;

	short	is_eof;

	};

static	struct screen_stat old_ss = { 0, 0, 0 };

static	struct screen_stat new_ss;

static	struct termio otty;	/* to save old terminal settings */

static	short	termflg = 0;	/* set once terminal is initialized */

static	short	eoflag;		/* set whenever at end of current file */

static	short	doliseof;	/* set when last line of file is known */

static	off_t	eofl_no;	/* what the last line of the file is */

static	void	usage(void);

static FILE	*pg_stdin;

int

main(int argc, char **argv)

{

	char	*s;

	char	*p;

	int		prnames = 0;

	int		opt;

	int		i;

	(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);

	/* check for non-standard "-#" option */

	for (i = 1; i < argc; i++) {

		if (strcmp(argv[i], "--") == 0)

			break;

		if ((argv[i][0] == '-') && isdigit(argv[i][1])) {

			if (strlen(&argv[i][1]) !=

			    strspn(&argv[i][1], "0123456789")) {

				(void) fprintf(stderr, gettext(

				    "pg: Badly formed number\n"));

				usage();

			}

			window = (int)strtol(&argv[i][1], (char **)NULL, 10);

			while (i < argc) {

				argv[i] = argv[i + 1];

				i++;

			}

			i--;

			argc--;

		}

	}

	/* check for non-standard + option */

	for (i = 1; i < argc; i++) {

		if (strcmp(argv[i], "--") == 0)

		break;

		if (argv[i][0] == '+') {

			if (argv[i][1] == '/') {

				srchopt++;

				initopt = 0;

				for (s = &argv[i][2], p = initbuf; *s != '\0'; )

					if (p < initbuf + sizeof (initbuf))

						*p++ = *s++;

					else {

						(void) fprintf(stderr, gettext(

						    "pg: pattern too long\n"));

						return (1);

					}

				*p = '\0';

			} else {

				initopt++;

				srchopt = 0;

				s = &argv[i][2];

				for (; isdigit(*s); s++)

					initline = initline*10 + *s -'0';

				if (*s != '\0')

					usage();

			}

			while (i < argc) {

				argv[i] = argv[i + 1];

				i++;

			}

			i--;

			argc--;

		}

	}

	while ((opt = getopt(argc, argv, "cefnrsp:")) != EOF) {

		switch (opt) {

		case 'c':

			clropt = 1;

			break;

		case 'e':

			eof_pause = 0;

			break;

		case 'f':

			fflag = 1;

			break;

		case 'n':

			nflag = 1;

			break;

		case 'r':

			rmode = 1;	/* restricted mode */

			break;

		case 's':

			soflag = 1;	/* standout mode */

			break;

		case 'p':

			promptstr = setprompt(optarg);

			break;

		default:

			usage();

		}

	}

	nfiles = argc - optind;

	fnames = &argv[optind];

	(void) signal(SIGQUIT, end_it);

	(void) signal(SIGINT, end_it);

	out_is_tty = isatty(1);

	my_pgid = getpgrp();

	if (out_is_tty) {

		terminit();

		(void) signal(SIGQUIT, on_brk);

		(void) signal(SIGINT, on_brk);

		if (signal(SIGTSTP, SIG_IGN) == SIG_DFL) {

			(void) signal(SIGTSTP, onsusp);

			catch_susp++;

		}

	}

	if (window == 0)

		window = lines - 1;

	if (window <= 1)

		window = 2;

	if (initline <= 0)

		initline = 1;

	if (nfiles > 1)

		prnames++;

	if (nfiles == 0) {

		fnames[0] = "-";

		nfiles++;

	}

	while (fnum < nfiles) {

		if (strcmp(fnames[fnum], "") == 0)

			fnames[fnum] = "-";

		if ((in_file = checkf(fnames[fnum])) == NULL) {

			status = 2;

			fnum++;

		} else {

			status = 0;

			if (out_is_tty)

				fnum += screen(fnames[fnum]);

			else {

				if (prnames) {

					(void) fputs("::::::::::::::\n",

					    stdout);

					(void) fputs(fnames[fnum], stdout);

					(void) fputs("\n::::::::::::::\n",

					    stdout);

				}

				copy_file(in_file, stdout);

				fnum++;

			}

			(void) fflush(stdout);

			if (pipe_in)

				save_pipe();

			else

			if (in_file != tmp_fin)

				(void) fclose(in_file);

		}

	}

	end_it();

	/*NOTREACHED*/

	return (0);

}

static	char *

setprompt(s)

char *s;

{

	int i = 0;

	int pct_d = 0;

	static char pstr[PROMPTSIZE];

	while (i < PROMPTSIZE - 2)

		switch (pstr[i++] = *s++) {

		case '\0':

			return (pstr);

		case '%':

			if (*s == 'd' && !pct_d) {

				pct_d++;

			} else if (*s != '%')

				pstr[i++] = '%';

			if ((pstr[i++] = *s++) == '\0')

				return (pstr);

			break;

		default:

			break;

		}

	(void) fprintf(stderr, gettext("pg: prompt too long\n"));

	exit(1);

	/*NOTREACHED*/

}

/*

 * Print out the contents of the file f, one screenful at a time.

 */

static int

screen(file_name)

char *file_name;

{

	int cmd_ret = 0;

	off_t start;

	short hadchance = 0;

	old_ss.is_eof = 0;

	old_ss.first_line = 0;

	old_ss.last_line = 0;

	new_ss = old_ss;

	if (!firstf)

		cmd_ret = command(file_name);

	else {

		firstf = 0;

		if (initopt) {

			initopt = 0;

			new_ss.first_line = initline;

			new_ss.last_line = initline + (off_t)window - 1;

		} else if (srchopt) {

			srchopt = 0;

			if (!search(initbuf, (off_t)1))

				cmd_ret = command(file_name);

		} else {

			new_ss.first_line = 1;

			new_ss.last_line = (off_t)window;

		}

	}

	for (;;) {

		if (cmd_ret)

			return (cmd_ret);

		if (hadchance && new_ss.last_line >= eofl_no)

			return (1);

		hadchance = 0;

		if (new_ss.last_line < (off_t)window)

			new_ss.last_line = (off_t)window;

		if (find(0, new_ss.last_line + 1) != EOF)

			new_ss.is_eof = 0;

		else {

			new_ss.is_eof = 1;

			new_ss.last_line = eofl_no - 1;

			new_ss.first_line = new_ss.last_line -

			    (off_t)window + 1;

		}

		if (new_ss.first_line < 1)

			new_ss.first_line = 1;

		if (clropt) {

			doclear();

			start = new_ss.first_line;

		} else {

			if (new_ss.first_line == old_ss.last_line)

				start = new_ss.first_line + 1;

			else

			if (new_ss.first_line > old_ss.last_line)

				start = new_ss.first_line;

			else

			if (old_ss.first_line < new_ss.first_line)

				start = old_ss.last_line + 1;

			else

				start = new_ss.first_line;

			if (start < old_ss.first_line)

				sopr(gettext("...skipping backward\n"), 0);

			else

			if (start > old_ss.last_line + 1)

				sopr(gettext("...skipping forward\n"), 0);

		}

		for (; start <= new_ss.last_line; start++) {

			(void) find(0, start);

			(void) fputs(Line, stdout);

			if (brk_hit) {

				new_ss.last_line = find(1, 0);

				new_ss.is_eof = 0;

				break;

			}

		}

		brk_hit = 0;

		(void) fflush(stdout);

		if (new_ss.is_eof) {

			if (!eof_pause || eofl_no == 1)

				return (1);

			hadchance++;

			error("(EOF)");

		}

		old_ss = new_ss;

		cmd_ret = command((char *)NULL);

	}

}

static	char	cmdbuf[LINSIZ], *cmdptr;

#define	BEEP()		if (bell) { (void) putp(bell); (void) fflush(stdout); }

#define	BLANKS(p)	while (*p == ' ' || *p == '\t') p++

#define	CHECKEND()	BLANKS(cmdptr); if (*cmdptr) { BEEP(); break; }

/*

 * Read a command and do it. A command consists of an optional integer

 * argument followed by the command character.  Return the number of files

 * to skip, 0 if we're still talking about the same file.

 */

static int

command(filename)

char *filename;

{

	off_t nlines;

	FILE *sf;

	char *cmdend;

	pid_t id;

	int skip;

	int	len;

	wchar_t	wc;

	wchar_t	wc_e;

	wchar_t	wc_e1;

	char	*p;

	for (;;) {

		/*

		 * Wait for output to drain before going on.

		 * This is done so that the user will not hit

		 * break and quit before he has seen the prompt.

		 */

		(void) ioctl(1, TCSBRK, 1);

		if (setjmp(restore) > 0)

			end_it();

		inwait = 1;