Remove not needed void casts.
[dragonfly.git] / games / atc / grammar.y
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. 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.
35  *
36  * @(#)grammar.y        8.1 (Berkeley) 5/31/93
37  */
38
39 /*
40  * Copyright (c) 1987 by Ed James, UC Berkeley.  All rights reserved.
41  *
42  * Copy permission is hereby granted provided that this notice is
43  * retained on all partial or complete copies.
44  *
45  * For more info on this and all of my stuff, mail edjames@berkeley.edu.
46  */
47
48 %token <ival>   HeightOp
49 %token <ival>   WidthOp
50 %token <ival>   UpdateOp
51 %token <ival>   NewplaneOp
52 %token <cval>   DirOp
53 %token <ival>   ConstOp
54 %token <ival>   LineOp
55 %token <ival>   AirportOp
56 %token <ival>   BeaconOp
57 %token <ival>   ExitOp
58 %union {
59         int     ival;
60         char    cval;
61 }
62
63 %{
64 #include "include.h"
65
66 int     errors = 0;
67 int     line = 1;
68 %}
69
70 %%
71 file:
72         bunch_of_defs { if (checkdefs() < 0) return (errors); } bunch_of_lines
73                 { 
74                 if (sp->num_exits + sp->num_airports < 2)
75                         yyerror("Need at least 2 airports and/or exits.");
76                 return (errors);
77                 }
78         ;
79
80 bunch_of_defs:
81         def bunch_of_defs
82         | def
83         ;
84
85 def:
86         udef
87         | ndef
88         | wdef
89         | hdef
90         ;
91
92 udef:
93         UpdateOp '=' ConstOp ';'
94                 {
95                 if (sp->update_secs != 0)
96                         return (yyerror("Redefinition of 'update'."));
97                 else if ($3 < 1)
98                         return (yyerror("'update' is too small."));
99                 else
100                         sp->update_secs = $3;
101                 }
102         ;
103
104 ndef:
105         NewplaneOp '=' ConstOp ';'
106                 {
107                 if (sp->newplane_time != 0)
108                         return (yyerror("Redefinition of 'newplane'."));
109                 else if ($3 < 1)
110                         return (yyerror("'newplane' is too small."));
111                 else
112                         sp->newplane_time = $3;
113                 }
114         ;
115
116 hdef:
117         HeightOp '=' ConstOp ';'
118                 {
119                 if (sp->height != 0)
120                         return (yyerror("Redefinition of 'height'."));
121                 else if ($3 < 3)
122                         return (yyerror("'height' is too small."));
123                 else
124                         sp->height = $3; 
125                 }
126         ;
127
128 wdef:
129         WidthOp '=' ConstOp ';'
130                 {
131                 if (sp->height != 0)
132                         return (yyerror("Redefinition of 'width'."));
133                 else if ($3 < 3)
134                         return (yyerror("'width' is too small."));
135                 else
136                         sp->width = $3; 
137                 }
138         ;
139
140 bunch_of_lines:
141         line bunch_of_lines
142                 {}
143         | line
144                 {}
145         ;
146
147 line:
148         BeaconOp ':' Bpoint_list ';'
149                 {}
150         | ExitOp ':' Epoint_list ';'
151                 {}
152         | LineOp ':' Lline_list ';'
153                 {}
154         | AirportOp ':' Apoint_list ';'
155                 {}
156         ;
157
158 Bpoint_list:
159         Bpoint Bpoint_list
160                 {}
161         | Bpoint
162                 {}
163         ;
164
165 Bpoint:
166         '(' ConstOp ConstOp ')'
167                 {
168                 if (sp->num_beacons % REALLOC == 0) {
169                         if (sp->beacon == NULL)
170                                 sp->beacon = (BEACON *) malloc((sp->num_beacons
171                                         + REALLOC) * sizeof (BEACON));
172                         else
173                                 sp->beacon = (BEACON *) realloc(sp->beacon,
174                                         (sp->num_beacons + REALLOC) * 
175                                         sizeof (BEACON));
176                         if (sp->beacon == NULL)
177                                 return (yyerror("No memory available."));
178                 }
179                 sp->beacon[sp->num_beacons].x = $2;
180                 sp->beacon[sp->num_beacons].y = $3;
181                 check_point($2, $3);
182                 sp->num_beacons++;
183                 }
184         ;
185
186 Epoint_list:
187         Epoint Epoint_list
188                 {}
189         | Epoint
190                 {}
191         ;
192
193 Epoint:
194         '(' ConstOp ConstOp DirOp ')'
195                 {
196                 int     dir;
197
198                 if (sp->num_exits % REALLOC == 0) {
199                         if (sp->exit == NULL)
200                                 sp->exit = (EXIT *) malloc((sp->num_exits + 
201                                         REALLOC) * sizeof (EXIT));
202                         else
203                                 sp->exit = (EXIT *) realloc(sp->exit,
204                                         (sp->num_exits + REALLOC) * 
205                                         sizeof (EXIT));
206                         if (sp->exit == NULL)
207                                 return (yyerror("No memory available."));
208                 }
209                 dir = dir_no($4);
210                 sp->exit[sp->num_exits].x = $2;
211                 sp->exit[sp->num_exits].y = $3;
212                 sp->exit[sp->num_exits].dir = dir;
213                 check_edge($2, $3);
214                 check_edir($2, $3, dir);
215                 sp->num_exits++;
216                 }
217         ;
218
219 Apoint_list:
220         Apoint Apoint_list
221                 {}
222         | Apoint
223                 {}
224         ;
225
226 Apoint:
227         '(' ConstOp ConstOp DirOp ')'
228                 {
229                 int     dir;
230
231                 if (sp->num_airports % REALLOC == 0) {
232                         if (sp->airport == NULL)
233                                 sp->airport=(AIRPORT *)malloc((sp->num_airports
234                                         + REALLOC) * sizeof(AIRPORT));
235                         else
236                                 sp->airport = (AIRPORT *) realloc(sp->airport,
237                                         (sp->num_airports + REALLOC) * 
238                                         sizeof(AIRPORT));
239                         if (sp->airport == NULL)
240                                 return (yyerror("No memory available."));
241                 }
242                 dir = dir_no($4);
243                 sp->airport[sp->num_airports].x = $2;
244                 sp->airport[sp->num_airports].y = $3;
245                 sp->airport[sp->num_airports].dir = dir;
246                 check_point($2, $3);
247                 check_adir($2, $3, dir);
248                 sp->num_airports++;
249                 }
250         ;
251
252 Lline_list:
253         Lline Lline_list
254                 {}
255         | Lline
256                 {}
257         ;
258
259 Lline:
260         '[' '(' ConstOp ConstOp ')' '(' ConstOp ConstOp ')' ']'
261                 {
262                 if (sp->num_lines % REALLOC == 0) {
263                         if (sp->line == NULL)
264                                 sp->line = (LINE *) malloc((sp->num_lines + 
265                                         REALLOC) * sizeof (LINE));
266                         else
267                                 sp->line = (LINE *) realloc(sp->line,
268                                         (sp->num_lines + REALLOC) *
269                                         sizeof (LINE));
270                         if (sp->line == NULL)
271                                 return (yyerror("No memory available."));
272                 }
273                 sp->line[sp->num_lines].p1.x = $3;
274                 sp->line[sp->num_lines].p1.y = $4;
275                 sp->line[sp->num_lines].p2.x = $7;
276                 sp->line[sp->num_lines].p2.y = $8;
277                 check_line($3, $4, $7, $8);
278                 sp->num_lines++;
279                 }
280         ;
281 %%
282
283 check_edge(x, y)
284 {
285         if (!(x == 0) && !(x == sp->width - 1) && 
286             !(y == 0) && !(y == sp->height - 1))
287                 yyerror("edge value not on edge.");
288 }
289
290 check_point(x, y)
291 {
292         if (x < 1 || x >= sp->width - 1)
293                 yyerror("X value out of range.");
294         if (y < 1 || y >= sp->height - 1)
295                 yyerror("Y value out of range.");
296 }
297
298 check_linepoint(x, y)
299 {
300         if (x < 0 || x >= sp->width)
301                 yyerror("X value out of range.");
302         if (y < 0 || y >= sp->height)
303                 yyerror("Y value out of range.");
304 }
305
306 check_line(x1, y1, x2, y2)
307 {
308         int     d1, d2;
309
310         check_linepoint(x1, y1);
311         check_linepoint(x2, y2);
312
313         d1 = ABS(x2 - x1);
314         d2 = ABS(y2 - y1);
315
316         if (!(d1 == d2) && !(d1 == 0) && !(d2 == 0))
317                 yyerror("Bad line endpoints.");
318 }
319
320 yyerror(s)
321         char *s;
322 {
323         fprintf(stderr, "\"%s\": line %d: %s\n", file, line, s);
324         errors++;
325
326         return (errors);
327 }
328
329 check_edir(x, y, dir)
330 {
331         int     bad = 0;
332
333         if (x == sp->width - 1)
334                 x = 2;
335         else if (x != 0)
336                 x = 1;
337         if (y == sp->height - 1)
338                 y = 2;
339         else if (y != 0)
340                 y = 1;
341         
342         switch (x * 10 + y) {
343         case 00: if (dir != 3) bad++; break;
344         case 01: if (dir < 1 || dir > 3) bad++; break;
345         case 02: if (dir != 1) bad++; break;
346         case 10: if (dir < 3 || dir > 5) bad++; break;
347         case 11: break;
348         case 12: if (dir > 1 && dir < 7) bad++; break;
349         case 20: if (dir != 5) bad++; break;
350         case 21: if (dir < 5) bad++; break;
351         case 22: if (dir != 7) bad++; break;
352         default:
353                 yyerror("Unknown value in checkdir!  Get help!");
354                 break;
355         }
356         if (bad)
357                 yyerror("Bad direction for entrance at exit.");
358 }
359
360 check_adir(x, y, dir)
361 {
362 }
363
364 checkdefs()
365 {
366         int     err = 0;
367
368         if (sp->width == 0) {
369                 yyerror("'width' undefined.");
370                 err++;
371         }
372         if (sp->height == 0) {
373                 yyerror("'height' undefined.");
374                 err++;
375         }
376         if (sp->update_secs == 0) {
377                 yyerror("'update' undefined.");
378                 err++;
379         }
380         if (sp->newplane_time == 0) {
381                 yyerror("'newplane' undefined.");
382                 err++;
383         }
384         if (err)
385                 return (-1);
386         else
387                 return (0);
388 }