[unix-history] / .ref-BSD-4_3_Net_2 / usr / src / games / atc / input.c

/*-
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Ed James.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * Copyright (c) 1987 by Ed James, UC Berkeley.  All rights reserved.
 *
 * Copy permission is hereby granted provided that this notice is
 * retained on all partial or complete copies.
 *
 * For more info on this and all of my stuff, mail edjames@berkeley.edu.
 */

#ifndef lint
static char sccsid[] = "@(#)input.c	5.4 (Berkeley) 4/30/90";
#endif not lint

#include "include.h"
#include "pathnames.h"

#define MAXRULES	6
#define MAXDEPTH	15

#define RETTOKEN	'\n'
#ifdef SYSV
#define CRTOKEN		'\r'
#endif
#define REDRAWTOKEN	'\014'	/* CTRL(L) */
#define	SHELLTOKEN	'!'
#define HELPTOKEN	'?'
#define ALPHATOKEN	256
#define NUMTOKEN	257

typedef struct {
	int	token;
	int	to_state;
	char	*str;
	char	*(*func)();
} RULE;

typedef struct {
	int	num_rules;
	RULE	*rule;
} STATE;

typedef struct {
	char	str[20];
	int	state;
	int	rule;
	int	ch;
	int	pos;
} STACK;

#define T_RULE		stack[level].rule
#define T_STATE		stack[level].state
#define T_STR		stack[level].str
#define T_POS		stack[level].pos
#define	T_CH		stack[level].ch

#define NUMELS(a)	(sizeof (a) / sizeof (*(a)))

#define NUMSTATES	NUMELS(st)

char	*setplane(), *circle(), *left(), *right(), *Left(), *Right(), 
	*beacon(), *ex_it(), *climb(), *descend(), *setalt(), *setrelalt(), 
	*benum(), *to_dir(), *rel_dir(), *delayb(), *mark(), *unmark(),
	*airport(), *turn(), *ignore();

RULE	state0[] = {	{ ALPHATOKEN,	1,	"%c:",		setplane},
			{ RETTOKEN,	-1,	"",		NULL	},
#ifdef SYSV
			{ CRTOKEN,	-1,	"",		NULL	},
#endif
			{ HELPTOKEN,	12,	" [a-z]<ret>",	NULL	}},
	state1[] = {	{ 't',		2,	" turn",	turn	},	
			{ 'a',		3,	" altitude:",	NULL	},	
			{ 'c',		4,	" circle",	circle	},
			{ 'm',		7,	" mark",	mark	},
			{ 'u',		7,	" unmark",	unmark	},
			{ 'i',		7,	" ignore",	ignore	},
			{ HELPTOKEN,	12,	" tacmui",	NULL	}},
	state2[] = {	{ 'l',		6,	" left",	left	},	
			{ 'r',		6,	" right",	right	},	
			{ 'L',		4,	" left 90",	Left	},
			{ 'R',		4,	" right 90",	Right	},	
			{ 't',		11,	" towards",	NULL	},
			{ 'w',		4,	" to 0",	to_dir	},
			{ 'e',		4,	" to 45",	to_dir	},
			{ 'd',		4,	" to 90",	to_dir	},
			{ 'c',		4,	" to 135",	to_dir	},
			{ 'x',		4,	" to 180",	to_dir	},
			{ 'z',		4,	" to 225",	to_dir	},
			{ 'a',		4,	" to 270",	to_dir	},
			{ 'q',		4,	" to 315",	to_dir	},
			{ HELPTOKEN,	12,	" lrLRt<dir>",	NULL	}},
	state3[] = {	{ '+',		10,	" climb",	climb	},	
			{ 'c',		10,	" climb",	climb	},	
			{ '-',		10,	" descend",	descend	},	
			{ 'd',		10,	" descend",	descend	},	
			{ NUMTOKEN,	7,	" %c000 feet",	setalt	},
			{ HELPTOKEN,	12,	" +-cd[0-9]",	NULL	}},
	state4[] = {	{ '@',		9,	" at",		NULL	},	
			{ 'a',		9,	" at",		NULL	},	
			{ RETTOKEN,	-1,	"",		NULL	},
#ifdef SYSV
			{ CRTOKEN,	-1,	"",		NULL	},
#endif
			{ HELPTOKEN,	12,	" @a<ret>",	NULL	}},
	state5[] = {	{ NUMTOKEN,	7,	"%c",		delayb	},
			{ HELPTOKEN,	12,	" [0-9]",	NULL	}},
	state6[] = {	{ '@',		9,	" at",		NULL	},
			{ 'a',		9,	" at",		NULL	},
			{ 'w',		4,	" 0",		rel_dir	},
			{ 'e',		4,	" 45",		rel_dir	},
			{ 'd',		4,	" 90",		rel_dir	},
			{ 'c',		4,	" 135",		rel_dir	},
			{ 'x',		4,	" 180",		rel_dir	},
			{ 'z',		4,	" 225",		rel_dir	},
			{ 'a',		4,	" 270",		rel_dir	},
			{ 'q',		4,	" 315",		rel_dir	},
			{ RETTOKEN,	-1,	"",		NULL	},	
#ifdef SYSV
			{ CRTOKEN,	-1,	"",		NULL	},	
#endif
			{ HELPTOKEN,	12,	" @a<dir><ret>",NULL	}},
	state7[] = {	{ RETTOKEN,	-1,	"",		NULL	},
#ifdef SYSV
	            	{ CRTOKEN,	-1,	"",		NULL	},
#endif
			{ HELPTOKEN,	12,	" <ret>",	NULL	}},
	state8[] = {	{ NUMTOKEN,	4,	"%c",		benum	},
			{ HELPTOKEN,	12,	" [0-9]",	NULL	}},
	state9[] = {	{ 'b',		5,	" beacon #",	NULL	},
			{ '*',		5,	" beacon #",	NULL	},
			{ HELPTOKEN,	12,	" b*",		NULL	}},
	state10[] = {	{ NUMTOKEN,	7,	" %c000 ft",	setrelalt},
			{ HELPTOKEN,	12,	" [0-9]",	NULL	}},
	state11[] = {	{ 'b',		8,	" beacon #",	beacon	},	
			{ '*',		8,	" beacon #",	beacon	},
			{ 'e',		8,	" exit #",	ex_it	},
			{ 'a',		8,	" airport #",	airport	},
			{ HELPTOKEN,	12,	" b*ea",	NULL	}},
	state12[] = {	{ -1,		-1,	"",		NULL	}};

