input.c

/*	$NetBSD: input.c,v 1.30 2021/05/02 12:50:43 rillig Exp $	*/

/*-
 * Copyright (c) 1990, 1993
 *	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. 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.
 */

#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)input.c	8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: input.c,v 1.30 2021/05/02 12:50:43 rillig Exp $");
#endif
#endif /* not lint */

#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <termios.h>
#include <ctype.h>
#include <assert.h>
#include <math.h>

#include "pathnames.h"
#include "def.h"
#include "struct.h"
#include "extern.h"
#include "tunable.h"

static void rezero(void);
static void noise(void);
static int gettoken(void);
static const char *setplane(int);
static const char *turn(int);
static const char *circle(int);
static const char *left(int);
static const char *right(int);
static const char *Left(int);
static const char *Right(int);
static const char *delayb(int);
static const char *beacon(int);
static const char *ex_it(int);
static const char *airport(int);
static const char *climb(int);
static const char *descend(int);
static const char *setalt(int);
static const char *setrelalt(int);
static const char *benum(int);
static const char *to_dir(int);
static const char *rel_dir(int);
static const char *mark(int);
static const char *unmark(int);
static const char *ignore(int);



#define MAXRULES	6
#define MAXDEPTH	15

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

typedef struct {
	int	token;
	int	to_state;
	const char	*str;
	const char	*(*func)(int);
} 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)

static
RULE	state0[] = {	{ ALPHATOKEN,	1,	"%c:",		setplane},
			{ RETTOKEN,	-1,	"",		NULL	},
			{ 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	},
			{ 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	},
			{ HELPTOKEN,	12,	" @a<dir><ret>",NULL	}},
	state7[] = {	{ RETTOKEN,	-1,	"",		NULL	},
			{ 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)	}

static 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)
};

static PLANE p;
static STACK stack[MAXDEPTH];
static int level;
static int tval;
static int dir;
static enum places dest_type;
static unsigned dest_no;

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

	ioclrtoeol(T_POS);

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

static void
rezero(void)
{
	iomove(0);

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

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

	assert(level < (MAXDEPTH - 1));
	(void)snprintf(T_STR, sizeof(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;
	(void)strcpy(T_STR, "");
}

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

	rezero();

	do {
		c = gettoken();
		if (c == tty_new.c_cc[VERASE]) {
			if (pop() < 0)
				noise();
		} else if (c == tty_new.c_cc[VKILL]) {
			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,
				    (int)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);
}

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

static int
gettoken(void)
{
	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;
			(void)setitimer(ITIMER_REAL, &itv, NULL);
#endif
#ifdef SYSV
			int aval;
			aval = alarm(0);
#endif
			if (fork() == 0)	/* child */
			{
				char *shell, *base;

				done_screen();

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

				exit(0);	/* oops */
			}

			(void)wait(0);
			(void)tcsetattr(fileno(stdin), TCSADRAIN, &tty_new);
#ifdef BSD
			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;
			(void)setitimer(ITIMER_REAL, &itv, NULL);
#endif
#ifdef SYSV
			alarm(aval);
#endif
		}
		(void)redraw();
	}

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

static const char *
setplane(int c)
{
	PLANE	*pp;

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

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

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

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

/* ARGSUSED */
static const char *
right(int c __unused)
{
	dir = D_RIGHT;
	p.new_dir = p.dir + 1;
	if (p.new_dir >= MAXDIR)
		p.new_dir -= MAXDIR;
	return (NULL);
}

/* ARGSUSED */
static const char *
Left(int c __unused)
{
	p.new_dir = p.dir - 2;
	if (p.new_dir < 0)
		p.new_dir += MAXDIR;
	return (NULL);
}

/* ARGSUSED */
static const char *
Right(int c __unused)
{
	p.new_dir = p.dir + 2;
	if (p.new_dir >= MAXDIR)
		p.new_dir -= MAXDIR;
	return (NULL);
}

static const char *
delayb(int ch)
{
	int	xdiff, ydiff;
	unsigned bn;

	bn = ch -= '0';

	if (bn >= sp->num_beacons)
		return ("Unknown beacon");
	xdiff = sp->beacon[bn].x - p.xpos;
	xdiff = SGN(xdiff);
	ydiff = sp->beacon[bn].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 = true;
	p.delayd_no = bn;

	if (dest_type != T_NODEST) {
		switch (dest_type) {
		case T_BEACON:
			xdiff = sp->beacon[dest_no].x - sp->beacon[bn].x;
			ydiff = sp->beacon[dest_no].y - sp->beacon[bn].y;
			break;
		case T_EXIT:
			xdiff = sp->exit[dest_no].x - sp->beacon[bn].x;
			ydiff = sp->exit[dest_no].y - sp->beacon[bn].y;
			break;
		case T_AIRPORT:
			xdiff = sp->airport[dest_no].x - sp->beacon[bn].x;
			ydiff = sp->airport[dest_no].y - sp->beacon[bn].y;
			break;
		default:
			return ("Bad case in delayb!  Get help!");
		}
		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);
}

/* ARGSUSED */
static const char *
beacon(int c __unused)
{
	dest_type = T_BEACON;
	return (NULL);
}

/* ARGSUSED */
static const char *
ex_it(int c __unused)
{
	dest_type = T_EXIT;
	return (NULL);
}

/* ARGSUSED */
static const char *
airport(int c __unused)
{
	dest_type = T_AIRPORT;
	return (NULL);
}

/* ARGSUSED */
static const char *
climb(int c __unused)
{
	dir = D_UP;
	return (NULL);
}

/* ARGSUSED */
static const char *
descend(int c __unused)
{
	dir = D_DOWN;
	return (NULL);
}

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

static const char *
setrelalt(int c)
{
	int newalt;

	if (c == 0)
		return ("altitude not changed");

	switch (dir) {
	case D_UP:
		newalt = p.altitude + c - '0';
		break;
	case D_DOWN:
		newalt = p.altitude - (c - '0');
		break;
	default:
		return ("Unknown case in setrelalt!  Get help!");
	}

	if (p.new_altitude == newalt)
		return ("Already going to that altitude");

	p.new_altitude = newalt;

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

static const char *
benum(int ch)
{
	unsigned n;

	n = ch - '0';
	dest_no = n;

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

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

static const char *
rel_dir(int 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!");
	}
	return (NULL);
}

/* ARGSUSED */
static const char *
mark(int c __unused)
{
	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);
}

/* ARGSUSED */
static const char *
unmark(int c __unused)
{
	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);
}

/* ARGSUSED */
static const char *
ignore(int c __unused)
{
	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);
}

int
dir_no(int ch)
{
	int	dirno;

	dirno = -1;
	switch (ch) {
	case 'w':	dirno = 0;	break;
	case 'e':	dirno = 1;	break;
	case 'd':	dirno = 2;	break;
	case 'c':	dirno = 3;	break;
	case 'x':	dirno = 4;	break;
	case 'z':	dirno = 5;	break;
	case 'a':	dirno = 6;	break;
	case 'q':	dirno = 7;	break;
	default:
		(void)fprintf(stderr, "bad character in dir_no\n");
		break;
	}
	return (dirno);
}