/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1988 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.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*LINTLIBRARY*/

#include	<stdio.h>
#include	<sys/types.h>
#include	<fcntl.h>
#include	<stdlib.h>
#include	<string.h>
#include	<unistd.h>
#include	<errno.h>
#include	"curses_inc.h"

#define	TERMPATH	"/usr/share/lib/terminfo/"
#define	TERMPATHLEN	512

extern	bool	_use_env;	/* in curses.c */

chtype	bit_attributes[NUM_ATTRIBUTES] = {
	    A_STANDOUT,
	    A_UNDERLINE,
	    A_ALTCHARSET,
	    A_REVERSE,
	    A_BLINK,
	    A_DIM,
	    A_BOLD,
	    A_INVIS,
	    A_PROTECT
	};

char	*Def_term = "unknown",	/* default terminal type */
	term_parm_err[32], ttytype[BUFSIZ], _frst_tblstr[1400];

TERMINAL		_first_term, *cur_term = &_first_term;
struct	_bool_struct	_frst_bools, *cur_bools = &_frst_bools;
struct	_num_struct	_frst_nums, *cur_nums = &_frst_nums;
struct	_str_struct	_frst_strs, *cur_strs = &_frst_strs;

/* _called_before is used/cleared by delterm.c and restart.c */
char	_called_before = 0;
short	term_errno = -1;

#ifdef SYSV
int	prog_istermios = -1;
int	shell_istermios = -1;
#endif

#ifdef	DUMPTI
extern	char	*boolfnames[], *boolnames[], *boolcodes[],
		*numfnames[], *numnames[], *numcodes[],
		*strfnames[], *strnames[], *strcodes[];

main(int argc, char **argv)	/* FOR DEBUG ONLY */
{
	if (argc > 1)
		setupterm(argv[1], 1, (int *)0);
	else
		setupterm((char *)0, 1, (int *)0);
	return (0);
}

_Pr(int ch)	/* FOR DEBUG ONLY */
{
	if (ch >= 0200) {
		printf("M-");
		ch -= 0200;
	}
	if ((ch < ' ') || (ch == 0177))
		printf("^%c", ch ^ 0100);
	else
		printf("%c", ch);
}

_Sprint(int n, char *string)	/* FOR DEBUG ONLY */
{
	int	ch;

	if (n == -1) {
		printf(".\n");
		return;
	}
	printf(", string = '");
	while (ch = *string++)
		_Pr(ch&0377);

	printf("'.\n");
}

_Mprint(int n, char *memory)	/* FOR DEBUG ONLY */
{
	unsigned	char	ch;

	while (ch = *memory++, n-- > 0)
		_Pr(ch&0377);
}

#define	_Vr2getshi()	_Vr2getsh(ip-2)

#if	vax || pdp11
#define	_Vr2getsh(ip)	(* (short *)(ip))
#endif	/* vax || pdp11 */

#ifndef	_Vr2getsh
/*
 * Here is a more portable version, which does not assume byte ordering
 * in shorts, sign extension, etc.
 */
_Vr2getsh(char *p)
{
	int	rv;

	if (*p == (char)0377)
		return (-1);
	rv = (unsigned char) *p++;
	rv += (unsigned char) *p * 256;
	return (rv);
}
#endif	/* _Vr2getsh */

#endif	/* DUMPTI */

#define	_Getshi()	_Getsh(ip); ip += 2

/*
 * "function" to get a short from a pointer.  The short is in a standard
 * format: two bytes, the first is the low order byte, the second is
 * the high order byte (base 256).  The only negative numbers allowed are
 * -1 and -2, which are represented as 255,255 and 255,254  This format
 * happens to be the same as the hardware on the pdp-11, vax, and 386,
 * making it fast and convenient and small to do this on a pdp-11.
 */

#if	vax || pdp11 || i386
#define	_Getsh(ip)	(* (short *)ip)
#endif	/* vax || pdp11 */
/*
 * The following macro is partly due to Mike Laman, laman@sdcsvax
 *	NCR @ Torrey Pines.		- Tony Hansen
 */
