[unix-history] / usr / src / sys / kern / tty_compat.c

/*
 * Copyright (c) 1982, 1986 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 *
 *	@(#)tty_compat.c	7.8 (Berkeley) %G%
 */

/* 
 * mapping routines for old line discipline (yuck)
 */
#ifdef COMPAT_43

#include "param.h"
#include "systm.h"
#include "user.h"
#include "ioctl.h"
#include "tty.h"
#include "termios.h"
#include "proc.h"
#include "file.h"
#include "conf.h"
#include "dkstat.h"
#include "uio.h"
#include "kernel.h"
#include "syslog.h"

#include "machine/reg.h"

int ttydebug = 0;

static struct speedtab compatspeeds[] = {
	38400,	15,
	19200,	14,
	9600,	13,
	4800,	12,
	2400,	11,
	1800,	10,
	1200,	9,
	600,	8,
	300,	7,
	200,	6,
	150,	5,
	134,	4,
	110,	3,
	75,	2,
	50,	1,
	0,	0,
	-1,	-1,
};
static int compatspcodes[16] = { 
	0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
	1800, 2400, 4800, 9600, 19200, 38400,
};

ttspeedtab(speed, table)
	register struct speedtab *table;
{

	for ( ; table->sp_speed != -1; table++)
		if (table->sp_speed == speed)
			return (table->sp_code);
	return (-1);
}

/*ARGSUSED*/
ttcompat(tp, com, data, flag)
	register struct tty *tp;
	caddr_t data;
{

	switch (com) {
	case TIOCGETP: {
		register struct sgttyb *sg = (struct sgttyb *)data;
		register u_char *cc = tp->t_cc;
		register speed;

		speed = ttspeedtab(tp->t_ospeed, compatspeeds);
		sg->sg_ospeed = (speed == -1) ? 15 : speed;
		if (tp->t_ispeed == 0)
			sg->sg_ispeed = sg->sg_ospeed;
		else {
			speed = ttspeedtab(tp->t_ispeed, compatspeeds);
			sg->sg_ispeed = (speed == -1) ? 15 : speed;
		}
		sg->sg_erase = cc[VERASE];
		sg->sg_kill = cc[VKILL];
		sg->sg_flags = ttcompatgetflags(tp);
		break;
	}

	case TIOCSETP:
	case TIOCSETN: {
		register struct sgttyb *sg = (struct sgttyb *)data;
		struct termios term;
		int speed;

		term = tp->t_termios;
		if ((speed = sg->sg_ispeed) > 15 || speed < 0)
			term.c_ispeed = speed;
		else
			term.c_ispeed = compatspcodes[speed];
		if ((speed = sg->sg_ospeed) > 15 || speed < 0)
			term.c_ospeed = speed;
		else
			term.c_ospeed = compatspcodes[speed];
		term.c_cc[VERASE] = sg->sg_erase;
		term.c_cc[VKILL] = sg->sg_kill;
		tp->t_flags = tp->t_flags&0xffff0000 | sg->sg_flags&0xffff;
		ttcompatsetflags(tp, &term);
		return (ttioctl(tp, com == TIOCSETP ? TIOCSETAF : TIOCSETA, 
			&term, flag));
	}

	case TIOCGETC: {
		struct tchars *tc = (struct tchars *)data;
		register u_char *cc = tp->t_cc;

		tc->t_intrc = cc[VINTR];
		tc->t_quitc = cc[VQUIT];
		tc->t_startc = cc[VSTART];
		tc->t_stopc = cc[VSTOP];
		tc->t_eofc = cc[VEOF];
		tc->t_brkc = cc[VEOL];
		break;
	}
	case TIOCSETC: {
		struct tchars *tc = (struct tchars *)data;
		register u_char *cc = tp->t_cc;

		cc[VINTR] = tc->t_intrc;
		cc[VQUIT] = tc->t_quitc;
		cc[VSTART] = tc->t_startc;
		cc[VSTOP] = tc->t_stopc;
		cc[VEOF] = tc->t_eofc;
		cc[VEOL] = tc->t_brkc;
		if (tc->t_brkc == -1)
			cc[VEOL2] = _POSIX_VDISABLE;
		break;
	}
	case TIOCSLTC: {
		struct ltchars *ltc = (struct ltchars *)data;
		register u_char *cc = tp->t_cc;

		cc[VSUSP] = ltc->t_suspc;
		cc[VDSUSP] = ltc->t_dsuspc;
		cc[VREPRINT] = ltc->t_rprntc;
		cc[VDISCARD] = ltc->t_flushc;
		cc[VWERASE] = ltc->t_werasc;
		cc[VLNEXT] = ltc->t_lnextc;
		break;
	}
	case TIOCGLTC: {
		struct ltchars *ltc = (struct ltchars *)data;
		register u_char *cc = tp->t_cc;

		ltc->t_suspc = cc[VSUSP];
		ltc->t_dsuspc = cc[VDSUSP];
		ltc->t_rprntc = cc[VREPRINT];
		ltc->t_flushc = cc[VDISCARD];
		ltc->t_werasc = cc[VWERASE];
		ltc->t_lnextc = cc[VLNEXT];
		break;
	}
	case TIOCLBIS:
	case TIOCLBIC:
	case TIOCLSET: {
		struct termios term;

		term = tp->t_termios;
		if (com == TIOCLSET)
			tp->t_flags = (tp->t_flags&0xffff) | *(int *)data<<16;
		else {
			tp->t_flags = 
			 (ttcompatgetflags(tp)&0xffff0000)|(tp->t_flags&0xffff);
			if (com == TIOCLBIS)
				tp->t_flags |= *(int *)data<<16;
			else
				tp->t_flags &= ~(*(int *)data<<16);
		}
		ttcompatsetlflags(tp, &term);
		return (ttioctl(tp, TIOCSETA, &term, flag));
	}
	case TIOCLGET:
		*(int *)data = ttcompatgetflags(tp)>>16;
		if (ttydebug)
			printf("CLGET: returning %x\n", *(int *)data);
		break;

	case OTIOCGETD:
		*(int *)data = tp->t_line ? tp->t_line : 2;
		break;

	case OTIOCSETD: {
		int ldisczero = 0;

		return (ttioctl(tp, TIOCSETD, 
			*(int *)data == 2 ? (caddr_t)&ldisczero : data, flag));
	    }

	case OTIOCCONS:
		*(int *)data = 1;
		return (ttioctl(tp, TIOCCONS, data, flag));

	default:
		return (-1);
	}
	return (0);
}

