xref: /netbsd-src/games/atc/grammar.y (revision 46f5119e40af2e51998f686b2fdcc76b5488f7f3) 
1 /*	$NetBSD: grammar.y,v 1.10 2009/08/12 04:48:03 dholland Exp $	*/
2 
3 /*-
4  * Copyright (c) 1990, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Ed James.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 
35 /*
36  * Copyright (c) 1987 by Ed James, UC Berkeley.  All rights reserved.
37  *
38  * Copy permission is hereby granted provided that this notice is
39  * retained on all partial or complete copies.
40  *
41  * For more info on this and all of my stuff, mail edjames@berkeley.edu.
42  */
43 
44 %token <ival>	HeightOp
45 %token <ival>	WidthOp
46 %token <ival>	UpdateOp
47 %token <ival>	NewplaneOp
48 %token <cval>	DirOp
49 %token <ival>	ConstOp
50 %token <ival>	LineOp
51 %token <ival>	AirportOp
52 %token <ival>	BeaconOp
53 %token <ival>	ExitOp
54 %union {
55 	int	ival;
56 	char	cval;
57 }
58 
59 %{
60 #include "include.h"
61 
62 #include <sys/cdefs.h>
63 #ifndef lint
64 #if 0
65 static char sccsid[] = "@(#)grammar.y	8.1 (Berkeley) 5/31/93";
66 #else
67 __RCSID("$NetBSD: grammar.y,v 1.10 2009/08/12 04:48:03 dholland Exp $");
68 #endif
69 #endif /* not lint */
70 
71 int line = 1;
72 
73 static int errors = 0;
74 
75 static int yyerror(const char *);
76 %}
77 
78 %%
79 file:
80 	bunch_of_defs { if (checkdefs() < 0) return (errors); } bunch_of_lines
81 		{
82 		if (sp->num_exits + sp->num_airports < 2)
83 			yyerror("Need at least 2 airports and/or exits.");
84 		return (errors);
85 		}
86 	;
87 
88 bunch_of_defs:
89 	def bunch_of_defs
90 	| def
91 	;
92 
93 def:
94 	udef
95 	| ndef
96 	| wdef
97 	| hdef
98 	;
99 
100 udef:
101 	UpdateOp '=' ConstOp ';'
102 		{
103 		if (sp->update_secs != 0)
104 			return (yyerror("Redefinition of 'update'."));
105 		else if ($3 < 1)
106 			return (yyerror("'update' is too small."));
107 		else
108 			sp->update_secs = $3;
109 		}
110 	;
111 
112 ndef:
113 	NewplaneOp '=' ConstOp ';'
114 		{
115 		if (sp->newplane_time != 0)
116 			return (yyerror("Redefinition of 'newplane'."));
117 		else if ($3 < 1)
118 			return (yyerror("'newplane' is too small."));
119 		else
120 			sp->newplane_time = $3;
121 		}
122 	;
123 
124 hdef:
125 	HeightOp '=' ConstOp ';'
126 		{
127 		if (sp->height != 0)
128 			return (yyerror("Redefinition of 'height'."));
129 		else if ($3 < 3)
130 			return (yyerror("'height' is too small."));
131 		else
132 			sp->height = $3;
133 		}
134 	;
135 
136 wdef:
137 	WidthOp '=' ConstOp ';'
138 		{
139 		if (sp->width != 0)
140 			return (yyerror("Redefinition of 'width'."));
141 		else if ($3 < 3)
142 			return (yyerror("'width' is too small."));
143 		else
144 			sp->width = $3;
145 		}
146 	;
147 
148 bunch_of_lines:
149 	line bunch_of_lines
150 		{}
151 	| line
152 		{}
153 	;
154 
155 line:
156 	BeaconOp ':' Bpoint_list ';'
157 		{}
158 	| ExitOp ':' Epoint_list ';'
159 		{}
160 	| LineOp ':' Lline_list ';'
161 		{}
162 	| AirportOp ':' Apoint_list ';'
163 		{}
164 	;
165 
166 Bpoint_list:
167 	Bpoint Bpoint_list
168 		{}
169 	| Bpoint
170 		{}
171 	;
172 
173 Bpoint:
174 	'(' ConstOp ConstOp ')'
175 		{
176 		if (sp->num_beacons % REALLOC == 0) {
177 			if (sp->beacon == NULL)
178 				sp->beacon = (BEACON *) malloc((sp->num_beacons
179 					+ REALLOC) * sizeof (BEACON));
180 			else
181 				sp->beacon = (BEACON *) realloc(sp->beacon,
182 					(sp->num_beacons + REALLOC) *
183 					sizeof (BEACON));
184 			if (sp->beacon == NULL)
185 				return (yyerror("No memory available."));
186 		}
187 		sp->beacon[sp->num_beacons].x = $2;
188 		sp->beacon[sp->num_beacons].y = $3;
189 		check_point($2, $3);
190 		sp->num_beacons++;
191 		}
192 	;
193 
194 Epoint_list:
195 	Epoint Epoint_list
196 		{}
197 	| Epoint
198 		{}
199 	;
200 
201 Epoint:
202 	'(' ConstOp ConstOp DirOp ')'
203 		{
204 		int	dir;
205 
206 		if (sp->num_exits % REALLOC == 0) {
207 			if (sp->exit == NULL)
208 				sp->exit = (EXIT *) malloc((sp->num_exits +
209 					REALLOC) * sizeof (EXIT));
210 			else
211 				sp->exit = (EXIT *) realloc(sp->exit,
212 					(sp->num_exits + REALLOC) *
213 					sizeof (EXIT));
214 			if (sp->exit == NULL)
215 				return (yyerror("No memory available."));
216 		}
217 		dir = dir_no($4);
218 		sp->exit[sp->num_exits].x = $2;
219 		sp->exit[sp->num_exits].y = $3;
220 		sp->exit[sp->num_exits].dir = dir;
221 		check_edge($2, $3);
222 		check_edir($2, $3, dir);
223 		sp->num_exits++;
224 		}
225 	;
226 
227 Apoint_list:
228 	Apoint Apoint_list
229 		{}
230 	| Apoint
231 		{}
232 	;
233 
234 Apoint:
235 	'(' ConstOp ConstOp DirOp ')'
236 		{
237 		int	dir;
238 
239 		if (sp->num_airports % REALLOC == 0) {
240 			if (sp->airport == NULL)
241 				sp->airport=(AIRPORT *)malloc((sp->num_airports
242 					+ REALLOC) * sizeof(AIRPORT));
243 			else
244 				sp->airport = (AIRPORT *) realloc(sp->airport,
245 					(sp->num_airports + REALLOC) *
246 					sizeof(AIRPORT));
247 			if (sp->airport == NULL)
248 				return (yyerror("No memory available."));
249 		}
250 		dir = dir_no($4);
251 		sp->airport[sp->num_airports].x = $2;
252 		sp->airport[sp->num_airports].y = $3;
253 		sp->airport[sp->num_airports].dir = dir;
254 		check_point($2, $3);
255 		sp->num_airports++;
256 		}
257 	;
258 
259 Lline_list:
260 	Lline Lline_list
261 		{}
262 	| Lline
263 		{}
264 	;
265 
266 Lline:
267 	'[' '(' ConstOp ConstOp ')' '(' ConstOp ConstOp ')' ']'
268 		{
269 		if (sp->num_lines % REALLOC == 0) {
270 			if (sp->line == NULL)
271 				sp->line = (LINE *) malloc((sp->num_lines +
272 					REALLOC) * sizeof (LINE));
273 			else
274 				sp->line = (LINE *) realloc(sp->line,
275 					(sp->num_lines + REALLOC) *
276 					sizeof (LINE));
277 			if (sp->line == NULL)
278 				return (yyerror("No memory available."));
279 		}
280 		sp->line[sp->num_lines].p1.x = $3;
281 		sp->line[sp->num_lines].p1.y = $4;
282 		sp->line[sp->num_lines].p2.x = $7;
283 		sp->line[sp->num_lines].p2.y = $8;
284 		check_line($3, $4, $7, $8);
285 		sp->num_lines++;
286 		}
287 	;
288 %%
289 
290 static void
291 check_edge(int x, int y)
292 {
293 	if (!(x == 0) && !(x == sp->width - 1) &&
294 	    !(y == 0) && !(y == sp->height - 1))
295 		yyerror("edge value not on edge.");
296 }
297 
298 static void
299 check_point(int x, int y)
300 {
301 	if (x < 1 || x >= sp->width - 1)
302 		yyerror("X value out of range.");
303 	if (y < 1 || y >= sp->height - 1)
304 		yyerror("Y value out of range.");
305 }
306 
307 static void
308 check_linepoint(int x, int y)
309 {
310 	if (x < 0 || x >= sp->width)
311 		yyerror("X value out of range.");
312 	if (y < 0 || y >= sp->height)
313 		yyerror("Y value out of range.");
314 }
315 
316 static void
317 check_line(int px1, int py1, int px2, int py2)
318 {
319 	int	d1, d2;
320 
321 	check_linepoint(px1, py1);
322 	check_linepoint(px2, py2);
323 
324 	d1 = ABS(px2 - px1);
325 	d2 = ABS(py2 - py1);
326 
327 	if (!(d1 == d2) && !(d1 == 0) && !(d2 == 0))
328 		yyerror("Bad line endpoints.");
329 }
330 
331 static int
332 yyerror(const char *s)
333 {
334 	fprintf(stderr, "\"%s\": line %d: %s\n", filename, line, s);
335 	errors++;
336 
337 	return (errors);
338 }
339 
340 static void
341 check_edir(int x, int y, int dir)
342 {
343 	int	bad = 0;
344 
345 	if (x == sp->width - 1)
346 		x = 2;
347 	else if (x != 0)
348 		x = 1;
349 	if (y == sp->height - 1)
350 		y = 2;
351 	else if (y != 0)
352 		y = 1;
353 
354 	switch (x * 10 + y) {
355 	case 00: if (dir != 3) bad++; break;
356 	case 01: if (dir < 1 || dir > 3) bad++; break;
357 	case 02: if (dir != 1) bad++; break;
358 	case 10: if (dir < 3 || dir > 5) bad++; break;
359 	case 11: break;
360 	case 12: if (dir > 1 && dir < 7) bad++; break;
361 	case 20: if (dir != 5) bad++; break;
362 	case 21: if (dir < 5) bad++; break;
363 	case 22: if (dir != 7) bad++; break;
364 	default:
365 		yyerror("Unknown value in checkdir!  Get help!");
366 		break;
367 	}
368 	if (bad)
369 		yyerror("Bad direction for entrance at exit.");
370 }
371 
372 static int
373 checkdefs(void)
374 {
375 	int	error = 0;
376 
377 	if (sp->width == 0) {
378 		yyerror("'width' undefined.");
379 		error++;
380 	}
381 	if (sp->height == 0) {
382 		yyerror("'height' undefined.");
383 		error++;
384 	}
385 	if (sp->update_secs == 0) {
386 		yyerror("'update' undefined.");
387 		error++;
388 	}
389 	if (sp->newplane_time == 0) {
390 		yyerror("'newplane' undefined.");
391 		error++;
392 	}
393 	if (error)
394 		return (-1);
395 	else
396 		return (0);
397 }
398