#if	u3b || u3b15 || u3b2 || m68000
#define	_Getsh(ip)	((short)(*((unsigned char *)ip) | (*(ip+1) << 8)))
#endif	/* u3b || u3b15 || u3b2 || m68000 */

#ifndef	_Getsh
/*
 * Here is a more portable version, which does not assume byte ordering
 * in shorts, sign extension, etc.  For the sake of the porters,
 * two alternative implementations, for the machines that don't have
 * casting to "unsigned char", are also given, but commented out.
 * Not ANSI C implementation assumes that the * C preprocessor does
 * sign-extension the same as on the machine being compiled for.
 */
static int
_Getsh(char *p)
{
	int	rv, rv2;

	rv  = (unsigned char) p[0];
	rv2 = (unsigned char) p[1];

	/* the following stuff is only for porting.  See the comment above */

#ifdef FOR_PORTING
#if    CHAR_MIN < 0
	rv = (*p++) & 0377;
	rv2 = (*p) & 0377;
#else   /* CHAR_MIN < 0 */
	rv = *p++;
	rv2 = *p;
#endif  /* CHAR_MIN < 0 */

#endif  /* FOR_PORTING  */

	if ((rv2 == 0377) && ((rv == 0377) || (rv == 0376)))
		return (-1);
	return (rv + (rv2 * 256));
}
#endif	/* _Getsh */

/*
 * setupterm: low level routine to dig up terminfo from database
 * and read it in.  Parms are terminal type (0 means use getenv("TERM"),
 * file descriptor all output will go to (for ioctls), and a pointer
 * to an int into which the error return code goes (0 means to bomb
 * out with an error message if there's an error).  Thus,
 * setupterm((char *)0, 1, (int *)0) is a reasonable way for a simple
 * program to set up.
 */