ttcompatgetflags(tp)
	register struct tty *tp;
{
	register long iflag = tp->t_iflag;
	register long lflag = tp->t_lflag;
	register long oflag = tp->t_oflag;
	register long cflag = tp->t_cflag;
	register flags = 0;

	if (iflag&IXOFF)
		flags |= TANDEM;
	if (iflag&ICRNL || oflag&ONLCR)
		flags |= CRMOD;
	if (cflag&PARENB) {
		if (iflag&INPCK) {
			if (cflag&PARODD)
				flags |= ODDP;
			else
				flags |= EVENP;
		} else
			flags |= EVENP | ODDP;
	} else {
		if ((tp->t_flags&LITOUT) && !(oflag&OPOST))
			flags |= LITOUT;
		if (tp->t_flags&PASS8)
			flags |= PASS8;
	}
	
	if ((lflag&ICANON) == 0) {	
		/* fudge */
		if (iflag&IXON || lflag&ISIG || lflag&IEXTEN || cflag&PARENB)
			flags |= CBREAK;
		else
			flags |= RAW;
	}
	if (oflag&OXTABS)
		flags |= XTABS;
	if (lflag&ECHOE)
		flags |= CRTERA|CRTBS;
	if (lflag&ECHOKE)
		flags |= CRTKIL|CRTBS;
	if (lflag&ECHOPRT)
		flags |= PRTERA;
	if (lflag&ECHOCTL)
		flags |= CTLECH;
	if ((iflag&IXANY) == 0)
		flags |= DECCTQ;
	flags |= lflag&(ECHO|MDMBUF|TOSTOP|FLUSHO|NOHANG|PENDIN|NOFLSH);
if (ttydebug)
	printf("getflags: %x\n", flags);
	return (flags);
}

