 @@ -1,677 +1,678 @@
-/*	$NetBSD: input.c,v 1.22 2007/12/15 19:44:38 perry Exp $	*/
+/*	$NetBSD: input.c,v 1.23 2009/05/26 00:00:56 dholland 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.22 2007/12/15 19:44:38 perry Exp $");
+__RCSID("$NetBSD: input.c,v 1.23 2009/05/26 00:00:56 dholland Exp $");
 #endif
 #endif /* not lint */
 #include "include.h"
 #include "pathnames.h"
 #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)
 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)	}
 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;
 int
 pop(void)
+{
 	if (level == 0)
 		return (-1);
 	level--;
 	ioclrtoeol(T_POS);
 	(void)strcpy(T_STR, "");
 	T_RULE = -1;
 	T_CH = -1;
 	return (0);
+}
 void
 rezero(void)
+{
 	iomove(0);
 	level = 0;
 	T_STATE = 0;
 	T_RULE = -1;
 	T_CH = -1;
 	T_POS = 0;
 	(void)strcpy(T_STR, "");
+}
 void
 push(int ruleno, int ch)
+{
 	int	newstate, newpos;
 	assert(level < (MAXDEPTH - 1));
-	(void)sprintf(T_STR, st[T_STATE].rule[ruleno].str, tval);
+	(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);
+}
 void
 noise(void)
+{
 	(void)putchar('\07');
 	(void)fflush(stdout);
+}
 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);
+}
 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 = 0;
 	return (NULL);
+}
 /* ARGSUSED */
 const char *
 turn(int c __unused)
+{
 	if (p.altitude == 0)
 		return ("Planes at airports may not change direction");
 	return (NULL);
+}
 /* ARGSUSED */
 const char *
 circle(int c __unused)
+{
 	if (p.altitude == 0)
 		return ("Planes cannot circle on the ground");
 	p.new_dir = MAXDIR;
 	return (NULL);
+}
 /* ARGSUSED */
 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 */
 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 */
 const char *
 Left(int c __unused)
+{
 	p.new_dir = p.dir - 2;
 	if (p.new_dir < 0)
 		p.new_dir += MAXDIR;
 	return (NULL);
+}
 /* ARGSUSED */
 const char *
 Right(int c __unused)
+{
 	p.new_dir = p.dir + 2;
 	if (p.new_dir >= MAXDIR)
 		p.new_dir -= MAXDIR;
 	return (NULL);
+}
 const char *
 delayb(int c)
+{
 	int	xdiff, ydiff;
 	c -= '0';
 	if (c >= sp->num_beacons)
 		return ("Unknown beacon");
 	xdiff = sp->beacon[(int)c].x - p.xpos;
 	xdiff = SGN(xdiff);
 	ydiff = sp->beacon[(int)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[(int)c].x;
 			ydiff = sp->beacon[dest_no].y - sp->beacon[(int)c].y;
 			break;
 		case T_EXIT:
 			xdiff = sp->exit[dest_no].x - sp->beacon[(int)c].x;
 			ydiff = sp->exit[dest_no].y - sp->beacon[(int)c].y;
 			break;
 		case T_AIRPORT:
 			xdiff = sp->airport[dest_no].x - sp->beacon[(int)c].x;
 			ydiff = sp->airport[dest_no].y - sp->beacon[(int)c].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 */
 const char *
 beacon(int c __unused)
+{
 	dest_type = T_BEACON;
 	return (NULL);
+}
 /* ARGSUSED */
 const char *
 ex_it(int c __unused)
+{
 	dest_type = T_EXIT;
 	return (NULL);
+}
 /* ARGSUSED */
 const char *
 airport(int c __unused)
+{
 	dest_type = T_AIRPORT;
 	return (NULL);
+}
 /* ARGSUSED */
 const char *
 climb(int c __unused)
+{
 	dir = D_UP;
 	return (NULL);
+}
 /* ARGSUSED */
 const char *
 descend(int c __unused)
+{
 	dir = D_DOWN;
 	return (NULL);
+}
 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);
+}
 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);
