atc/grammar.y

   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 }