#define DEF_STATE(s)	{ NUMELS(s),	(s)	}

STATE	st[] = {
	DEF_STATE(state0), DEF_STATE(state1), DEF_STATE(state2),
	DEF_STATE(state3), DEF_STATE(state4), DEF_STATE(state5),
	DEF_STATE(state6), DEF_STATE(state7), DEF_STATE(state8),
	DEF_STATE(state9), DEF_STATE(state10), DEF_STATE(state11),
	DEF_STATE(state12)
};

PLANE	p;
STACK	stack[MAXDEPTH];
int	level;
int	tval;
int	dest_type, dest_no, dir;

pop()
{
	if (level == 0)
		return (-1);
	level--;

	ioclrtoeol(T_POS);

	strcpy(T_STR, "");
	T_RULE = -1;
	T_CH = -1;
	return (0);
}

rezero()
{
	iomove(0);

	level = 0;
	T_STATE = 0;
	T_RULE = -1;
	T_CH = -1;
	T_POS = 0;
	strcpy(T_STR, "");
}

push(ruleno, ch)
{
	int	newstate, newpos;

	(void)sprintf(T_STR, st[T_STATE].rule[ruleno].str, tval);
	T_RULE = ruleno;
	T_CH = ch;
	newstate = st[T_STATE].rule[ruleno].to_state;
	newpos = T_POS + strlen(T_STR);

	ioaddstr(T_POS, T_STR);

	if (level == 0)
		ioclrtobot();
	level++;
	T_STATE = newstate;
	T_POS = newpos;
	T_RULE = -1;
	strcpy(T_STR, "");
}

getcommand()
{
	int	c, i, done;
	char	*s, *(*func)();
	PLANE	*pp;

	rezero();

	do {
		c = gettoken();
		if (c == tty_new.sg_erase) {
			if (pop() < 0)
				noise();
		} else if (c == tty_new.sg_kill) {
			while (pop() >= 0)
				;
		} else {
			done = 0;
			for (i = 0; i < st[T_STATE].num_rules; i++) {
				if (st[T_STATE].rule[i].token == c ||
				    st[T_STATE].rule[i].token == tval) {
					push(i, (c >= ALPHATOKEN) ? tval : c);
					done = 1;
					break;
				}
			}
			if (!done)
				noise();
		}
	} while (T_STATE != -1);

	if (level == 1)
		return (1);	/* forced update */

	dest_type = T_NODEST;
	
	for (i = 0; i < level; i++) {
		func = st[stack[i].state].rule[stack[i].rule].func;
		if (func != NULL)
			if ((s = (*func)(stack[i].ch)) != NULL) {
				ioerror(stack[i].pos, strlen(stack[i].str), s);
				return (-1);
			}
	}

	pp = findplane(p.plane_no);
	if (pp->new_altitude != p.new_altitude)
		pp->new_altitude = p.new_altitude;
	else if (pp->status != p.status)
		pp->status = p.status;
	else {
		pp->new_dir = p.new_dir;
		pp->delayd = p.delayd;
		pp->delayd_no = p.delayd_no;
	}
	return (0);
}

noise()
{
	putchar('\07');
	fflush(stdout);
}