+}
 const char *
 benum(int 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[(int)c].x - p.xpos,
 			sp->beacon[(int)c].y - p.ypos);
 		break;
 	case T_EXIT:
 		if (c >= sp->num_exits)
 			return ("Unknown exit");
 		p.new_dir = DIR_FROM_DXDY(sp->exit[(int)c].x - p.xpos,
 			sp->exit[(int)c].y - p.ypos);
 		break;
 	case T_AIRPORT:
 		if (c >= sp->num_airports)
 			return ("Unknown airport");
 		p.new_dir = DIR_FROM_DXDY(sp->airport[(int)c].x - p.xpos,
 			sp->airport[(int)c].y - p.ypos);
 		break;
 	default:
 		return ("Unknown case in benum!  Get help!");
+	}
 	return (NULL);
+}
 const char *
 to_dir(int c)
+{
 	p.new_dir = dir_no(c);
 	return (NULL);
+}
 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 */
 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 */
 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 */
 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);
+}

 @@ -1,300 +1,301 @@
-/*	$NetBSD: log.c,v 1.19 2007/12/15 19:44:38 perry Exp $	*/
+/*	$NetBSD: log.c,v 1.20 2009/05/26 00:00:56 dholland 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[] = "@(#)log.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: log.c,v 1.19 2007/12/15 19:44:38 perry Exp $");
+__RCSID("$NetBSD: log.c,v 1.20 2009/05/26 00:00:56 dholland Exp $");
 #endif
 #endif /* not lint */
 #include "include.h"
 #include "pathnames.h"
 static FILE *score_fp;
 int
 compar(const void *va, const void *vb)
+{
 	const SCORE	*a, *b;
 	a = (const SCORE *)va;
 	b = (const SCORE *)vb;
 	if (b->planes == a->planes)
 		return (b->time - a->time);
 	else
 		return (b->planes - a->planes);
+}
 #define SECAMIN		60
 #define MINAHOUR	60
 #define HOURADAY	24
 #define SECAHOUR	(SECAMIN * MINAHOUR)
 #define SECADAY		(SECAHOUR * HOURADAY)
 #define DAY(t)		((t) / SECADAY)
 #define HOUR(t)		(((t) % SECADAY) / SECAHOUR)
 #define MIN(t)		(((t) % SECAHOUR) / SECAMIN)
 #define SEC(t)		((t) % SECAMIN)
 const char *
 timestr(int t)
+{
 	static char	s[80];
 	if (DAY(t) > 0)
-		(void)sprintf(s, "%dd+%02dhrs", DAY(t), HOUR(t));
+		(void)snprintf(s, sizeof(s), "%dd+%02dhrs", DAY(t), HOUR(t));
 	else if (HOUR(t) > 0)
-		(void)sprintf(s, "%d:%02d:%02d", HOUR(t), MIN(t), SEC(t));
+		(void)snprintf(s, sizeof(s), "%d:%02d:%02d", HOUR(t), MIN(t),
 			SEC(t));
 	else if (MIN(t) > 0)
-		(void)sprintf(s, "%d:%02d", MIN(t), SEC(t));
+		(void)snprintf(s, sizeof(s), "%d:%02d", MIN(t), SEC(t));
 	else if (SEC(t) > 0)
-		(void)sprintf(s, ":%02d", SEC(t));
+		(void)snprintf(s, sizeof(s), ":%02d", SEC(t));
 	else
 		*s = '\0';
 	return (s);
+}
 void
 open_score_file(void)
