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