ttcompatsetflags(tp, t)
	register struct tty *tp;
	register struct termios *t;
{
	register flags = tp->t_flags;
	register long iflag = t->c_iflag;
	register long oflag = t->c_oflag;
	register long lflag = t->c_lflag;
	register long cflag = t->c_cflag;

	if (flags & RAW) {
		iflag &= IXOFF;
		oflag &= ~OPOST;
		lflag &= ~(ECHOCTL|ISIG|ICANON|IEXTEN);
	} else {
		iflag |= BRKINT|IXON|IMAXBEL;
		oflag |= OPOST;
		lflag |= ISIG|IEXTEN|ECHOCTL;	/* XXX was echoctl on ? */
		if (flags & XTABS)
			oflag |= OXTABS;
		else
			oflag &= ~OXTABS;
		if (flags & CBREAK)
			lflag &= ~ICANON;
		else
			lflag |= ICANON;
		if (flags&CRMOD) {
			iflag |= ICRNL;
			oflag |= ONLCR;
		} else {
			iflag &= ~ICRNL;
			oflag &= ~ONLCR;
		}
	}
	if (flags&ECHO)
		lflag |= ECHO;
	else
		lflag &= ~ECHO;
		
	if (flags&(RAW|LITOUT|PASS8)) {
		cflag &= ~(CSIZE|PARENB);
		cflag |= CS8;
		if ((flags&(RAW|PASS8)) == 0)
			iflag |= ISTRIP;
		else
			iflag &= ~ISTRIP;
	} else {
		cflag &= ~CSIZE;
		cflag |= CS7|PARENB;
		iflag |= ISTRIP;
	}
	if ((flags&(EVENP|ODDP)) == EVENP) {
		iflag |= INPCK;
		cflag &= ~PARODD;
	} else if ((flags&(EVENP|ODDP)) == ODDP) {
		iflag |= INPCK;
		cflag |= PARODD;
	} else 
		iflag &= ~INPCK;
	if (flags&LITOUT)
		oflag &= ~OPOST;	/* move earlier ? */
	if (flags&TANDEM)
		iflag |= IXOFF;
	else
		iflag &= ~IXOFF;
	t->c_iflag = iflag;
	t->c_oflag = oflag;
	t->c_lflag = lflag;
	t->c_cflag = cflag;
}

ttcompatsetlflags(tp, t)
	register struct tty *tp;
	register struct termios *t;
{
	register flags = tp->t_flags;
	register long iflag = t->c_iflag;
	register long oflag = t->c_oflag;
	register long lflag = t->c_lflag;
	register long cflag = t->c_cflag;

	if (flags&CRTERA)
		lflag |= ECHOE;
	else
		lflag &= ~ECHOE;
	if (flags&CRTKIL)
		lflag |= ECHOKE;
	else
		lflag &= ~ECHOKE;
	if (flags&PRTERA)
		lflag |= ECHOPRT;
	else
		lflag &= ~ECHOPRT;
	if (flags&CTLECH)
		lflag |= ECHOCTL;
	else
		lflag &= ~ECHOCTL;
	if ((flags&DECCTQ) == 0)
		lflag |= IXANY;
	else
		lflag &= ~IXANY;
	lflag &= ~(MDMBUF|TOSTOP|FLUSHO|NOHANG|PENDIN|NOFLSH);
	lflag |= flags&(MDMBUF|TOSTOP|FLUSHO|NOHANG|PENDIN|NOFLSH);
	if (flags&(LITOUT|PASS8)) {
		iflag &= ~ISTRIP;
		cflag &= ~(CSIZE|PARENB);
		cflag |= CS8;
		if (flags&LITOUT)
			oflag &= ~OPOST;
		if ((flags&(PASS8|RAW)) == 0)
			iflag |= ISTRIP;
	} else if ((flags&RAW) == 0) {
		cflag &= ~CSIZE;
		cflag |= CS7|PARENB;
		oflag |= OPOST;
	}
	t->c_iflag = iflag;
	t->c_oflag = oflag;
	t->c_lflag = lflag;
	t->c_cflag = cflag;
}
#endif	/* COMPAT_43 */
Commit	Line	Data
f73a43fc MT	1	/*
	2	* Copyright (c) 1982, 1986 Regents of the University of California.
	3	* All rights reserved. The Berkeley software License Agreement
	4	* specifies the terms and conditions for redistribution.
	5	*
b98b2de8	6	* @(#)tty_compat.c 7.8 (Berkeley) %G%
f73a43fc MT	7	*/
	8
	9	/*
e39f9ea6	10	* mapping routines for old line discipline (yuck)
f73a43fc MT	11	*/
	12	#ifdef COMPAT_43
	13