+{
 	mode_t old_mask;
 	int score_fd;
 	int flags;
 	old_mask = umask(0);
 #if defined(O_NOFOLLOW)
 	score_fd = open(_PATH_SCORE, O_CREAT|O_RDWR|O_NOFOLLOW, 0664);
 #else
 	score_fd = open(_PATH_SCORE, O_CREAT|O_RDWR, 0664);
 #endif
 	(void)umask(old_mask);
 	if (score_fd < 0) {
 		warn("open %s", _PATH_SCORE);
 		return;
+	}
 	if (score_fd < 3)
 		exit(1);
 	/* Set the close-on-exec flag.  If this fails for any reason, quit
 	 * rather than leave the score file open to tampering.  */
 	flags = fcntl(score_fd, F_GETFD);
 	if (flags < 0)
 		err(1, "fcntl F_GETFD");
 	flags |= FD_CLOEXEC;
 	if (fcntl(score_fd, F_SETFD, flags) == -1)
 		err(1, "fcntl F_SETFD");
 	/*
 	 * This is done to take advantage of stdio, while still
 	 * allowing a O_CREAT during the open(2) of the log file.
 	 */
 	score_fp = fdopen(score_fd, "r+");
 	if (score_fp == NULL) {
 		warn("fdopen %s", _PATH_SCORE);
 		return;
+	}
+}
 int
 log_score(int list_em)