gettoken()
{
	while ((tval = getAChar()) == REDRAWTOKEN || tval == SHELLTOKEN)
	{
		if (tval == SHELLTOKEN)
		{
#ifdef BSD
			struct itimerval	itv;
			itv.it_value.tv_sec = 0;
			itv.it_value.tv_usec = 0;
			setitimer(ITIMER_REAL, &itv, NULL);
#endif
#ifdef SYSV
			int aval;
			aval = alarm(0);
#endif
			if (fork() == 0)	/* child */
			{
				char *shell, *base, *getenv(), *strrchr();

				setuid(getuid()); /* turn off setuid bit */
				done_screen();

						 /* run user's favorite shell */
				if ((shell = getenv("SHELL")) != NULL)
				{
					base = strrchr(shell, '/');
					if (base == NULL)
						base = shell;
					else
						base++;
					execl(shell, base, 0);
				}
				else
					execl(_PATH_BSHELL, "sh", 0);

				exit(0);	/* oops */
			}

			wait(0);
#ifdef BSD
			ioctl(fileno(stdin), TIOCSETP, &tty_new);
			itv.it_value.tv_sec = 0;
			itv.it_value.tv_usec = 1;
			itv.it_interval.tv_sec = sp->update_secs;
			itv.it_interval.tv_usec = 0;
			setitimer(ITIMER_REAL, &itv, NULL);
#endif
#ifdef SYSV
			ioctl(fileno(stdin), TCSETAW, &tty_new);
			alarm(aval);
#endif
		}
		redraw();
	}

	if (isdigit(tval))
		return (NUMTOKEN);
	else if (isalpha(tval))
		return (ALPHATOKEN);
	else
		return (tval);
}

char	*
setplane(c)
{
	PLANE	*pp;

	pp = findplane(number(c));
	if (pp == NULL)
		return ("Unknown Plane");
	bcopy(pp, &p, sizeof (p));
	p.delayd = 0;
	return (NULL);
}

char	*
turn(c)
{
	if (p.altitude == 0)
		return ("Planes at airports may not change direction");
	return (NULL);
}

char	*
circle(c)
{
	if (p.altitude == 0)
		return ("Planes cannot circle on the ground");
	p.new_dir = MAXDIR;
	return (NULL);
}

char	*
left(c)
{
	dir = D_LEFT;
	p.new_dir = p.dir - 1;
	if (p.new_dir < 0)
		p.new_dir += MAXDIR;
	return (NULL);
}

char	*
right(c)
{
	dir = D_RIGHT;
	p.new_dir = p.dir + 1;
	if (p.new_dir > MAXDIR)
		p.new_dir -= MAXDIR;
	return (NULL);
}

char	*
Left(c)
{
	p.new_dir = p.dir - 2;
	if (p.new_dir < 0)
		p.new_dir += MAXDIR;
	return (NULL);
}

char	*
Right(c)
{
	p.new_dir = p.dir + 2;
	if (p.new_dir > MAXDIR)
		p.new_dir -= MAXDIR;
	return (NULL);
}

char	*
delayb(c)
{
	int	xdiff, ydiff;

	c -= '0';

	if (c >= sp->num_beacons)
		return ("Unknown beacon");
	xdiff = sp->beacon[c].x - p.xpos;
	xdiff = SGN(xdiff);
	ydiff = sp->beacon[c].y - p.ypos;
	ydiff = SGN(ydiff);
	if (xdiff != displacement[p.dir].dx || ydiff != displacement[p.dir].dy)
		return ("Beacon is not in flight path");
	p.delayd = 1;
	p.delayd_no = c;

	if (dest_type != T_NODEST) {
		switch (dest_type) {
		case T_BEACON:
			xdiff = sp->beacon[dest_no].x - sp->beacon[c].x;
			ydiff = sp->beacon[dest_no].y - sp->beacon[c].y;
			break;
		case T_EXIT:
			xdiff = sp->exit[dest_no].x - sp->beacon[c].x;
			ydiff = sp->exit[dest_no].y - sp->beacon[c].y;
			break;
		case T_AIRPORT:
			xdiff = sp->airport[dest_no].x - sp->beacon[c].x;
			ydiff = sp->airport[dest_no].y - sp->beacon[c].y;
			break;
		default:
			return ("Bad case in delayb!  Get help!");
			break;
		}
		if (xdiff == 0 && ydiff == 0)
			return ("Would already be there");
		p.new_dir = DIR_FROM_DXDY(xdiff, ydiff);
		if (p.new_dir == p.dir)
			return ("Already going in that direction");
	}
	return (NULL);
}

char	*
beacon(c)
{
	dest_type = T_BEACON;
	return (NULL);
}

char	*
ex_it(c)
{
	dest_type = T_EXIT;
	return (NULL);
}

char	*
airport(c)
{
	dest_type = T_AIRPORT;
	return (NULL);
}

char	*
climb(c)
{
	dir = D_UP;
	return (NULL);
}

char	*
descend(c)
{
	dir = D_DOWN;
	return (NULL);
}