f73a43fc MT	14	#include "param.h"
f73a43fc MT	15	#include "systm.h"
f73a43fc MT	16	#include "user.h"
	17	#include "ioctl.h"
	18	#include "tty.h"
	19	#include "termios.h"
	20	#include "proc.h"
	21	#include "file.h"
	22	#include "conf.h"
	23	#include "dkstat.h"
	24	#include "uio.h"
	25	#include "kernel.h"
	26	#include "syslog.h"
	27
d301d150 KM	28	#include "machine/reg.h"
d301d150 KM	29
e39f9ea6	30	int ttydebug = 0;
f73a43fc	31
f73a43fc MT	32	static struct speedtab compatspeeds[] = {
	33	38400, 15,
	34	19200, 14,
	35	9600, 13,
	36	4800, 12,
	37	2400, 11,
	38	1800, 10,
	39	1200, 9,
	40	600, 8,
	41	300, 7,
	42	200, 6,
	43	150, 5,
	44	134, 4,
	45	110, 3,
	46	75, 2,
	47	50, 1,
	48	0, 0,
	49	-1, -1,
	50	};
	51	static int compatspcodes[16] = {
	52	0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
	53	1800, 2400, 4800, 9600, 19200, 38400,
	54	};
	55
7fbb76da MT	56	ttspeedtab(speed, table)
	57	register struct speedtab *table;
	58	{
	59
	60	for ( ; table->sp_speed != -1; table++)
	61	if (table->sp_speed == speed)
	62	return (table->sp_code);
	63	return (-1);
	64	}
	65