+{
 	int		i, num_scores = 0, good, changed = 0, found = 0;
 	struct passwd	*pw;
 	char		*cp;
 	SCORE		score[100], thisscore;
 	struct utsname	lname;
 	long		offset;
 	if (score_fp == NULL) {
 		warnx("no score file available");
 		return (-1);
+	}
 #ifdef BSD
 	if (flock(fileno(score_fp), LOCK_EX) < 0)
 #endif
 #ifdef SYSV
 	if (lockf(fileno(score_fp), F_LOCK, 1) < 0)
 #endif
+	{
 		warn("flock %s", _PATH_SCORE);
 		return (-1);
+	}
 	for (;;) {
 		good = fscanf(score_fp, SCORE_SCANF_FMT,
 			   score[num_scores].name,
 			   score[num_scores].host,
 			   score[num_scores].game,
 			   &score[num_scores].planes,
 			   &score[num_scores].time,
 			   &score[num_scores].real_time);
 		if (good != 6 || ++num_scores >= NUM_SCORES)
 			break;
+	}
 	if (!test_mode && !list_em) {
 		if ((pw = (struct passwd *) getpwuid(getuid())) == NULL) {
 			(void)fprintf(stderr,
 				"getpwuid failed for uid %d.  Who are you?\n",
 				(int)getuid());
 			return (-1);
+		}
 		(void)strlcpy(thisscore.name, pw->pw_name, SCORE_NAME_LEN);
 		(void)uname(&lname);
 		(void)strlcpy(thisscore.host, lname.nodename,
 		    sizeof(thisscore.host));
 		cp = strrchr(filename, '/');
 		if (cp == NULL) {
 			(void)fprintf(stderr, "log: where's the '/' in %s?\n",
 			    filename);
 			return (-1);
+		}
 		cp++;
 		(void)strlcpy(thisscore.game, cp, SCORE_GAME_LEN);
 		thisscore.time = clck;
 		thisscore.planes = safe_planes;
 		thisscore.real_time = time(0) - start_time;
 		for (i = 0; i < num_scores; i++) {
 			if (strcmp(thisscore.name, score[i].name) == 0 &&
 			    strcmp(thisscore.host, score[i].host) == 0 &&
 			    strcmp(thisscore.game, score[i].game) == 0) {
 				if (thisscore.time > score[i].time) {
 					score[i].time = thisscore.time;
 					score[i].planes = thisscore.planes;
 					score[i].real_time =
 					    thisscore.real_time;
 					changed++;
+				}
 				found++;
 				break;
+			}
+		}
 		if (!found) {
 			for (i = 0; i < num_scores; i++) {
 				if (thisscore.time > score[i].time) {
 					if (num_scores < NUM_SCORES)
 						num_scores++;
 					(void)memcpy(&score[num_scores - 1],
 					    &score[i], sizeof (score[i]));
 					(void)memcpy(&score[i], &thisscore,
 					    sizeof (score[i]));
 					changed++;
 					break;
+				}
+			}
+		}
 		if (!found && !changed && num_scores < NUM_SCORES) {
 			(void)memcpy(&score[num_scores], &thisscore,
 			    sizeof (score[num_scores]));
 			num_scores++;
 			changed++;
+		}
 		if (changed) {
 			if (found)
 				(void)puts("You beat your previous score!");
 			else
 				(void)puts("You made the top players list!");
 			qsort(score, (size_t)num_scores, sizeof (*score),
 			    compar);
 			rewind(score_fp);
 			for (i = 0; i < num_scores; i++)
 				(void)fprintf(score_fp, "%s %s %s %d %d %d\n",
 				    score[i].name, score[i].host,
 				    score[i].game, score[i].planes,
 				    score[i].time, score[i].real_time);
 			(void)fflush(score_fp);
 			if (ferror(score_fp))
 				warn("error writing %s", _PATH_SCORE);
 			/* It is just possible that updating an entry could
 			 * have reduced the length of the file, so we
 			 * truncate it.  The seeks are required for stream/fd
 			 * synchronisation by POSIX.1.  */
 			offset = ftell(score_fp);
 			(void)lseek(fileno(score_fp), (off_t)0, SEEK_SET);
 			(void)ftruncate(fileno(score_fp), (off_t)offset);
 			rewind(score_fp);
 		} else {
 			if (found)
 				(void)puts(
 				    "You didn't beat your previous score.");
 			else
 				(void)puts(
 				    "You didn't make the top players list.");
+		}
 		(void)putchar('\n');
+	}
 #ifdef BSD
 	(void)flock(fileno(score_fp), LOCK_UN);
 #endif
 #ifdef SYSV
 	/* lock will evaporate upon close */
 #endif
 	(void)fclose(score_fp);
 	(void)printf("%2s:  %-8s  %-8s  %-18s  %4s  %9s  %4s\n", "#", "name",
 	    "host", "game", "time", "real time", "planes safe");
 	(void)printf("-------------------------------------------------------");
 	(void)printf("-------------------------\n");
 	for (i = 0; i < num_scores; i++) {
 		cp = strchr(score[i].host, '.');
 		if (cp != NULL)
 			*cp = '\0';
 		(void)printf("%2d:  %-8s  %-8s  %-18s  %4d  %9s  %4d\n", i + 1,
 		    score[i].name, score[i].host, score[i].game,
 		    score[i].time, timestr(score[i].real_time),
 		    score[i].planes);
+	}
 	(void)putchar('\n');
 	return (0);
+}
 /* ARGSUSED */
 void
 log_score_quit(int dummy __unused)
+{
 	(void)log_score(0);
 	exit(0);
+}

 @@ -1,413 +1,419 @@
-/*	$NetBSD: update.c,v 1.19 2007/12/15 19:44:38 perry Exp $	*/
+/*	$NetBSD: update.c,v 1.20 2009/05/26 00:00:56 dholland 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[] = "@(#)update.c	8.1 (Berkeley) 5/31/93";
 #else
-__RCSID("$NetBSD: update.c,v 1.19 2007/12/15 19:44:38 perry Exp $");
+__RCSID("$NetBSD: update.c,v 1.20 2009/05/26 00:00:56 dholland Exp $");
 #endif
 #endif /* not lint */
 #include "include.h"
 /* ARGSUSED */
 void
 update(int dummy __unused)