char	*
setalt(c)
{
	if ((p.altitude == c - '0') && (p.new_altitude == p.altitude))
		return ("Already at that altitude");
	p.new_altitude = c - '0';
	return (NULL);
}

char	*
setrelalt(c)
{
	if (c == 0)
		return ("altitude not changed");

	switch (dir) {
	case D_UP:
		p.new_altitude = p.altitude + c - '0';
		break;
	case D_DOWN:
		p.new_altitude = p.altitude - (c - '0');
		break;
	default:
		return ("Unknown case in setrelalt!  Get help!");
		break;
	}
	if (p.new_altitude < 0)
		return ("Altitude would be too low");
	else if (p.new_altitude > 9)
		return ("Altitude would be too high");
	return (NULL);
}

char	*
benum(c)
{
	dest_no = c -= '0';

	switch (dest_type) {
	case T_BEACON:
		if (c >= sp->num_beacons)
			return ("Unknown beacon");
		p.new_dir = DIR_FROM_DXDY(sp->beacon[c].x - p.xpos,
			sp->beacon[c].y - p.ypos);
		break;
	case T_EXIT:
		if (c >= sp->num_exits)
			return ("Unknown exit");
		p.new_dir = DIR_FROM_DXDY(sp->exit[c].x - p.xpos,
			sp->exit[c].y - p.ypos);
		break;
	case T_AIRPORT:
		if (c >= sp->num_airports)
			return ("Unknown airport");
		p.new_dir = DIR_FROM_DXDY(sp->airport[c].x - p.xpos,
			sp->airport[c].y - p.ypos);
		break;
	default:
		return ("Unknown case in benum!  Get help!");
		break;
	}
	return (NULL);
}

char	*
to_dir(c)
{
	p.new_dir = dir_no(c);
	return (NULL);
}

char	*
rel_dir(c)
{
	int	angle;

	angle = dir_no(c);
	switch (dir) {
	case D_LEFT:
		p.new_dir = p.dir - angle;
		if (p.new_dir < 0)
			p.new_dir += MAXDIR;
		break;
	case D_RIGHT:
		p.new_dir = p.dir + angle;
		if (p.new_dir >= MAXDIR)
			p.new_dir -= MAXDIR;
		break;
	default:
		return ("Bizarre direction in rel_dir!  Get help!");
		break;
	}
	return (NULL);
}

char	*
mark(c)
{
	if (p.altitude == 0)
		return ("Cannot mark planes on the ground");
	if (p.status == S_MARKED)
		return ("Already marked");
	p.status = S_MARKED;
	return (NULL);
}

char	*
unmark(c)
{
	if (p.altitude == 0)
		return ("Cannot unmark planes on the ground");
	if (p.status == S_UNMARKED)
		return ("Already unmarked");
	p.status = S_UNMARKED;
	return (NULL);
}

char	*
ignore(c)
{
	if (p.altitude == 0)
		return ("Cannot ignore planes on the ground");
	if (p.status == S_IGNORED)
		return ("Already ignored");
	p.status = S_IGNORED;
	return (NULL);
}

dir_no(ch)
	char	ch;
{
	int	dir;

	switch (ch) {
	case 'w':	dir = 0;	break;
	case 'e':	dir = 1;	break;
	case 'd':	dir = 2;	break;
	case 'c':	dir = 3;	break;
	case 'x':	dir = 4;	break;
	case 'z':	dir = 5;	break;
	case 'a':	dir = 6;	break;
	case 'q':	dir = 7;	break;
	default:
		fprintf(stderr, "bad character in dir_no\n");
		break;
	}
	return (dir);
}
Commit	Line	Data
e04f5cf8 KB	1	/*-
	2	* Copyright (c) 1990 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* This code is derived from software contributed to Berkeley by
	6	* Ed James.
	7	*
af359dea C	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3. All advertising materials mentioning features or use of this software
	17	* must display the following acknowledgement:
	18	* This product includes software developed by the University of
	19	* California, Berkeley and its contributors.
	20	* 4. Neither the name of the University nor the names of its contributors
	21	* may be used to endorse or promote products derived from this software
	22	* without specific prior written permission.
	23	*
	24	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	25	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	27	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	29	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	30	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	31	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	32	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	33	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	34	* SUCH DAMAGE.
e04f5cf8 KB	35	*/
e04f5cf8 KB	36
864befdb KB	37	/*
	38	* Copyright (c) 1987 by Ed James, UC Berkeley. All rights reserved.
	39	*
	40	* Copy permission is hereby granted provided that this notice is
	41	* retained on all partial or complete copies.
	42	*
	43	* For more info on this and all of my stuff, mail edjames@berkeley.edu.
	44	*/
	45
	46	#ifndef lint
1c15e888	47	static char sccsid[] = "@(#)input.c 5.4 (Berkeley) 4/30/90";
864befdb KB	48	#endif not lint
	49
	50	#include "include.h"
