atc/grammar.y

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