Fix warnings from byacc import.
[dragonfly.git] / games / atc / main.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  * @(#) Copyright (c) 1990, 1993 The Regents of the University of California.  All rights reserved.
33  * @(#)main.c   8.1 (Berkeley) 5/31/93
34  * $FreeBSD: src/games/atc/main.c,v 1.9 1999/11/30 03:48:21 billf Exp $
35  * $DragonFly: src/games/atc/main.c,v 1.4 2006/10/08 17:11:30 pavalos Exp $
36  */
37
38 /*
39  * Copyright (c) 1987 by Ed James, UC Berkeley.  All rights reserved.
40  *
41  * Copy permission is hereby granted provided that this notice is
42  * retained on all partial or complete copies.
43  *
44  * For more info on this and all of my stuff, mail edjames@berkeley.edu.
45  */
46
47 #include <stdlib.h>
48 #include "include.h"
49 #include "pathnames.h"
50
51 extern FILE     *yyin;
52 extern int      yyparse(void);
53 static int read_file(const char *);
54 static const char *default_game(void);
55 static const char *okay_game(const char *);
56 static int list_games(void);
57
58 int
59 main(int argc __unused, char *argv[])
60 {
61         int                     seed = 0;
62         int                     f_usage = 0, f_list = 0, f_showscore = 0;
63         int                     f_printpath = 0;
64         const char              *file = NULL;
65         char                    *p_name, *ptr;
66         struct itimerval        itv;
67
68         /* Open the score file then revoke setgid privileges */
69         open_score_file();
70         setregid(getgid(), getgid());
71
72         start_time = time(0);
73
74         p_name = *argv++;
75         while (*argv) {
76 #ifndef SAVEDASH
77                 if (**argv == '-')
78                         ++*argv;
79                 else
80                         break;
81 #endif
82                 ptr = *argv++;
83                 while (*ptr) {
84                         switch (*ptr) {
85                         case '?':
86                         case 'u':
87                                 f_usage++;
88                                 break;
89                         case 'l':
90                                 f_list++;
91                                 break;
92                         case 's':
93                         case 't':
94                                 f_showscore++;
95                                 break;
96                         case 'p':
97                                 f_printpath++;
98                                 break;
99                         case 'r':
100                                 srandom(atoi(*argv));
101                                 seed = 1;
102                                 argv++;
103                                 break;
104                         case 'f':
105                         case 'g':
106                                 file = *argv;
107                                 argv++;
108                                 break;
109                         default:
110                                 fprintf(stderr, "Unknown option '%c'\n", *ptr);
111                                 f_usage++;
112                                 break;
113                         }
114                         ptr++;
115                 }
116         }
117         if (!seed)
118                 srandomdev();
119
120         if (f_usage)
121                 fprintf(stderr,
122                     "Usage: %s -[u?lstp] [-[gf] game_name] [-r random seed]\n",
123                         p_name);
124         if (f_showscore)
125                 log_score(1);
126         if (f_list)
127                 list_games();
128         if (f_printpath) {
129                 char    buf[100];
130
131                 strcpy(buf, _PATH_GAMES);
132                 buf[strlen(buf) - 1] = '\0';
133                 puts(buf);
134         }
135
136         if (f_usage || f_showscore || f_list || f_printpath)
137                 exit(0);
138
139         if (file == NULL)
140                 file = default_game();
141         else
142                 file = okay_game(file);
143
144         if (file == NULL || read_file(file) < 0)
145                 exit(1);
146
147         init_gr();
148         setup_screen(sp);
149
150         addplane();
151
152         signal(SIGINT, (sig_t)quit);
153         signal(SIGQUIT, (sig_t)quit);
154         signal(SIGTSTP, SIG_IGN);
155         signal(SIGSTOP, SIG_IGN);
156         signal(SIGHUP, (sig_t)log_score);
157         signal(SIGTERM, (sig_t)log_score);
158
159         tcgetattr(fileno(stdin), &tty_start);
160         bcopy(&tty_start, &tty_new, sizeof(tty_new));
161         tty_new.c_lflag &= ~(ICANON|ECHO);
162         tty_new.c_cc[VMIN] = 1;
163         tty_new.c_cc[VTIME] = 0;
164         tcsetattr(fileno(stdin), TCSANOW, &tty_new);
165         signal(SIGALRM, (sig_t)update);
166
167         itv.it_value.tv_sec = 0;
168         itv.it_value.tv_usec = 1;
169         itv.it_interval.tv_sec = sp->update_secs;
170         itv.it_interval.tv_usec = 0;
171         setitimer(ITIMER_REAL, &itv, NULL);
172
173         for (;;) {
174                 if (getcommand() != 1)
175                         planewin();
176                 else {
177                         itv.it_value.tv_sec = 0;
178                         itv.it_value.tv_usec = 0;
179                         setitimer(ITIMER_REAL, &itv, NULL);
180
181                         update();
182
183                         itv.it_value.tv_sec = sp->update_secs;
184                         itv.it_value.tv_usec = 0;
185                         itv.it_interval.tv_sec = sp->update_secs;
186                         itv.it_interval.tv_usec = 0;
187                         setitimer(ITIMER_REAL, &itv, NULL);
188                 }
189         }
190 }
191
192 static int
193 read_file(const char *s)
194 {
195         int             retval;
196
197         filename = s;
198         yyin = fopen(s, "r");
199         if (yyin == NULL) {
200                 perror(s);
201                 return (-1);
202         }
203         retval = yyparse();
204         fclose(yyin);
205
206         if (retval != 0)
207                 return (-1);
208         else
209                 return (0);
210 }
211
212 static const char *
213 default_game(void)
214 {
215         FILE            *fp;
216         static char     file[256];
217         char            line[256], games[256];
218
219         strcpy(games, _PATH_GAMES);
220         strcat(games, GAMES);
221
222         if ((fp = fopen(games, "r")) == NULL) {
223                 perror(games);
224                 return (NULL);
225         }
226         if (fgets(line, sizeof(line), fp) == NULL) {
227                 fprintf(stderr, "%s: no default game available\n", games);
228                 return (NULL);
229         }
230         fclose(fp);
231         line[strlen(line) - 1] = '\0';
232         strcpy(file, _PATH_GAMES);
233         strcat(file, line);
234         return (file);
235 }
236
237 static const char *
238 okay_game(const char *s)
239 {
240         FILE            *fp;
241         static char     file[256];
242         const char      *ret = NULL;
243         char            line[256], games[256];
244
245         strcpy(games, _PATH_GAMES);
246         strcat(games, GAMES);
247
248         if ((fp = fopen(games, "r")) == NULL) {
249                 perror(games);
250                 return (NULL);
251         }
252         while (fgets(line, sizeof(line), fp) != NULL) {
253                 line[strlen(line) - 1] = '\0';
254                 if (strcmp(s, line) == 0) {
255                         strcpy(file, _PATH_GAMES);
256                         strcat(file, line);
257                         ret = file;
258                         break;
259                 }
260         }
261         fclose(fp);
262         if (ret == NULL) {
263                 test_mode = 1;
264                 ret = s;
265                 fprintf(stderr, "%s: %s: game not found\n", games, s);
266                 fprintf(stderr, "Your score will not be logged.\n");
267                 sleep(2);       /* give the guy time to read it */
268         }
269         return (ret);
270 }
271
272 static int
273 list_games(void)
274 {
275         FILE            *fp;
276         char            line[256], games[256];
277         int             num_games = 0;
278
279         strcpy(games, _PATH_GAMES);
280         strcat(games, GAMES);
281
282         if ((fp = fopen(games, "r")) == NULL) {
283                 perror(games);
284                 return (-1);
285         }
286         puts("available games:");
287         while (fgets(line, sizeof(line), fp) != NULL) {
288                 printf("        %s", line);
289                 num_games++;
290         }
291         fclose(fp);
292         if (num_games == 0) {
293                 fprintf(stderr, "%s: no games available\n", games);
294                 return (-1);
295         }
296         return (0);
297 }