+{
 	int	i, dir_diff, unclean;
 	PLANE	*pp, *p1, *p2;
 #ifdef SYSV
 	alarm(0);
 	signal(SIGALRM, update);
 #endif
 	clck++;
 	erase_all();
 	/* put some planes in the air */
 	do {
 		unclean = 0;
 		for (pp = ground.head; pp != NULL; pp = pp->next) {
 			if (pp->new_altitude > 0) {
 				delete(&ground, pp);
 				append(&air, pp);
 				unclean = 1;
 				break;
+			}
+		}
 	} while (unclean);
 	/* do altitude change and basic movement */
 	for (pp = air.head; pp != NULL; pp = pp->next) {
 		/* type 0 only move every other turn */
 		if (pp->plane_type == 0 && clck & 1)
 			continue;
 		pp->fuel--;
 		if (pp->fuel < 0)
 			loser(pp, "ran out of fuel.");
 		pp->altitude += SGN(pp->new_altitude - pp->altitude);
 		if (!pp->delayd) {
 			dir_diff = pp->new_dir - pp->dir;
 			/*
 			 * Allow for circle commands
 			 */
 			if (pp->new_dir >= 0 && pp->new_dir < MAXDIR) {
 				if (dir_diff > MAXDIR/2)
 					dir_diff -= MAXDIR;
 				else if (dir_diff < -(MAXDIR/2))
 					dir_diff += MAXDIR;
+			}
 			if (dir_diff > 2)
 				dir_diff = 2;
 			else if (dir_diff < -2)
 				dir_diff = -2;
 			pp->dir += dir_diff;
 			if (pp->dir >= MAXDIR)
 				pp->dir -= MAXDIR;
 			else if (pp->dir < 0)
 				pp->dir += MAXDIR;
+		}
 		pp->xpos += displacement[pp->dir].dx;
 		pp->ypos += displacement[pp->dir].dy;
 		if (pp->delayd && pp->xpos == sp->beacon[pp->delayd_no].x &&
 		    pp->ypos == sp->beacon[pp->delayd_no].y) {
 			pp->delayd = 0;
 			if (pp->status == S_UNMARKED)
 				pp->status = S_MARKED;
+		}
 		switch (pp->dest_type) {
 		case T_AIRPORT:
 			if (pp->xpos == sp->airport[pp->dest_no].x &&
 			    pp->ypos == sp->airport[pp->dest_no].y &&
 			    pp->altitude == 0) {
 				if (pp->dir != sp->airport[pp->dest_no].dir)
 				    loser(pp, "landed in the wrong direction.");
 				else {
 				    pp->status = S_GONE;
 				    continue;
+				}
+			}
 			break;
 		case T_EXIT:
 			if (pp->xpos == sp->exit[pp->dest_no].x &&
 			    pp->ypos == sp->exit[pp->dest_no].y) {
 			    	if (pp->altitude != 9)
 				    loser(pp, "exited at the wrong altitude.");
 				else {
 				    pp->status = S_GONE;
 				    continue;
+				}
+			}
 			break;
 		default:
 			loser(pp, "has a bizarre destination, get help!");
+		}
 		if (pp->altitude > 9)
 			/* "this is impossible" */
 			loser(pp, "exceeded flight ceiling.");
 		if (pp->altitude <= 0) {
 			for (i = 0; i < sp->num_airports; i++)
 				if (pp->xpos == sp->airport[i].x &&
 				    pp->ypos == sp->airport[i].y) {
 					if (pp->dest_type == T_AIRPORT)
 					    loser(pp,
 						"landed at the wrong airport.");
 					else
 					    loser(pp,
 						"landed instead of exited.");
+				}
 			loser(pp, "crashed on the ground.");
+		}
 		if (pp->xpos < 1 || pp->xpos >= sp->width - 1 ||
 		    pp->ypos < 1 || pp->ypos >= sp->height - 1) {
 			for (i = 0; i < sp->num_exits; i++)
 				if (pp->xpos == sp->exit[i].x &&
 				    pp->ypos == sp->exit[i].y) {
 					if (pp->dest_type == T_EXIT)
 					    loser(pp,
 						"exited via the wrong exit.");
 					else
 					    loser(pp,
 						"exited instead of landed.");
+				}
 			loser(pp, "illegally left the flight arena.");
+		}
+	}
 	/*
 	 * Traverse the list once, deleting the planes that are gone.
 	 */
 	for (pp = air.head; pp != NULL; pp = p2) {
 		p2 = pp->next;
 		if (pp->status == S_GONE) {
 			safe_planes++;
 			delete(&air, pp);
+		}
+	}
 	draw_all();
 	for (p1 = air.head; p1 != NULL; p1 = p1->next)
 		for (p2 = p1->next; p2 != NULL; p2 = p2->next)
 			if (too_close(p1, p2, 1)) {
 				static char	buf[80];
-				(void)sprintf(buf, "collided with plane '%c'.",
+				(void)snprintf(buf, sizeof(buf),
 					"collided with plane '%c'.",
 					name(p2));
 				loser(p1, buf);
+			}
 	/*
 	 * Check every other update.  Actually, only add on even updates.
 	 * Otherwise, prop jobs show up *on* entrance.  Remember that
 	 * we don't update props on odd updates.
 	 */
 	if ((rand() % sp->newplane_time) == 0)
 		(void)addplane();
 #ifdef SYSV
 	alarm(sp->update_secs);
 #endif
+}
 const char *
 command(const PLANE *pp)
+{
 	static char	buf[50], *bp, *comm_start;
 	size_t bpsize;
 	buf[0] = '\0';
 	bp = buf;
-	(void)sprintf(bp, "%c%d%c%c%d: ", name(pp), pp->altitude,
+	bpsize = sizeof(buf);
 	(void)snprintf(bp, bpsize, "%c%d%c%c%d: ", name(pp), pp->altitude,
 		(pp->fuel < LOWFUEL) ? '*' : ' ',
 		(pp->dest_type == T_AIRPORT) ? 'A' : 'E', pp->dest_no);
 	comm_start = bp = strchr(buf, '\0');
 	bpsize = buf + sizeof(buf) - bp;
 	if (pp->altitude == 0)
-		(void)sprintf(bp, "Holding @ A%d", pp->orig_no);
+		(void)snprintf(bp, bpsize, "Holding @ A%d", pp->orig_no);
 	else if (pp->new_dir >= MAXDIR || pp->new_dir < 0)
-		(void)strcpy(bp, "Circle");
+		(void)snprintf(bp, bpsize, "Circle");
 	else if (pp->new_dir != pp->dir)
-		(void)sprintf(bp, "%d", dir_deg(pp->new_dir));
+		(void)snprintf(bp, bpsize, "%d", dir_deg(pp->new_dir));
 	bp = strchr(buf, '\0');
 	bpsize = buf + sizeof(buf) - bp;
 	if (pp->delayd)
-		(void)sprintf(bp, " @ B%d", pp->delayd_no);
+		(void)snprintf(bp, bpsize, " @ B%d", pp->delayd_no);
 	bp = strchr(buf, '\0');
 	bpsize = buf + sizeof(buf) - bp;
 	if (*comm_start == '\0' &&
 	    (pp->status == S_UNMARKED || pp->status == S_IGNORED))
-		(void)strcpy(bp, "---------");
+		(void)snprintf(bp, bpsize, "---------");
 	return (buf);
+}
 char
 name(const PLANE *p)
+{
 	if (p->plane_type == 0)
 		return ('A' + p->plane_no);
 	else
 		return ('a' + p->plane_no);
+}
 int
 number(int l)
+{
 	if (islower((unsigned char)l))
 		return (l - 'a');
 	else if (isupper((unsigned char)l))
 		return (l - 'A');
 	else
 		return (-1);
+}
 int
 next_plane(void)
+{
 	static int	last_plane = -1;
 	PLANE		*pp;
 	int		found, start_plane = last_plane;
 	do {
 		found = 0;
 		last_plane++;
 		if (last_plane >= 26)
 			last_plane = 0;
 		for (pp = air.head; pp != NULL; pp = pp->next)
 			if (pp->plane_no == last_plane) {
 				found++;
 				break;
+			}
 		if (!found)
 			for (pp = ground.head; pp != NULL; pp = pp->next)
 				if (pp->plane_no == last_plane) {
 					found++;
 					break;
+				}
 	} while (found && last_plane != start_plane);
 	if (last_plane == start_plane)
 		return (-1);
 	return (last_plane);
+}
 int
 addplane(void)
+{
 	PLANE	p, *pp, *p1;
 	int	i, num_starts, isclose, rnd, rnd2, pnum;
 	(void)memset(&p, 0, sizeof (p));
 	p.status = S_MARKED;
 	p.plane_type = random() % 2;
 	num_starts = sp->num_exits + sp->num_airports;
 	rnd = random() % num_starts;
 	if (rnd < sp->num_exits) {
 		p.dest_type = T_EXIT;
 		p.dest_no = rnd;
 	} else {
 		p.dest_type = T_AIRPORT;
 		p.dest_no = rnd - sp->num_exits;
+	}
 	/* loop until we get a plane not near another */
 	for (i = 0; i < num_starts; i++) {
 		/* loop till we get a different start point */
 		while ((rnd2 = random() % num_starts) == rnd)
+			;
 		if (rnd2 < sp->num_exits) {
 			p.orig_type = T_EXIT;
 			p.orig_no = rnd2;
 			p.xpos = sp->exit[rnd2].x;
 			p.ypos = sp->exit[rnd2].y;
 			p.new_dir = p.dir = sp->exit[rnd2].dir;
 			p.altitude = p.new_altitude = 7;
 			isclose = 0;
 			for (p1 = air.head; p1 != NULL; p1 = p1->next)
 				if (too_close(p1, &p, 4)) {
 					isclose++;
 					break;
+				}
 			if (isclose)
 				continue;
 		} else {
 			p.orig_type = T_AIRPORT;
 			p.orig_no = rnd2 - sp->num_exits;
 			p.xpos = sp->airport[p.orig_no].x;
 			p.ypos = sp->airport[p.orig_no].y;
 			p.new_dir = p.dir = sp->airport[p.orig_no].dir;
 			p.altitude = p.new_altitude = 0;
+		}
 		p.fuel = sp->width + sp->height;
 		break;
+	}
 	if (i >= num_starts)
 		return (-1);
 	pnum = next_plane();
 	if (pnum < 0)
 		return (-1);
 	p.plane_no = pnum;
 	pp = newplane();
 	if (pp == NULL)
 		loser(NULL, "Out of memory!");
 	(void)memcpy(pp, &p, sizeof (p));
 	if (pp->orig_type == T_AIRPORT)
 		append(&ground, pp);
 	else
 		append(&air, pp);
 	return (pp->dest_type);
+}
 PLANE *
 findplane(int n)
+{
 	PLANE	*pp;
 	for (pp = air.head; pp != NULL; pp = pp->next)
 		if (pp->plane_no == n)
 			return (pp);
 	for (pp = ground.head; pp != NULL; pp = pp->next)
 		if (pp->plane_no == n)
 			return (pp);
 	return (NULL);
+}
 int
 too_close(const PLANE *p1, const PLANE *p2, int dist)
+{
 	if (ABS(p1->altitude - p2->altitude) <= dist &&
 	    ABS(p1->xpos - p2->xpos) <= dist &&
 	    ABS(p1->ypos - p2->ypos) <= dist)
 		return (1);
 	else
 		return (0);
+}
 int
 dir_deg(int d)
+{
 	switch (d) {
 	case 0: return (0);
 	case 1: return (45);
 	case 2: return (90);
 	case 3: return (135);
 	case 4: return (180);
 	case 5: return (225);
 	case 6: return (270);
 	case 7: return (315);
 	default:
 		return (-1);
+	}
+}