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