7abf8d65	51	#include "pathnames.h"
864befdb KB	52
	53	#define MAXRULES 6
	54	#define MAXDEPTH 15
	55
	56	#define RETTOKEN '\n'
	57	#ifdef SYSV
	58	#define CRTOKEN '\r'
	59	#endif
	60	#define REDRAWTOKEN '\014' /* CTRL(L) */
	61	#define SHELLTOKEN '!'
	62	#define HELPTOKEN '?'
	63	#define ALPHATOKEN 256
	64	#define NUMTOKEN 257
	65
	66	typedef struct {
	67	int token;
	68	int to_state;
	69	char *str;
	70	char (func)();
	71	} RULE;
	72
	73	typedef struct {
	74	int num_rules;
	75	RULE *rule;
	76	} STATE;
	77
	78	typedef struct {
	79	char str[20];
	80	int state;
	81	int rule;
	82	int ch;
	83	int pos;
	84	} STACK;
	85
	86	#define T_RULE stack[level].rule
	87	#define T_STATE stack[level].state
	88	#define T_STR stack[level].str
	89	#define T_POS stack[level].pos
	90	#define T_CH stack[level].ch
	91
	92	#define NUMELS(a) (sizeof (a) / sizeof (*(a)))
	93
	94	#define NUMSTATES NUMELS(st)
	95
	96	char setplane(), circle(), left(), right(), Left(), Right(),
	97	beacon(), ex_it(), climb(), descend(), setalt(), setrelalt(),
	98	benum(), to_dir(), rel_dir(), delayb(), mark(), unmark(),
	99	airport(), turn(), *ignore();
	100
	101	RULE state0[] = { { ALPHATOKEN, 1, "%c:", setplane},
	102	{ RETTOKEN, -1, "", NULL },
	103	#ifdef SYSV
	104	{ CRTOKEN, -1, "", NULL },
	105	#endif
	106	{ HELPTOKEN, 12, " [a-z]<ret>", NULL }},
	107	state1[] = { { 't', 2, " turn", turn },
	108	{ 'a', 3, " altitude:", NULL },
	109	{ 'c', 4, " circle", circle },
	110	{ 'm', 7, " mark", mark },
	111	{ 'u', 7, " unmark", unmark },
	112	{ 'i', 7, " ignore", ignore },
	113	{ HELPTOKEN, 12, " tacmui", NULL }},
	114	state2[] = { { 'l', 6, " left", left },
	115	{ 'r', 6, " right", right },
116	{ 'L', 4, " left 90", Left },
117	{ 'R', 4, " right 90", Right },
118	{ 't', 11, " towards", NULL },
119	{ 'w', 4, " to 0", to_dir },
120	{ 'e', 4, " to 45", to_dir },
121	{ 'd', 4, " to 90", to_dir },
122	{ 'c', 4, " to 135", to_dir },
123	{ 'x', 4, " to 180", to_dir },
124	{ 'z', 4, " to 225", to_dir },
125	{ 'a', 4, " to 270", to_dir },
126	{ 'q', 4, " to 315", to_dir },
127	{ HELPTOKEN, 12, " lrLRt<dir>", NULL }},
128	state3[] = { { '+', 10, " climb", climb },
129	{ 'c', 10, " climb", climb },
130	{ '-', 10, " descend", descend },
131	{ 'd', 10, " descend", descend },
132	{ NUMTOKEN, 7, " %c000 feet", setalt },
133	{ HELPTOKEN, 12, " +-cd[0-9]", NULL }},
134	state4[] = { { '@', 9, " at", NULL },
135	{ 'a', 9, " at", NULL },
136	{ RETTOKEN, -1, "", NULL },
137	#ifdef SYSV
138	{ CRTOKEN, -1, "", NULL },
139	#endif
140	{ HELPTOKEN, 12, " @a<ret>", NULL }},
141	state5[] = { { NUMTOKEN, 7, "%c", delayb },
142	{ HELPTOKEN, 12, " [0-9]", NULL }},
143	state6[] = { { '@', 9, " at", NULL },
144	{ 'a', 9, " at", NULL },
145	{ 'w', 4, " 0", rel_dir },
146	{ 'e', 4, " 45", rel_dir },
147	{ 'd', 4, " 90", rel_dir },
148	{ 'c', 4, " 135", rel_dir },
149	{ 'x', 4, " 180", rel_dir },
150	{ 'z', 4, " 225", rel_dir },
151	{ 'a', 4, " 270", rel_dir },
152	{ 'q', 4, " 315", rel_dir },
153	{ RETTOKEN, -1, "", NULL },
154	#ifdef SYSV
155	{ CRTOKEN, -1, "", NULL },
156	#endif
157	{ HELPTOKEN, 12, " @a<dir><ret>",NULL }},
158	state7[] = { { RETTOKEN, -1, "", NULL },
159	#ifdef SYSV
160	{ CRTOKEN, -1, "", NULL },
161	#endif
162	{ HELPTOKEN, 12, " <ret>", NULL }},
163	state8[] = { { NUMTOKEN, 4, "%c", benum },
164	{ HELPTOKEN, 12, " [0-9]", NULL }},
165	state9[] = { { 'b', 5, " beacon #", NULL },
166	{ '*', 5, " beacon #", NULL },
167	{ HELPTOKEN, 12, " b*", NULL }},
168	state10[] = { { NUMTOKEN, 7, " %c000 ft", setrelalt},
169	{ HELPTOKEN, 12, " [0-9]", NULL }},
170	state11[] = { { 'b', 8, " beacon #", beacon },
171	{ '*', 8, " beacon #", beacon },
172	{ 'e', 8, " exit #", ex_it },
173	{ 'a', 8, " airport #", airport },
174	{ HELPTOKEN, 12, " b*ea", NULL }},
175	state12[] = { { -1, -1, "", NULL }};
176
177	#define DEF_STATE(s) { NUMELS(s), (s) }
178
179	STATE st[] = {
180	DEF_STATE(state0), DEF_STATE(state1), DEF_STATE(state2),
181	DEF_STATE(state3), DEF_STATE(state4), DEF_STATE(state5),
182	DEF_STATE(state6), DEF_STATE(state7), DEF_STATE(state8),
183	DEF_STATE(state9), DEF_STATE(state10), DEF_STATE(state11),
184	DEF_STATE(state12)
185	};
186
187	PLANE p;
188	STACK stack[MAXDEPTH];
189	int level;
190	int tval;
191	int dest_type, dest_no, dir;
192
193	pop()
194	{
195	if (level == 0)
196	return (-1);
197	level--;
198
199	ioclrtoeol(T_POS);
200
201	strcpy(T_STR, "");
202	T_RULE = -1;
203	T_CH = -1;
204	return (0);
205	}
206
207	rezero()
208	{
209	iomove(0);
210
211	level = 0;
212	T_STATE = 0;
213	T_RULE = -1;
214	T_CH = -1;
215	T_POS = 0;
216	strcpy(T_STR, "");
217	}
218
219	push(ruleno, ch)
220	{
221	int newstate, newpos;
222
e7c6fb2c	223	(void)sprintf(T_STR, st[T_STATE].rule[ruleno].str, tval);
864befdb KB	224	T_RULE = ruleno;
	225	T_CH = ch;
	226	newstate = st[T_STATE].rule[ruleno].to_state;
	227	newpos = T_POS + strlen(T_STR);
	228
	229	ioaddstr(T_POS, T_STR);
	230
	231	if (level == 0)
	232	ioclrtobot();
	233	level++;
	234	T_STATE = newstate;
	235	T_POS = newpos;
	236	T_RULE = -1;
	237	strcpy(T_STR, "");
	238	}
	239
	240	getcommand()
	241	{
	242	int c, i, done;
	243	char s, (*func)();
	244	PLANE *pp;
	245
	246	rezero();
	247
	248	do {
	249	c = gettoken();
	250	if (c == tty_new.sg_erase) {
	251	if (pop() < 0)
	252	noise();
	253	} else if (c == tty_new.sg_kill) {
	254	while (pop() >= 0)
	255	;
	256	} else {
	257	done = 0;
	258	for (i = 0; i < st[T_STATE].num_rules; i++) {
	259	if (st[T_STATE].rule[i].token == c \|\|
	260	st[T_STATE].rule[i].token == tval) {
	261	push(i, (c >= ALPHATOKEN) ? tval : c);
	262	done = 1;
	263	break;
	264	}
	265	}
	266	if (!done)
	267	noise();
	268	}
	269	} while (T_STATE != -1);
	270
	271	if (level == 1)
	272	return (1); /* forced update */
	273
	274	dest_type = T_NODEST;
	275
	276	for (i = 0; i < level; i++) {
	277	func = st[stack[i].state].rule[stack[i].rule].func;
	278	if (func != NULL)
	279	if ((s = (*func)(stack[i].ch)) != NULL) {
	280	ioerror(stack[i].pos, strlen(stack[i].str), s);
	281	return (-1);
	282	}
	283	}
	284
	285	pp = findplane(p.plane_no);
	286	if (pp->new_altitude != p.new_altitude)
	287	pp->new_altitude = p.new_altitude;
288	else if (pp->status != p.status)
289	pp->status = p.status;
290	else {
291	pp->new_dir = p.new_dir;
292	pp->delayd = p.delayd;
293	pp->delayd_no = p.delayd_no;
294	}
295	return (0);
296	}
297
298	noise()
299	{
300	putchar('\07');
301	fflush(stdout);
302	}
303
304	gettoken()
305	{
306	while ((tval = getAChar()) == REDRAWTOKEN \|\| tval == SHELLTOKEN)
307	{
308	if (tval == SHELLTOKEN)
309	{
310	#ifdef BSD
311	struct itimerval itv;
312	itv.it_value.tv_sec = 0;
313	itv.it_value.tv_usec = 0;
314	setitimer(ITIMER_REAL, &itv, NULL);
315	#endif
316	#ifdef SYSV
317	int aval;
318	aval = alarm(0);
319	#endif
320	if (fork() == 0) /* child */
321	{
322	char shell, base, getenv(), strrchr();
323
324	setuid(getuid()); /* turn off setuid bit */
325	done_screen();
326
327	/* run user's favorite shell */
328	if ((shell = getenv("SHELL")) != NULL)
329	{
330	base = strrchr(shell, '/');
331	if (base == NULL)
332	base = shell;
333	else
334	base++;
335	execl(shell, base, 0);
336	}
337	else
7abf8d65	338	execl(_PATH_BSHELL, "sh", 0);
864befdb KB	339
	340	exit(0); /* oops */
	341	}
	342
	343	wait(0);
	344	#ifdef BSD
	345	ioctl(fileno(stdin), TIOCSETP, &tty_new);
	346	itv.it_value.tv_sec = 0;
	347	itv.it_value.tv_usec = 1;
	348	itv.it_interval.tv_sec = sp->update_secs;
	349	itv.it_interval.tv_usec = 0;
	350	setitimer(ITIMER_REAL, &itv, NULL);
	351	#endif
	352	#ifdef SYSV
	353	ioctl(fileno(stdin), TCSETAW, &tty_new);
	354	alarm(aval);
	355	#endif
	356	}
	357	redraw();
	358	}
	359
	360	if (isdigit(tval))
	361	return (NUMTOKEN);
	362	else if (isalpha(tval))
	363	return (ALPHATOKEN);
	364	else
	365	return (tval);
	366	}
	367
	368	char *
	369	setplane(c)
	370	{
	371	PLANE *pp;
	372
	373	pp = findplane(number(c));
	374	if (pp == NULL)
	375	return ("Unknown Plane");
	376	bcopy(pp, &p, sizeof (p));
	377	p.delayd = 0;
	378	return (NULL);
	379	}
	380
	381	char *
	382	turn(c)
	383	{
	384	if (p.altitude == 0)
	385	return ("Planes at airports may not change direction");
	386	return (NULL);
	387	}
	388
	389	char *
	390	circle(c)
	391	{
	392	if (p.altitude == 0)
	393	return ("Planes cannot circle on the ground");
	394	p.new_dir = MAXDIR;
	395	return (NULL);
	396	}
	397
	398	char *
	399	left(c)
	400	{
	401	dir = D_LEFT;
	402	p.new_dir = p.dir - 1;
403	if (p.new_dir < 0)
404	p.new_dir += MAXDIR;
405	return (NULL);
406	}
407
408	char *
409	right(c)
410	{
411	dir = D_RIGHT;
412	p.new_dir = p.dir + 1;
413	if (p.new_dir > MAXDIR)
414	p.new_dir -= MAXDIR;
415	return (NULL);
416	}
417
418	char *
419	Left(c)
420	{
421	p.new_dir = p.dir - 2;
422	if (p.new_dir < 0)
423	p.new_dir += MAXDIR;
424	return (NULL);
425	}
426
427	char *
428	Right(c)
429	{
430	p.new_dir = p.dir + 2;
431	if (p.new_dir > MAXDIR)
432	p.new_dir -= MAXDIR;
433	return (NULL);
434	}
435
436	char *
437	delayb(c)
438	{
439	int xdiff, ydiff;
440
441	c -= '0';
442
443	if (c >= sp->num_beacons)
444	return ("Unknown beacon");
445	xdiff = sp->beacon[c].x - p.xpos;
446	xdiff = SGN(xdiff);
447	ydiff = sp->beacon[c].y - p.ypos;
448	ydiff = SGN(ydiff);
449	if (xdiff != displacement[p.dir].dx \|\| ydiff != displacement[p.dir].dy)
450	return ("Beacon is not in flight path");
451	p.delayd = 1;
452	p.delayd_no = c;
453
454	if (dest_type != T_NODEST) {
455	switch (dest_type) {
456	case T_BEACON:
457	xdiff = sp->beacon[dest_no].x - sp->beacon[c].x;
458	ydiff = sp->beacon[dest_no].y - sp->beacon[c].y;
459	break;
460	case T_EXIT:
461	xdiff = sp->exit[dest_no].x - sp->beacon[c].x;
462	ydiff = sp->exit[dest_no].y - sp->beacon[c].y;
463	break;
464	case T_AIRPORT:
465	xdiff = sp->airport[dest_no].x - sp->beacon[c].x;
466	ydiff = sp->airport[dest_no].y - sp->beacon[c].y;
467	break;
468	default:
469	return ("Bad case in delayb! Get help!");
470	break;
471	}
472	if (xdiff == 0 && ydiff == 0)
473	return ("Would already be there");
474	p.new_dir = DIR_FROM_DXDY(xdiff, ydiff);
475	if (p.new_dir == p.dir)
476	return ("Already going in that direction");
477	}
478	return (NULL);
479	}
480
481	char *
482	beacon(c)
483	{
484	dest_type = T_BEACON;
485	return (NULL);
486	}
487
488	char *
489	ex_it(c)
490	{
491	dest_type = T_EXIT;
492	return (NULL);
493	}
494
495	char *
496	airport(c)
497	{
498	dest_type = T_AIRPORT;
499	return (NULL);
500	}
501
502	char *
503	climb(c)
504	{
505	dir = D_UP;
506	return (NULL);
507	}
508
509	char *
510	descend(c)
511	{
512	dir = D_DOWN;
513	return (NULL);
514	}
515
516	char *
517	setalt(c)
518	{
519	if ((p.altitude == c - '0') && (p.new_altitude == p.altitude))
520	return ("Already at that altitude");
521	p.new_altitude = c - '0';
522	return (NULL);
523	}
524
525	char *
526	setrelalt(c)
527	{
528	if (c == 0)
529	return ("altitude not changed");
530
531	switch (dir) {
532	case D_UP:
533	p.new_altitude = p.altitude + c - '0';
534	break;
535	case D_DOWN:
536	p.new_altitude = p.altitude - (c - '0');
537	break;
538	default:
539	return ("Unknown case in setrelalt! Get help!");
540	break;
541	}
542	if (p.new_altitude < 0)
543	return ("Altitude would be too low");
544	else if (p.new_altitude > 9)
545	return ("Altitude would be too high");
546	return (NULL);
547	}
548
549	char *
550	benum(c)
551	{
552	dest_no = c -= '0';
553
554	switch (dest_type) {
555	case T_BEACON:
556	if (c >= sp->num_beacons)
557	return ("Unknown beacon");
558	p.new_dir = DIR_FROM_DXDY(sp->beacon[c].x - p.xpos,
559	sp->beacon[c].y - p.ypos);
560	break;
561	case T_EXIT:
562	if (c >= sp->num_exits)
563	return ("Unknown exit");
564	p.new_dir = DIR_FROM_DXDY(sp->exit[c].x - p.xpos,
565	sp->exit[c].y - p.ypos);
566	break;
567	case T_AIRPORT:
568	if (c >= sp->num_airports)
569	return ("Unknown airport");
570	p.new_dir = DIR_FROM_DXDY(sp->airport[c].x - p.xpos,
571	sp->airport[c].y - p.ypos);
572	break;
573	default:
574	return ("Unknown case in benum! Get help!");
575	break;
576	}
577	return (NULL);
578	}
579
580	char *
581	to_dir(c)
582	{
583	p.new_dir = dir_no(c);
584	return (NULL);
585	}
586
587	char *
588	rel_dir(c)
589	{
590	int angle;
591
592	angle = dir_no(c);
593	switch (dir) {
594	case D_LEFT:
595	p.new_dir = p.dir - angle;
596	if (p.new_dir < 0)
597	p.new_dir += MAXDIR;
598	break;
599	case D_RIGHT:
600	p.new_dir = p.dir + angle;
601	if (p.new_dir >= MAXDIR)
602	p.new_dir -= MAXDIR;
603	break;
604	default:
605	return ("Bizarre direction in rel_dir! Get help!");
606	break;
607	}
608	return (NULL);
609	}
610
611	char *
612	mark(c)
613	{
614	if (p.altitude == 0)
615	return ("Cannot mark planes on the ground");
616	if (p.status == S_MARKED)
617	return ("Already marked");
618	p.status = S_MARKED;
619	return (NULL);
620	}
621
622	char *
623	unmark(c)
624	{
625	if (p.altitude == 0)
626	return ("Cannot unmark planes on the ground");
627	if (p.status == S_UNMARKED)
628	return ("Already unmarked");
629	p.status = S_UNMARKED;
630	return (NULL);
631	}
632
633	char *
634	ignore(c)
635	{
636	if (p.altitude == 0)
637	return ("Cannot ignore planes on the ground");
638	if (p.status == S_IGNORED)
639	return ("Already ignored");
640	p.status = S_IGNORED;
641	return (NULL);
642	}
643
644	dir_no(ch)
645	char ch;
646	{
647	int dir;
648
649	switch (ch) {
650	case 'w': dir = 0; break;
651	case 'e': dir = 1; break;
652	case 'd': dir = 2; break;
653	case 'c': dir = 3; break;
654	case 'x': dir = 4; break;
655	case 'z': dir = 5; break;
656	case 'a': dir = 6; break;
657	case 'q': dir = 7; break;
658	default:
659	fprintf(stderr, "bad character in dir_no\n");
660	break;
661	}
662	return (dir);
663	}