f73a43fc MT	66	/ARGSUSED/
	67	ttcompat(tp, com, data, flag)
	68	register struct tty *tp;
	69	caddr_t data;
	70	{
7fbb76da MT	71
7fbb76da MT	72	switch (com) {
f73a43fc MT	73	case TIOCGETP: {
	74	register struct sgttyb sg = (struct sgttyb )data;
	75	register u_char *cc = tp->t_cc;
	76	register speed;
	77
	78	speed = ttspeedtab(tp->t_ospeed, compatspeeds);
	79	sg->sg_ospeed = (speed == -1) ? 15 : speed;
	80	if (tp->t_ispeed == 0)
	81	sg->sg_ispeed = sg->sg_ospeed;
	82	else {
	83	speed = ttspeedtab(tp->t_ispeed, compatspeeds);
	84	sg->sg_ispeed = (speed == -1) ? 15 : speed;
	85	}
f73a43fc MT	86	sg->sg_erase = cc[VERASE];
f73a43fc MT	87	sg->sg_kill = cc[VKILL];
e39f9ea6	88	sg->sg_flags = ttcompatgetflags(tp);
f73a43fc MT	89	break;
	90	}
	91
	92	case TIOCSETP:
	93	case TIOCSETN: {
	94	register struct sgttyb sg = (struct sgttyb )data;
	95	struct termios term;
	96	int speed;
	97
	98	term = tp->t_termios;
f73a43fc MT	99	if ((speed = sg->sg_ispeed) > 15 \|\| speed < 0)
	100	term.c_ispeed = speed;
	101	else
	102	term.c_ispeed = compatspcodes[speed];
	103	if ((speed = sg->sg_ospeed) > 15 \|\| speed < 0)
	104	term.c_ospeed = speed;
	105	else
	106	term.c_ospeed = compatspcodes[speed];
f73a43fc MT	107	term.c_cc[VERASE] = sg->sg_erase;
f73a43fc MT	108	term.c_cc[VKILL] = sg->sg_kill;
7fbb76da	109	tp->t_flags = tp->t_flags&0xffff0000 \| sg->sg_flags&0xffff;
f73a43fc MT	110	ttcompatsetflags(tp, &term);
	111	return (ttioctl(tp, com == TIOCSETP ? TIOCSETAF : TIOCSETA,
	112	&term, flag));
	113	}
	114
	115	case TIOCGETC: {
	116	struct tchars tc = (struct tchars )data;
	117	register u_char *cc = tp->t_cc;
	118
	119	tc->t_intrc = cc[VINTR];
	120	tc->t_quitc = cc[VQUIT];
	121	tc->t_startc = cc[VSTART];
	122	tc->t_stopc = cc[VSTOP];
	123	tc->t_eofc = cc[VEOF];
	124	tc->t_brkc = cc[VEOL];
	125	break;
	126	}
	127	case TIOCSETC: {
	128	struct tchars tc = (struct tchars )data;
	129	register u_char *cc = tp->t_cc;
	130
	131	cc[VINTR] = tc->t_intrc;
	132	cc[VQUIT] = tc->t_quitc;
	133	cc[VSTART] = tc->t_startc;
	134	cc[VSTOP] = tc->t_stopc;
	135	cc[VEOF] = tc->t_eofc;
	136	cc[VEOL] = tc->t_brkc;
	137	if (tc->t_brkc == -1)
e39f9ea6	138	cc[VEOL2] = _POSIX_VDISABLE;
f73a43fc MT	139	break;
	140	}
	141	case TIOCSLTC: {
	142	struct ltchars ltc = (struct ltchars )data;
	143	register u_char *cc = tp->t_cc;
	144
	145	cc[VSUSP] = ltc->t_suspc;
	146	cc[VDSUSP] = ltc->t_dsuspc;
	147	cc[VREPRINT] = ltc->t_rprntc;
ee3c7f94	148	cc[VDISCARD] = ltc->t_flushc;
f73a43fc MT	149	cc[VWERASE] = ltc->t_werasc;
	150	cc[VLNEXT] = ltc->t_lnextc;
	151	break;
	152	}
	153	case TIOCGLTC: {
	154	struct ltchars ltc = (struct ltchars )data;
	155	register u_char *cc = tp->t_cc;
	156
	157	ltc->t_suspc = cc[VSUSP];
	158	ltc->t_dsuspc = cc[VDSUSP];
	159	ltc->t_rprntc = cc[VREPRINT];
ee3c7f94	160	ltc->t_flushc = cc[VDISCARD];
f73a43fc MT	161	ltc->t_werasc = cc[VWERASE];
	162	ltc->t_lnextc = cc[VLNEXT];
	163	break;
	164	}
	165	case TIOCLBIS:
	166	case TIOCLBIC:
	167	case TIOCLSET: {
	168	struct termios term;
	169
	170	term = tp->t_termios;
	171	if (com == TIOCLSET)
e39f9ea6	172	tp->t_flags = (tp->t_flags&0xffff) \| (int )data<<16;
f73a43fc MT	173	else {
	174	tp->t_flags =
	175	(ttcompatgetflags(tp)&0xffff0000)\|(tp->t_flags&0xffff);
	176	if (com == TIOCLBIS)
e39f9ea6	177	tp->t_flags \|= (int )data<<16;
f73a43fc	178	else
e39f9ea6	179	tp->t_flags &= ~((int )data<<16);
f73a43fc MT	180	}
	181	ttcompatsetlflags(tp, &term);
	182	return (ttioctl(tp, TIOCSETA, &term, flag));
	183	}
	184	case TIOCLGET:
e39f9ea6 MT	185	(int )data = ttcompatgetflags(tp)>>16;
	186	if (ttydebug)
	187	printf("CLGET: returning %x\n", (int )data);
f73a43fc	188	break;
e39f9ea6	189
6ef1614c	190	case OTIOCGETD:
e39f9ea6 MT	191	(int )data = tp->t_line ? tp->t_line : 2;
	192	break;
	193
6ef1614c	194	case OTIOCSETD: {
e39f9ea6 MT	195	int ldisczero = 0;
e39f9ea6 MT	196
7fbb76da	197	return (ttioctl(tp, TIOCSETD,
e39f9ea6	198	(int )data == 2 ? (caddr_t)&ldisczero : data, flag));
7fbb76da	199	}
a574d21e KM	200
	201	case OTIOCCONS:
	202	(int )data = 1;
7fbb76da	203	return (ttioctl(tp, TIOCCONS, data, flag));
e39f9ea6	204
f73a43fc MT	205	default:
	206	return (-1);
	207	}
7fbb76da	208	return (0);
f73a43fc MT	209	}
f73a43fc MT	210
f73a43fc MT	211	ttcompatgetflags(tp)
	212	register struct tty *tp;
	213	{
	214	register long iflag = tp->t_iflag;
	215	register long lflag = tp->t_lflag;
	216	register long oflag = tp->t_oflag;
	217	register long cflag = tp->t_cflag;
	218	register flags = 0;
	219
	220	if (iflag&IXOFF)
	221	flags \|= TANDEM;
	222	if (iflag&ICRNL \|\| oflag&ONLCR)
	223	flags \|= CRMOD;
	224	if (cflag&PARENB) {
	225	if (iflag&INPCK) {
	226	if (cflag&PARODD)
	227	flags \|= ODDP;
	228	else
	229	flags \|= EVENP;
	230	} else
	231	flags \|= EVENP \| ODDP;
	232	} else {
	233	if ((tp->t_flags&LITOUT) && !(oflag&OPOST))
	234	flags \|= LITOUT;
	235	if (tp->t_flags&PASS8)
	236	flags \|= PASS8;
	237	}
	238
	239	if ((lflag&ICANON) == 0) {
	240	/* fudge */
	241	if (iflag&IXON \|\| lflag&ISIG \|\| lflag&IEXTEN \|\| cflag&PARENB)
	242	flags \|= CBREAK;
	243	else
	244	flags \|= RAW;
	245	}
	246	if (oflag&OXTABS)
	247	flags \|= XTABS;
f73a43fc	248	if (lflag&ECHOE)
e39f9ea6	249	flags \|= CRTERA\|CRTBS;
f73a43fc	250	if (lflag&ECHOKE)
e39f9ea6	251	flags \|= CRTKIL\|CRTBS;
f73a43fc MT	252	if (lflag&ECHOPRT)
	253	flags \|= PRTERA;
	254	if (lflag&ECHOCTL)
	255	flags \|= CTLECH;
	256	if ((iflag&IXANY) == 0)
	257	flags \|= DECCTQ;
	258	flags \|= lflag&(ECHO\|MDMBUF\|TOSTOP\|FLUSHO\|NOHANG\|PENDIN\|NOFLSH);
e39f9ea6 MT	259	if (ttydebug)
e39f9ea6 MT	260	printf("getflags: %x\n", flags);
f73a43fc MT	261	return (flags);
	262	}
	263
	264	ttcompatsetflags(tp, t)
	265	register struct tty *tp;
	266	register struct termios *t;
	267	{
	268	register flags = tp->t_flags;
	269	register long iflag = t->c_iflag;
	270	register long oflag = t->c_oflag;
	271	register long lflag = t->c_lflag;
	272	register long cflag = t->c_cflag;
	273
	274	if (flags & RAW) {
	275	iflag &= IXOFF;
	276	oflag &= ~OPOST;
85a1af63	277	lflag &= ~(ECHOCTL\|ISIG\|ICANON\|IEXTEN);
f73a43fc	278	} else {
85a1af63	279	iflag \|= BRKINT\|IXON\|IMAXBEL;
f73a43fc	280	oflag \|= OPOST;
7fbb76da	281	lflag \|= ISIG\|IEXTEN\|ECHOCTL; /* XXX was echoctl on ? */
f73a43fc MT	282	if (flags & XTABS)
	283	oflag \|= OXTABS;
	284	else
	285	oflag &= ~OXTABS;
	286	if (flags & CBREAK)
	287	lflag &= ~ICANON;
	288	else
	289	lflag \|= ICANON;
	290	if (flags&CRMOD) {
	291	iflag \|= ICRNL;
	292	oflag \|= ONLCR;
	293	} else {
	294	iflag &= ~ICRNL;
	295	oflag &= ~ONLCR;
	296	}
	297	}
	298	if (flags&ECHO)
	299	lflag \|= ECHO;
	300	else
	301	lflag &= ~ECHO;
	302
	303	if (flags&(RAW\|LITOUT\|PASS8)) {
	304	cflag &= ~(CSIZE\|PARENB);
	305	cflag \|= CS8;
	306	if ((flags&(RAW\|PASS8)) == 0)
	307	iflag \|= ISTRIP;
7fbb76da MT	308	else
7fbb76da MT	309	iflag &= ~ISTRIP;
f73a43fc MT	310	} else {
	311	cflag &= ~CSIZE;
	312	cflag \|= CS7\|PARENB;
7fbb76da	313	iflag \|= ISTRIP;
f73a43fc MT	314	}
	315	if ((flags&(EVENP\|ODDP)) == EVENP) {
	316	iflag \|= INPCK;
	317	cflag &= ~PARODD;
	318	} else if ((flags&(EVENP\|ODDP)) == ODDP) {
	319	iflag \|= INPCK;
	320	cflag \|= PARODD;
	321	} else
	322	iflag &= ~INPCK;
	323	if (flags&LITOUT)
	324	oflag &= ~OPOST; /* move earlier ? */
	325	if (flags&TANDEM)
	326	iflag \|= IXOFF;
	327	else
	328	iflag &= ~IXOFF;
	329	t->c_iflag = iflag;
	330	t->c_oflag = oflag;
	331	t->c_lflag = lflag;
	332	t->c_cflag = cflag;
	333	}
	334
