games/atc/grammar.y

   1 /*-
   2  * Copyright (c) 1990, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Ed James.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * @(#)grammar.y        8.1 (Berkeley) 5/31/93
  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 #if YYPATCH < 20180510
  63 extern int      yylex(void);
  64 #endif
  65
  66 static void     check_edge(int, int);
  67 static void     check_point(int, int);
  68 static void     check_linepoint(int, int);
  69 static void     check_line(int, int, int, int);
  70 static int      yyerror(const char *);
  71 static void     check_edir(int, int, int);
  72 static int      checkdefs(void);
  73
  74 int     errors = 0;
  75 int     line = 1;
  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->height != 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 = malloc((sp->num_beacons + REALLOC)
 179                                         * sizeof(BEACON));
 180                         else
 181                                 sp->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 = malloc((sp->num_exits + REALLOC) *
 209                                         sizeof(EXIT));
 210                         else
 211                                 sp->exit = realloc(sp->exit, (sp->num_exits +
 212                                         REALLOC) * sizeof(EXIT));
 213                         if (sp->exit == NULL)
 214                                 return (yyerror("No memory available."));
 215                 }
 216                 dir = dir_no($4);
 217                 sp->exit[sp->num_exits].x = $2;
 218                 sp->exit[sp->num_exits].y = $3;
 219                 sp->exit[sp->num_exits].dir = dir;
 220                 check_edge($2, $3);
 221                 check_edir($2, $3, dir);
 222                 sp->num_exits++;
 223                 }
 224         ;
 225
 226 Apoint_list:
 227         Apoint Apoint_list
 228                 {}
 229         | Apoint
 230                 {}
 231         ;
 232
 233 Apoint:
 234         '(' ConstOp ConstOp DirOp ')'
 235                 {
 236                 int     dir;
 237
 238                 if (sp->num_airports % REALLOC == 0) {
 239                         if (sp->airport == NULL)
 240                                 sp->airport = malloc((sp->num_airports +
 241                                         REALLOC) * sizeof(AIRPORT));
 242                         else
 243                                 sp->airport = realloc(sp->airport,
 244                                         (sp->num_airports + REALLOC) *
 245                                         sizeof(AIRPORT));
 246                         if (sp->airport == NULL)
 247                                 return (yyerror("No memory available."));
 248                 }
 249                 dir = dir_no($4);
 250                 sp->airport[sp->num_airports].x = $2;
 251                 sp->airport[sp->num_airports].y = $3;
 252                 sp->airport[sp->num_airports].dir = dir;
 253                 check_point($2, $3);
 254                 sp->num_airports++;
 255                 }
 256         ;
 257
 258 Lline_list:
 259         Lline Lline_list
 260                 {}
 261         | Lline
 262                 {}
 263         ;
 264
 265 Lline:
 266         '[' '(' ConstOp ConstOp ')' '(' ConstOp ConstOp ')' ']'
 267                 {
 268                 if (sp->num_lines % REALLOC == 0) {
 269                         if (sp->line == NULL)
 270                                 sp->line = malloc((sp->num_lines + REALLOC) *
 271                                         sizeof(LINE));
 272                         else
 273                                 sp->line = realloc(sp->line, (sp->num_lines +
 274                                         REALLOC) * sizeof(LINE));
 275                         if (sp->line == NULL)
 276                                 return (yyerror("No memory available."));
 277                 }
 278                 sp->line[sp->num_lines].p1.x = $3;
 279                 sp->line[sp->num_lines].p1.y = $4;
 280                 sp->line[sp->num_lines].p2.x = $7;
 281                 sp->line[sp->num_lines].p2.y = $8;
 282                 check_line($3, $4, $7, $8);
 283                 sp->num_lines++;
 284                 }
 285         ;
 286 %%
 287
 288 static void
 289 check_edge(int x, int y)
 290 {
 291         if (!(x == 0) && !(x == sp->width - 1) &&
 292             !(y == 0) && !(y == sp->height - 1))
 293                 yyerror("edge value not on edge.");
 294 }
 295
 296 static void
 297 check_point(int x, int y)
 298 {
 299         if (x < 1 || x >= sp->width - 1)
 300                 yyerror("X value out of range.");
 301         if (y < 1 || y >= sp->height - 1)
 302                 yyerror("Y value out of range.");
 303 }
 304
 305 static void
 306 check_linepoint(int x, int y)
 307 {
 308         if (x < 0 || x >= sp->width)
 309                 yyerror("X value out of range.");
 310         if (y < 0 || y >= sp->height)
 311                 yyerror("Y value out of range.");
 312 }
 313
 314 static void
 315 check_line(int x_1, int y_1, int x_2, int y_2)
 316 {
 317         int     d1, d2;
 318
 319         check_linepoint(x_1, y_1);
 320         check_linepoint(x_2, y_2);
 321
 322         d1 = ABS(x_2 - x_1);
 323         d2 = ABS(y_2 - y_1);
 324
 325         if (!(d1 == d2) && !(d1 == 0) && !(d2 == 0))
 326                 yyerror("Bad line endpoints.");
 327 }
 328
 329 static int
 330 yyerror(const char *s)
 331 {
 332         fprintf(stderr, "\"%s\": line %d: %s\n", filename, line, s);
 333         errors++;
 334
 335         return (errors);
 336 }
 337
 338 static void
 339 check_edir(int x, int y, int dir)
 340 {
 341         int     bad = 0;
 342
 343         if (x == sp->width - 1)
 344                 x = 2;
 345         else if (x != 0)
 346                 x = 1;
 347         if (y == sp->height - 1)
 348                 y = 2;
 349         else if (y != 0)
 350                 y = 1;
 351
 352         switch (x * 10 + y) {
 353         case 00: if (dir != 3) bad++; break;
 354         case 01: if (dir < 1 || dir > 3) bad++; break;
 355         case 02: if (dir != 1) bad++; break;
 356         case 10: if (dir < 3 || dir > 5) bad++; break;
 357         case 11: break;
 358         case 12: if (dir > 1 && dir < 7) bad++; break;
 359         case 20: if (dir != 5) bad++; break;
 360         case 21: if (dir < 5) bad++; break;
 361         case 22: if (dir != 7) bad++; break;
 362         default:
 363                 yyerror("Unknown value in checkdir!  Get help!");
 364                 break;
 365         }
 366         if (bad)
 367                 yyerror("Bad direction for entrance at exit.");
 368 }
 369
 370 static int
 371 checkdefs(void)
 372 {
 373         int     err = 0;
 374
 375         if (sp->width == 0) {
 376                 yyerror("'width' undefined.");
 377                 err++;
 378         }
 379         if (sp->height == 0) {
 380                 yyerror("'height' undefined.");
 381                 err++;
 382         }
 383         if (sp->update_secs == 0) {
 384                 yyerror("'update' undefined.");
 385                 err++;
 386         }
 387         if (sp->newplane_time == 0) {
 388                 yyerror("'newplane' undefined.");
 389                 err++;
 390         }
 391         if (err)
 392                 return (-1);
 393         else
 394                 return (0);
 395 }