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