int
setupterm(char *term, int filenum, int *errret)
	/* filenum - This is a UNIX file descriptor, not a stdio ptr. */
{
	char	tiebuf[4096];
	char	fname[TERMPATHLEN];
	char	*ip;
	char	*cp;
	int	n, tfd;
	char	*lcp, *ccp, **on_sequences, **str_array;
	int	snames, nbools, nints, nstrs, sstrtab;
	char	*strtab;
#ifdef	DUMPTI
	int		Vr2val;
#endif	/* DUMPTI */

	(void) mbgetwidth();

	if (term == NULL)
		term = getenv("TERM");

	if (term == NULL || *term == '\0')
		term = Def_term;

	tfd = -1;
	errno = 0; 	/* ehr3 */

	if (errret != 0)
		*errret = -1;

	if (((cp = getenv("TERMINFO")) != 0) && *cp) {
		/* $TERMINFO/?/$TERM */
		if (snprintf(fname, sizeof (fname),
			"%s/%c/%s", cp, *term, term) >= sizeof (fname)) {
			term_errno = TERMINFO_TOO_LONG;
			goto out_err;
		}

		tfd = open(fname, 0);
#ifdef	DUMPTI
		printf("looking in file %s\n", fname);
#endif	/* DUMPTI */
		if ((tfd < 0) && (errno == EACCES))
			goto cant_read;
	}

	if (tfd < 0) {
		/* /usr/share/lib/terminfo/?/$TERM */
		if (snprintf(fname, sizeof (fname),
			"%s/%c/%s", TERMPATH, *term, term) >= sizeof (fname)) {
			term_errno = TERMINFO_TOO_LONG;
			goto out_err;
		}

		tfd = open(fname, 0);
#ifdef	DUMPTI
		printf("looking in file %s\n", fname);
#endif	/* DUMPTI */

	}

	if (tfd < 0) {
		if (errno == EACCES) {
cant_read:
			term_errno = NOT_READABLE;
		} else {
			if (access(TERMPATH, 0) == -1)
				term_errno = UNACCESSIBLE;
			else {
				term_errno = NO_TERMINAL;
				if (errret != 0)
					*errret = 0;
			}
		}
		/*
		 * if the length of the specified terminal name is longer
		 * than 31, it will be chopped after the 31st byte.
		 * This should be a rare case.
		 */
		(void) strncpy(term_parm_err, term, 31);
		term_parm_err[31] = '\0';
		goto out_err;
	}

	/* LINTED */
	n = (int)read(tfd, tiebuf, sizeof (tiebuf));
	(void) close(tfd);

	if (n <= 0) {
corrupt:
		term_errno = CORRUPTED;
		goto out_err;
	} else
		if (n == sizeof (tiebuf)) {
			term_errno = ENTRY_TOO_LONG;
			goto out_err;
		}
	cp = ttytype;
	ip = tiebuf;

	/* Pick up header */
	snames = _Getshi();
#ifdef	DUMPTI
	Vr2val = _Vr2getshi();
	printf("Magic number = %d, %#o [%d, %#o].\n", snames,
	    snames, Vr2val, Vr2val);
#endif	/* DUMPTI */
	if (snames != MAGNUM)
		goto corrupt;
	snames = _Getshi();
#ifdef	DUMPTI
	Vr2val = _Vr2getshi();
	printf("Size of names = %d, %#o [%d, %#o].\n", snames,
	    snames, Vr2val, Vr2val);
#endif	/* DUMPTI */

	nbools = _Getshi();
#ifdef	DUMPTI
	Vr2val = _Vr2getshi();
	printf("Number of bools = %d, %#o [%d, %#o].\n", nbools,
	    nbools, Vr2val, Vr2val);
#endif	/* DUMPTI */

	nints = _Getshi();
#ifdef	DUMPTI
	Vr2val = _Vr2getshi();
	printf("Number of ints = %d, %#o [%d, %#o].\n", nints, nints,
	    Vr2val, Vr2val);
#endif	/* DUMPTI */

	nstrs = _Getshi();
#ifdef	DUMPTI
	Vr2val = _Vr2getshi();
	printf("Number of strings = %d, %#o [%d, %#o].\n", nstrs, nstrs,
	    Vr2val, Vr2val);
#endif	/* DUMPTI */

	sstrtab = _Getshi();
#ifdef	DUMPTI
	Vr2val = _Vr2getshi();
	printf("Size of string table = %d, %#o [%d, %#o].\n", sstrtab,
	    sstrtab, Vr2val, Vr2val);
	printf("Names are: %.*s.\n", snames, ip);
#endif	/* DUMPTI */

	/* allocate all of the space */
	strtab = NULL;
	if (_called_before) {
		/* 2nd or more times through */
		if ((cur_term = (TERMINAL *)
		    calloc(sizeof (TERMINAL), 1)) == NULL)
			goto badmalloc;
		if ((cur_bools = (struct _bool_struct *)
		    calloc(sizeof (struct _bool_struct), 1)) == NULL)
			goto freeterminal;
		if ((cur_nums = (struct _num_struct *)
		    calloc(sizeof (struct _num_struct), 1)) == NULL)
			goto freebools;
		if ((cur_strs = (struct _str_struct *)
		    calloc(sizeof (struct _str_struct), 1)) == NULL) {
freenums:
			free((char *)cur_nums);
freebools:
			free((char *)cur_bools);
freeterminal:
			free((char *)cur_term);
badmalloc:
			term_errno = TERM_BAD_MALLOC;
#ifdef	DEBUG
			strcpy(term_parm_err, "setupterm");
#endif	/* DEBUG */
out_err:
			if (errret == 0) {
				termerr();
				exit(-term_errno);
			} else
				return (ERR);
		}
	} else {
		/* First time through */
		_called_before = TRUE;
		cur_term = &_first_term;
		cur_bools = &_frst_bools;
		cur_nums = &_frst_nums;
		cur_strs = &_frst_strs;
		if (sstrtab < sizeof (_frst_tblstr))
			strtab = _frst_tblstr;
	}

	if (strtab == NULL) {
		if ((strtab = (char *)malloc((unsigned)sstrtab)) == NULL) {
			if (cur_strs != &_frst_strs)
				free((char *)cur_strs);
			goto freenums;
		}
	}

	/* no more catchable errors */
	if (errret)
		*errret = 1;

	(void) strncpy(cur_term->_termname, term, 14);
	/* In case the name is exactly 15 characters */
	cur_term->_termname[14] = '\0';
	cur_term->_bools = cur_bools;
	cur_term->_nums = cur_nums;
	cur_term->_strs = cur_strs;
	cur_term->_strtab = strtab;
	cur_term->sgr_mode = cur_term->sgr_faked = A_NORMAL;

	if (filenum == 1 && !isatty(filenum))
		filenum = 2;	/* Allow output redirect */
	/* LINTED */
	cur_term->Filedes = (short)filenum;
	_blast_keys(cur_term);
	cur_term->_iwait = cur_term->fl_typeahdok = cur_term->_chars_on_queue =
		cur_term->_fl_rawmode = cur_term->_ungotten = 0;
	cur_term->_cursorstate = 1;
	cur_term->_delay = cur_term->_inputfd = cur_term->_check_fd = -1;
	(void) memset((char *)cur_term->_regs, 0, 26 * sizeof (short));

#ifndef	DUMPTI
	(void) def_shell_mode();
	/* This is a useful default for PROGTTY, too */
#ifdef SYSV
	if (shell_istermios < 0) {
		int i;

		SHELLTTY.c_lflag = SHELLTTYS.c_lflag;
		SHELLTTY.c_oflag = SHELLTTYS.c_oflag;
		SHELLTTY.c_iflag = SHELLTTYS.c_iflag;
		SHELLTTY.c_cflag = SHELLTTYS.c_cflag;
		for (i = 0; i < NCC; i++)
			SHELLTTY.c_cc[i] = SHELLTTYS.c_cc[i];
		PROGTTY = SHELLTTY;
		prog_istermios = -1;

		PROGTTYS.c_lflag = PROGTTY.c_lflag;
		PROGTTYS.c_oflag = PROGTTY.c_oflag;
		PROGTTYS.c_iflag = PROGTTY.c_iflag;
		PROGTTYS.c_cflag = PROGTTY.c_cflag;
		for (i = 0; i < NCC; i++)
			PROGTTYS.c_cc[i] = PROGTTY.c_cc[i];
	} else {
		PROGTTYS = SHELLTTYS;
		prog_istermios = 0;
	}
#else	/* SYSV */
	PROGTTY = SHELLTTY;
#endif	/* SYSV */
#endif	/* DUMPTI */

	/* Skip names of terminals */
	(void) memcpy((char *)cp, (char *)ip, (snames * sizeof (*cp)));
	ip += snames;

	/*
	 * Pull out the booleans.
	 * The for loop below takes care of a new curses with an old tic
	 * file and visa-versa.  nbools says how many bools the tic file has.
	 * So, we only loop for as long as there are bools to read.
	 * However, if this is an old curses that doesn't have all the
	 * bools that this new tic has dumped, then the extra if
	 * "if (cp < fp)" says that if we are going to read into our structure
	 * passed its size don't do it but we still need to keep bumping
	 * up the pointer of what we read in from the terminfo file.
	 */
	{
		char	*fp = &cur_bools->Sentinel;
		char	s;
#ifdef	DUMPTI
		int	tempindex = 0;
#endif	/* DUMPTI */
		cp = &cur_bools->_auto_left_margin;
		while (nbools--) {
			s = *ip++;
#ifdef	DUMPTI
			printf("Bool %s [%s] (%s) = %d.\n",
			    boolfnames[tempindex], boolnames[tempindex],
			    boolcodes[tempindex], s);
			tempindex++;
#endif	/* DUMPTI */
			if (cp < fp)
				*cp++ = s & 01;
		}
		if (cp < fp)
			(void) memset(cp, 0, ((fp - cp) * sizeof (bool)));
	}

	/* Force proper alignment */
	if (((unsigned long) ip) & 1)
		ip++;

	/*
	 * Pull out the numbers.
	 */
	{
		short	*sp = &cur_nums->_columns;
		short	*fp = &cur_nums->Sentinel;
		int	s;
#ifdef	DUMPTI
		int	tempindex = 0;
#endif	/* DUMPTI */

		while (nints--) {
			s = _Getshi();
#ifdef	DUMPTI
			Vr2val = _Vr2getshi();
			printf("Num %s [%s] (%s) = %d [%d].\n",
			    numfnames[tempindex], numnames[tempindex],
			    numcodes[tempindex], s, Vr2val);
			tempindex++;
#endif	/* DUMPTI */
			if (sp < fp)
				if (s < 0)
					*sp++ = -1;
				else
					/* LINTED */
					*sp++ = (short)s;
		}
		if (sp < fp)
			(void) memset((char *)sp, '\377',
			    ((fp - sp) * sizeof (short)));
	}

	if (_use_env) {
		/*
		 * This ioctl defines the window size and overrides what
		 * it says in terminfo.
		 */
		{
			struct	winsize	w;

			if (ioctl(filenum, TIOCGWINSZ, &w) != -1) {
				if (w.ws_row != 0)
					cur_nums->_lines = w.ws_row;
				if (w.ws_col != 0)
					cur_nums->_columns = w.ws_col;
#ifdef	DUMPTI
				printf("ioctl TIOCGWINSZ override: "
				    "(lines, columns) = (%d, %d)\n",
				    w.ws_row, w.ws_col);
#endif	/* DUMPTI */
			}
		}

		/*
		 * Check $LINES and $COLUMNS.
		 */
		{
			int	ilines, icolumns;

			lcp = getenv("LINES");
			ccp = getenv("COLUMNS");
			if (lcp)
				if ((ilines = atoi(lcp)) > 0) {
					/* LINTED */
					cur_nums->_lines = (short)ilines;
#ifdef	DUMPTI
					printf("$LINES override: lines = %d\n",
					    ilines);
#endif	/* DUMPTI */
				}
			if (ccp)
				if ((icolumns = atoi(ccp)) > 0) {
					/* LINTED */
					cur_nums->_columns = (short)icolumns;
#ifdef	DUMPTI
					printf("$COLUMNS override: columns = "
					    "%d\n", icolumns);
#endif	/* DUMPTI */
				}
		}
	}

	/* Pull out the strings. */
	{
		char	**pp = &cur_strs->strs._back_tab;
		char	**fp = &cur_strs->strs4.Sentinel;
#ifdef	DUMPTI
		int	tempindex = 0;
		char	*startstr = ip + sizeof (short) *
					    nstrs;

		printf("string table = '");
		_Mprint(sstrtab, startstr);
		printf("'\n");
#endif	/* DUMPTI */

		while (nstrs--) {
			n = _Getshi();
#ifdef	DUMPTI
			Vr2val = _Vr2getshi();
			printf("String %s [%s] (%s) offset = %d [%d]",
			    strfnames[tempindex], strnames[tempindex],
			    strcodes[tempindex], n, Vr2val);
			tempindex++;
#endif	/* DUMPTI */
			if (pp < fp) {
#ifdef	DUMPTI
				_Sprint(n, startstr+n);
#endif	/* DUMPTI */
				if (n < 0)
					*pp++ = NULL;
				else
					*pp++ = strtab + n;
			}
#ifdef	DUMPTI
			else
				_Sprint(-1, (char *)0);
#endif	/* DUMPTI */
		}
		if (pp < fp)
		(void) memset((char *)pp, 0, ((fp - pp) * sizeof (charptr)));
	}

	(void) memcpy(strtab, ip, sstrtab);

#ifndef	DUMPTI

	/*
	 * If tabs are being expanded in software, turn this off
	 * so output won't get messed up.  Also, don't use tab
	 * or backtab, even if the terminal has them, since the
	 * user might not have hardware tabs set right.
	 */
#ifdef	SYSV
	if ((PROGTTYS.c_oflag & TABDLY) == TAB3) {
		PROGTTYS.c_oflag &= ~TABDLY;
		(void) reset_prog_mode();
		goto next;
	}
#else	/* SYSV */
	if ((PROGTTY.sg_flags & XTABS) == XTABS) {
		PROGTTY.sg_flags &= ~XTABS;
		(void) reset_prog_mode();
		goto next;
	}
#endif	/* SYSV */
	if (dest_tabs_magic_smso) {
next:
		cur_strs->strs2._tab = cur_strs->strs._back_tab = NULL;
	}

#ifdef	LTILDE
	ioctl(cur_term -> Filedes, TIOCLGET, &n);
#endif	/* LTILDE */
#endif	/* DUMPTI */

#ifdef	_VR2_COMPAT_CODE
	(void) memcpy(&cur_term->_b1, &cur_bools->_auto_left_margin,
	    (char *)&cur_term->_c1 - (char *)&cur_term->_b1);
	(void) memcpy((char *)&cur_term->_c1, (char *)&cur_nums->_columns,
	    (char *)&cur_term->_Vr2_Astrs._s1 - (char *)&cur_term->_c1);
	(void) memcpy((char *)&cur_term->_Vr2_Astrs._s1,
	    (char *)&cur_strs->strs._back_tab,
	    (char *)&cur_term->Filedes - (char *)&cur_term->_Vr2_Astrs._s1);
#endif	/* _VR2_COMPAT_CODE */

	on_sequences = cur_term->turn_on_seq;
	str_array = (char **)cur_strs;
	{
		static	char	offsets[] = {
			    35,	/* enter_standout_mode, */
			    36,	/* enter_underline_mode, */
			    25,	/* enter_alt_charset_mode, */
			    34,	/* enter_reverse_mode, */
			    26,	/* enter_blink_mode, */
			    30,	/* enter_dim_mode, */
			    27,	/* enter_bold_mode, */
			    32,	/* enter_secure_mode, */
			    33,	/* enter_protected_mode, */
			};

		for (n = 0; n < NUM_ATTRIBUTES; n++) {
			if ((on_sequences[n] = str_array[offsets[n]]) != 0)
				cur_term->bit_vector |= bit_attributes[n];
		}
	}

	if (!(set_attributes)) {
		static	char	faked_attrs[] = { 1, 3, 4, 6 },
			offsets[] = {
			    43,	/* exit_standout_mode, */
			    44,	/* exit_underline_mode, */
			    38,	/* exit_alt_charset_mode, */
			};
		char		**off_sequences = cur_term->turn_off_seq;
		int		i;

		if ((max_attributes == -1) && (ceol_standout_glitch ||
		    (magic_cookie_glitch >= 0)))
			max_attributes = 1;

		/* Figure out what attributes need to be faked. */
		/* See vidupdate.c */

		for (n = 0; n < sizeof (faked_attrs); n++) {
			if (on_sequences[0] != NULL) {
				if ((!on_sequences[i = faked_attrs[n]]) ||
				    (strcmp(on_sequences[i],
				    on_sequences[0]) == 0)) {
					cur_term->sgr_faked |=
					    bit_attributes[i];
				}
			} else {
				if (!on_sequences[i = faked_attrs[n]]) {
					cur_term->sgr_faked |=
					    bit_attributes[i];
				}
			}
		}

		cur_term->check_turn_off = A_STANDOUT | A_UNDERLINE |
		    A_ALTCHARSET;

		for (n = 0; n < sizeof (offsets); n++) {
			if ((!(off_sequences[n] = str_array[offsets[n]])) ||
			    ((n > 0) && off_sequences[0] &&
			    (strcmp(off_sequences[n], off_sequences[0]) ==
			    0)) || ((n == 2) && (exit_attribute_mode) &&
			    (strcmp(exit_attribute_mode, off_sequences[n]) ==
			    0))) {
				cur_term->check_turn_off &= ~bit_attributes[n];
			}
		}
	}
	cur_term->cursor_seq[0] = cursor_invisible;
	cur_term->cursor_seq[1] = cursor_normal;
	cur_term->cursor_seq[2] = cursor_visible;
	cur_term->_pairs_tbl = (_Color_pair *) NULL;
	cur_term->_color_tbl = (_Color *) NULL;

	return (OK);
}