f73a43fc MT	335	ttcompatsetlflags(tp, t)
	336	register struct tty *tp;
	337	register struct termios *t;
	338	{
	339	register flags = tp->t_flags;
	340	register long iflag = t->c_iflag;
	341	register long oflag = t->c_oflag;
	342	register long lflag = t->c_lflag;
	343	register long cflag = t->c_cflag;
e39f9ea6	344
f73a43fc MT	345	if (flags&CRTERA)
	346	lflag \|= ECHOE;
	347	else
e39f9ea6	348	lflag &= ~ECHOE;
f73a43fc MT	349	if (flags&CRTKIL)
	350	lflag \|= ECHOKE;
	351	else
	352	lflag &= ~ECHOKE;
	353	if (flags&PRTERA)
	354	lflag \|= ECHOPRT;
	355	else
	356	lflag &= ~ECHOPRT;
	357	if (flags&CTLECH)
	358	lflag \|= ECHOCTL;
	359	else
	360	lflag &= ~ECHOCTL;
	361	if ((flags&DECCTQ) == 0)
	362	lflag \|= IXANY;
	363	else
	364	lflag &= ~IXANY;
f73a43fc MT	365	lflag &= ~(MDMBUF\|TOSTOP\|FLUSHO\|NOHANG\|PENDIN\|NOFLSH);
f73a43fc MT	366	lflag \|= flags&(MDMBUF\|TOSTOP\|FLUSHO\|NOHANG\|PENDIN\|NOFLSH);
f73a43fc MT	367	if (flags&(LITOUT\|PASS8)) {
	368	iflag &= ~ISTRIP;
	369	cflag &= ~(CSIZE\|PARENB);
	370	cflag \|= CS8;
	371	if (flags&LITOUT)
	372	oflag &= ~OPOST;
	373	if ((flags&(PASS8\|RAW)) == 0)
	374	iflag \|= ISTRIP;
	375	} else if ((flags&RAW) == 0) {
	376	cflag &= ~CSIZE;
	377	cflag \|= CS7\|PARENB;
	378	oflag \|= OPOST;
	379	}
	380	t->c_iflag = iflag;
	381	t->c_oflag = oflag;
	382	t->c_lflag = lflag;
	383	t->c_cflag = cflag;
	384	}
	385	#endif /* COMPAT_43 */