SETUP/config/parser.y

   1 /*
   2  * Mach Operating System
   3  * Copyright (c) 1990 Carnegie-Mellon University
   4  * Copyright (c) 1989 Carnegie-Mellon University
   5  * Copyright (c) 1988 Carnegie-Mellon University
   6  * Copyright (c) 1987 Carnegie-Mellon University
   7  * All rights reserved.  The CMU software License Agreement specifies
   8  * the terms and conditions for use and redistribution.
   9  */
  10
  11 /*
  12  * Copyright (c) 1988 Regents of the University of California.
  13  * All rights reserved.
  14  *
  15  * Redistribution and use in source and binary forms are permitted
  16  * provided that the above copyright notice and this paragraph are
  17  * duplicated in all such forms and that any documentation,
  18  * advertising materials, and other materials related to such
  19  * distribution and use acknowledge that the software was developed
  20  * by the University of California, Berkeley.  The name of the
  21  * University may not be used to endorse or promote products derived
  22  * from this software without specific prior written permission.
  23  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  24  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  25  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  26  *
  27  *      @(#)config.y    5.8 (Berkeley) 6/18/88
  28  */
  29
  30 %union {
  31         char    *str;
  32         int     val;
  33         struct  file_list *file;
  34         struct  idlst *lst;
  35 }
  36
  37 %token  BUILDDIR
  38 %token  COMMA
  39 %token  EQUALS
  40 %token  INIT
  41 %token  MACHINE
  42 %token  OBJECTDIR
  43 %token  OPTIONS
  44 %token  MAKEOPTIONS
  45 %token  PSEUDO_DEVICE
  46 %token  SEMICOLON
  47 %token  SOURCEDIR
  48 %token  TRACE
  49
  50 %token  <str>   ID
  51 %token  <val>   NUMBER
  52
  53 %type   <str>   Save_id
  54 %type   <str>   Opt_value
  55 %type   <str>   Dev
  56
  57 %{
  58
  59 #include "config.h"
  60 #include <ctype.h>
  61 #include <stdio.h>
  62
  63 struct  device cur;
  64 struct  device *curp = 0;
  65 char    *temp_id;
  66 char    *val_id;
  67 /* char *malloc(); */
  68
  69 int yylex(void);
  70
  71 void deverror(const char *systemname, const char *devtype);
  72
  73 %}
  74 %%
  75 Configuration:
  76         Many_specs
  77                 ;
  78
  79 Many_specs:
  80         Many_specs Spec
  81                 |
  82         /* lambda */
  83                 ;
  84
  85 Spec:
  86         Device_spec SEMICOLON
  87               { newdev(&cur); } |
  88         Config_spec SEMICOLON
  89                 |
  90         TRACE SEMICOLON
  91               { do_trace = !do_trace; } |
  92         SEMICOLON
  93                 |
  94         error SEMICOLON
  95                 ;
  96
  97 Config_spec:
  98         MACHINE Save_id
  99                 { machinename = ns($2); }
 100                 |
 101         OPTIONS Opt_list
 102                 |
 103         MAKEOPTIONS Mkopt_list
 104                 |
 105         BUILDDIR Save_id
 106                 { build_directory = ns($2); }
 107                 |
 108         OBJECTDIR Save_id
 109                 { object_directory = ns($2); }
 110                 |
 111         SOURCEDIR Save_id
 112                 { source_directory = ns($2); }
 113                 ;
 114
 115
 116 Opt_list:
 117         Opt_list COMMA Option
 118                 |
 119         Option
 120                 ;
 121
 122 Option:
 123         Save_id
 124               {
 125                 struct opt *op = (struct opt *)malloc(sizeof (struct opt));
 126                 op->op_name = ns($1);
 127                 op->op_next = (struct opt *) 0;
 128                 op->op_value = 0;
 129                 if (opt == (struct opt *) 0)
 130                         opt = op;
 131                 else
 132                         opt_tail->op_next = op;
 133                 opt_tail = op;
 134                 free(temp_id);
 135               } |
 136         Save_id EQUALS Opt_value
 137               {
 138                 struct opt *op = (struct opt *)malloc(sizeof (struct opt));
 139                 op->op_name = ns($1);
 140                 op->op_next = (struct opt *) 0;
 141                 op->op_value = ns($3);
 142                 if (opt == (struct opt *) 0)
 143                         opt = op;
 144                 else
 145                         opt_tail->op_next = op;
 146                 opt_tail = op;
 147                 free(temp_id);
 148                 if (val_id)
 149                         free(val_id);
 150               } ;
 151
 152 Opt_value:
 153         ID
 154               { $$ = val_id = ns($1); } |
 155         NUMBER
 156               { char nb[16];
 157                   (void) sprintf(nb, "%u", $1);
 158                   $$ = val_id = ns(nb);
 159               } |
 160         /* lambda from MIPS -- WHY */
 161               { $$ = val_id = ns(""); }
 162               ;
 163
 164 Save_id:
 165         ID
 166               { $$ = temp_id = ns($1); }
 167         ;
 168
 169 Mkopt_list:
 170         Mkopt_list COMMA Mkoption
 171                 |
 172         Mkoption
 173                 ;
 174
 175 Mkoption:
 176         Save_id
 177               {
 178                 struct opt *op = (struct opt *)malloc(sizeof (struct opt));
 179                 op->op_name = ns($1);
 180                 op->op_next =  (struct opt *) 0;
 181                 op->op_value = 0;
 182                 mkopt = op;
 183                 free(temp_id);
 184               } |
 185         Save_id EQUALS Opt_value
 186               {
 187                 struct opt *op = (struct opt *)malloc(sizeof (struct opt));
 188                 op->op_name = ns($1);
 189                 op->op_next =  (struct opt *) 0;
 190                 op->op_value = ns($3);
 191                 if (mkopt == (struct opt *) 0)
 192                         mkopt = op;
 193                 else
 194                         mkopt_tail->op_next = op;
 195                 mkopt_tail = op;
 196                 free(temp_id);
 197                 if (val_id)
 198                         free(val_id);
 199               } ;
 200
 201 Dev:
 202         ID
 203               { $$ = ns($1); }
 204         ;
 205
 206 Device_spec:
 207         PSEUDO_DEVICE Init_dev Dev
 208               {
 209                 cur.d_name = $3;
 210                 cur.d_type = PSEUDO_DEVICE;
 211                 } |
 212         PSEUDO_DEVICE Init_dev Dev NUMBER
 213               {
 214                 cur.d_name = $3;
 215                 cur.d_type = PSEUDO_DEVICE;
 216                 cur.d_slave = $4;
 217                 } |
 218         PSEUDO_DEVICE Init_dev Dev INIT ID
 219               {
 220                 cur.d_name = $3;
 221                 cur.d_type = PSEUDO_DEVICE;
 222                 cur.d_init = ns($5);
 223                 } |
 224         PSEUDO_DEVICE Init_dev Dev NUMBER INIT ID
 225               {
 226                 cur.d_name = $3;
 227                 cur.d_type = PSEUDO_DEVICE;
 228                 cur.d_slave = $4;
 229                 cur.d_init = ns($6);
 230                 };
 231
 232 Init_dev:
 233         /* lambda */
 234               { init_dev(&cur); };
 235
 236 %%
 237
 238 void
 239 yyerror(const char *s)
 240 {
 241         fprintf(stderr, "config: line %d: %s\n", yyline, s);
 242 }
 243
 244 /*
 245  * return the passed string in a new space
 246  */
 247 char *
 248 ns(const char *str)
 249 {
 250         register char *cp;
 251
 252         cp = malloc((unsigned)(strlen(str)+1));
 253         (void) strcpy(cp, str);
 254         return (cp);
 255 }
 256
 257 /*
 258  * add a device to the list of devices
 259  */
 260 void
 261 newdev(struct device *dp)
 262 {
 263         register struct device *np;
 264
 265         np = (struct device *) malloc(sizeof *np);
 266         *np = *dp;
 267         if (curp == 0)
 268                 dtab = np;
 269         else
 270                 curp->d_next = np;
 271         curp = np;
 272         curp->d_next = 0;
 273 }
 274
 275 void
 276 init_dev(struct device *dp)
 277 {
 278
 279         dp->d_name = "OHNO!!!";
 280         dp->d_type = PSEUDO_DEVICE;
 281         dp->d_flags = 0;
 282         dp->d_slave = UNKNOWN;
 283         dp->d_init = 0;
 284 }
 285
 286 void
 287 deverror(const char *systemname, const char *devtype)
 288 {
 289
 290         fprintf(stderr, "config: %s: %s device not configured\n",
 291                 systemname, devtype);
 292 }