void
_blast_keys(TERMINAL *terminal)
{
	terminal->_keys = NULL;
	terminal->internal_keys = NULL;
	terminal->_ksz = terminal->_first_macro = 0;
	terminal->_lastkey_ordered = terminal->_lastmacro_ordered = -1;
	(void) memset((char *)terminal->funckeystarter, 0, 0400 *
	    sizeof (bool));
}

#ifndef	DUMPTI

int
reset_prog_mode(void)
{
#ifdef	SYSV
	if (_BRS(PROGTTYS)) {
		if (prog_istermios < 0) {
			int i;

			PROGTTY.c_lflag = PROGTTYS.c_lflag;
			PROGTTY.c_oflag = PROGTTYS.c_oflag;
			PROGTTY.c_iflag = PROGTTYS.c_iflag;
			PROGTTY.c_cflag = PROGTTYS.c_cflag;
			for (i = 0; i < NCC; i++)
				PROGTTY.c_cc[i] = PROGTTYS.c_cc[i];
			(void) ioctl(cur_term -> Filedes, TCSETAW, &PROGTTY);
		} else
			(void) ioctl(cur_term -> Filedes, TCSETSW, &PROGTTYS);
	}
#else	/* SYSV */
	if (_BR(PROGTTY))
		(void) ioctl(cur_term -> Filedes, TIOCSETN, &PROGTTY);
#endif	/* SYSV */

#ifdef	LTILDE
	ioctl(cur_term -> Filedes, TIOCLGET, &cur_term -> oldlmode);
	cur_term -> newlmode = cur_term -> oldlmode & ~LTILDE;
	if (cur_term -> newlmode != cur_term -> oldlmode)
		ioctl(cur_term -> Filedes, TIOCLSET, &cur_term -> newlmode);
#endif	/* LTILDE */
#ifdef	DIOCSETT
	if (cur_term -> old.st_termt == 0)
		ioctl(cur_term->Filedes, DIOCGETT, &cur_term -> old);
	cur_term -> new = cur_term -> old;
	cur_term -> new.st_termt = 0;
	cur_term -> new.st_flgs |= TM_SET;
	ioctl(cur_term->Filedes, DIOCSETT, &cur_term -> new);
#endif	/* DIOCSETT */
	return (OK);
}

int
def_shell_mode(void)
{
#ifdef	SYSV
	if ((shell_istermios =
	    ioctl(cur_term -> Filedes, TCGETS, &SHELLTTYS)) < 0) {
		int i;

		(void) ioctl(cur_term -> Filedes, TCGETA, &SHELLTTY);
		SHELLTTYS.c_lflag = SHELLTTY.c_lflag;
		SHELLTTYS.c_oflag = SHELLTTY.c_oflag;
		SHELLTTYS.c_iflag = SHELLTTY.c_iflag;
		SHELLTTYS.c_cflag = SHELLTTY.c_cflag;
		for (i = 0; i < NCC; i++)
			SHELLTTYS.c_cc[i] = SHELLTTY.c_cc[i];
	}
#else	/* SYSV */
	(void) ioctl(cur_term -> Filedes, TIOCGETP, &SHELLTTY);
#endif	/* SYSV */
	return (OK);
}

#endif	/* DUMPTI */