1%union { 2 char *str; 3 int val; 4 struct file_list *file; 5} 6 7%token ARCH 8%token COMMA 9%token CONFIG 10%token CPU 11%token DEVICE
| 1%union { 2 char *str; 3 int val; 4 struct file_list *file; 5} 6 7%token ARCH 8%token COMMA 9%token CONFIG 10%token CPU 11%token DEVICE
|
| 12%token NODEVICE
|
12%token ENV 13%token EQUALS 14%token HINTS 15%token IDENT 16%token MAXUSERS
| 13%token ENV 14%token EQUALS 15%token HINTS 16%token IDENT 17%token MAXUSERS
|
17%token NODEVICE
| |
18%token PROFILE 19%token OPTIONS
| 18%token PROFILE 19%token OPTIONS
|
| 20%token NOOPTION
|
20%token MAKEOPTIONS
| 21%token MAKEOPTIONS
|
| 22%token NOMAKEOPTION
|
21%token SEMICOLON 22%token INCLUDE 23 24%token <str> ID 25%token <val> NUMBER 26 27%type <str> Save_id 28%type <str> Opt_value 29%type <str> Dev 30 31%{ 32 33/* 34 * Copyright (c) 1988, 1993 35 * The Regents of the University of California. All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 3. All advertising materials mentioning features or use of this software 46 * must display the following acknowledgement: 47 * This product includes software developed by the University of 48 * California, Berkeley and its contributors. 49 * 4. Neither the name of the University nor the names of its contributors 50 * may be used to endorse or promote products derived from this software 51 * without specific prior written permission. 52 * 53 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 54 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 55 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 56 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 57 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 58 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 59 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 60 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 61 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 62 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 63 * SUCH DAMAGE. 64 * 65 * @(#)config.y 8.1 (Berkeley) 6/6/93
| 23%token SEMICOLON 24%token INCLUDE 25 26%token <str> ID 27%token <val> NUMBER 28 29%type <str> Save_id 30%type <str> Opt_value 31%type <str> Dev 32 33%{ 34 35/* 36 * Copyright (c) 1988, 1993 37 * The Regents of the University of California. All rights reserved. 38 * 39 * Redistribution and use in source and binary forms, with or without 40 * modification, are permitted provided that the following conditions 41 * are met: 42 * 1. Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * 2. Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in the 46 * documentation and/or other materials provided with the distribution. 47 * 3. All advertising materials mentioning features or use of this software 48 * must display the following acknowledgement: 49 * This product includes software developed by the University of 50 * California, Berkeley and its contributors. 51 * 4. Neither the name of the University nor the names of its contributors 52 * may be used to endorse or promote products derived from this software 53 * without specific prior written permission. 54 * 55 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 56 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 57 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 58 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 59 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 60 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 61 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 62 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 63 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 64 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 65 * SUCH DAMAGE. 66 * 67 * @(#)config.y 8.1 (Berkeley) 6/6/93
|
66 * $FreeBSD: head/usr.sbin/config/config.y 111230 2003-02-21 23:17:00Z ru $
| 68 * $FreeBSD: head/usr.sbin/config/config.y 111582 2003-02-26 23:36:59Z ru $
|
67 */ 68 69#include <ctype.h> 70#include <err.h> 71#include <stdio.h> 72#include <string.h> 73 74#include "config.h" 75 76struct device_head dtab; 77char *ident; 78char *env; 79int envmode; 80char *hints; 81int hintmode; 82int yyline; 83const char *yyfile; 84struct file_list_head ftab; 85char errbuf[80]; 86int maxusers; 87 88#define ns(s) strdup(s) 89int include(const char *, int); 90void yyerror(const char *s); 91 92static char * 93devopt(char *dev) 94{ 95 char *ret = malloc(strlen(dev) + 5); 96 97 sprintf(ret, "DEV_%s", dev); 98 raisestr(ret); 99 return ret; 100} 101 102%} 103%% 104Configuration: 105 Many_specs 106 ; 107 108Many_specs: 109 Many_specs Spec 110 | 111 /* lambda */ 112 ; 113 114Spec: 115 Device_spec SEMICOLON 116 | 117 Config_spec SEMICOLON 118 | 119 SEMICOLON 120 | 121 error SEMICOLON 122 ; 123 124Config_spec: 125 ARCH Save_id 126 = { 127 machinename = $2; 128 } | 129 CPU Save_id 130 = { 131 struct cputype *cp = 132 (struct cputype *)malloc(sizeof (struct cputype)); 133 memset(cp, 0, sizeof(*cp)); 134 cp->cpu_name = $2; 135 SLIST_INSERT_HEAD(&cputype, cp, cpu_next); 136 } | 137 OPTIONS Opt_list 138 |
| 69 */ 70 71#include <ctype.h> 72#include <err.h> 73#include <stdio.h> 74#include <string.h> 75 76#include "config.h" 77 78struct device_head dtab; 79char *ident; 80char *env; 81int envmode; 82char *hints; 83int hintmode; 84int yyline; 85const char *yyfile; 86struct file_list_head ftab; 87char errbuf[80]; 88int maxusers; 89 90#define ns(s) strdup(s) 91int include(const char *, int); 92void yyerror(const char *s); 93 94static char * 95devopt(char *dev) 96{ 97 char *ret = malloc(strlen(dev) + 5); 98 99 sprintf(ret, "DEV_%s", dev); 100 raisestr(ret); 101 return ret; 102} 103 104%} 105%% 106Configuration: 107 Many_specs 108 ; 109 110Many_specs: 111 Many_specs Spec 112 | 113 /* lambda */ 114 ; 115 116Spec: 117 Device_spec SEMICOLON 118 | 119 Config_spec SEMICOLON 120 | 121 SEMICOLON 122 | 123 error SEMICOLON 124 ; 125 126Config_spec: 127 ARCH Save_id 128 = { 129 machinename = $2; 130 } | 131 CPU Save_id 132 = { 133 struct cputype *cp = 134 (struct cputype *)malloc(sizeof (struct cputype)); 135 memset(cp, 0, sizeof(*cp)); 136 cp->cpu_name = $2; 137 SLIST_INSERT_HEAD(&cputype, cp, cpu_next); 138 } | 139 OPTIONS Opt_list 140 |
|
| 141 NOOPTION Save_id 142 = { rmopt(&opt, $2); } |
|
139 MAKEOPTIONS Mkopt_list 140 |
| 143 MAKEOPTIONS Mkopt_list 144 |
|
| 145 NOMAKEOPTION Save_id 146 = { rmopt(&mkopt, $2); } |
|
141 IDENT ID 142 = { ident = $2; } | 143 System_spec 144 | 145 MAXUSERS NUMBER 146 = { maxusers = $2; } | 147 PROFILE NUMBER 148 = { profiling = $2; } | 149 ENV ID 150 = { 151 env = $2; 152 envmode = 1; 153 } | 154 HINTS ID 155 = { 156 hints = $2; 157 hintmode = 1; 158 } | 159 INCLUDE ID 160 = { include($2, 0); }; 161 162System_spec: 163 CONFIG System_id System_parameter_list 164 = { errx(1, "%s:%d: root/dump/swap specifications obsolete", 165 yyfile, yyline);} 166 | 167 CONFIG System_id 168 ; 169 170System_id: 171 Save_id 172 = { newopt(&mkopt, ns("KERNEL"), $1); }; 173 174System_parameter_list: 175 System_parameter_list ID 176 | ID 177 ; 178 179Opt_list: 180 Opt_list COMMA Option 181 | 182 Option 183 ; 184 185Option: 186 Save_id 187 = { 188 char *s; 189 190 newopt(&opt, $1, NULL); 191 if ((s = strchr($1, '='))) 192 errx(1, "%s:%d: The `=' in options should not be " 193 "quoted", yyfile, yyline); 194 } | 195 Save_id EQUALS Opt_value 196 = { 197 newopt(&opt, $1, $3); 198 } ; 199 200Opt_value: 201 ID 202 = { $$ = $1; } | 203 NUMBER 204 = { 205 char buf[80]; 206 207 (void) snprintf(buf, sizeof(buf), "%d", $1); 208 $$ = ns(buf); 209 } ; 210 211Save_id: 212 ID 213 = { $$ = $1; } 214 ; 215 216Mkopt_list: 217 Mkopt_list COMMA Mkoption 218 | 219 Mkoption 220 ; 221 222Mkoption: 223 Save_id 224 = { newopt(&mkopt, $1, ns("")); } | 225 Save_id EQUALS Opt_value 226 = { newopt(&mkopt, $1, $3); } ; 227 228Dev: 229 ID 230 = { $$ = $1; } 231 ; 232 233Device_spec: 234 DEVICE Dev 235 = { 236 newopt(&opt, devopt($2), ns("1")); 237 /* and the device part */ 238 newdev($2, UNKNOWN); 239 } | 240 DEVICE Dev NUMBER 241 = { 242 newopt(&opt, devopt($2), ns("1")); 243 /* and the device part */ 244 newdev($2, $3); 245 if ($3 == 0) 246 errx(1, "%s:%d: devices with zero units are not " 247 "likely to be correct", yyfile, yyline); 248 } | 249 NODEVICE Dev 250 = {
| 147 IDENT ID 148 = { ident = $2; } | 149 System_spec 150 | 151 MAXUSERS NUMBER 152 = { maxusers = $2; } | 153 PROFILE NUMBER 154 = { profiling = $2; } | 155 ENV ID 156 = { 157 env = $2; 158 envmode = 1; 159 } | 160 HINTS ID 161 = { 162 hints = $2; 163 hintmode = 1; 164 } | 165 INCLUDE ID 166 = { include($2, 0); }; 167 168System_spec: 169 CONFIG System_id System_parameter_list 170 = { errx(1, "%s:%d: root/dump/swap specifications obsolete", 171 yyfile, yyline);} 172 | 173 CONFIG System_id 174 ; 175 176System_id: 177 Save_id 178 = { newopt(&mkopt, ns("KERNEL"), $1); }; 179 180System_parameter_list: 181 System_parameter_list ID 182 | ID 183 ; 184 185Opt_list: 186 Opt_list COMMA Option 187 | 188 Option 189 ; 190 191Option: 192 Save_id 193 = { 194 char *s; 195 196 newopt(&opt, $1, NULL); 197 if ((s = strchr($1, '='))) 198 errx(1, "%s:%d: The `=' in options should not be " 199 "quoted", yyfile, yyline); 200 } | 201 Save_id EQUALS Opt_value 202 = { 203 newopt(&opt, $1, $3); 204 } ; 205 206Opt_value: 207 ID 208 = { $$ = $1; } | 209 NUMBER 210 = { 211 char buf[80]; 212 213 (void) snprintf(buf, sizeof(buf), "%d", $1); 214 $$ = ns(buf); 215 } ; 216 217Save_id: 218 ID 219 = { $$ = $1; } 220 ; 221 222Mkopt_list: 223 Mkopt_list COMMA Mkoption 224 | 225 Mkoption 226 ; 227 228Mkoption: 229 Save_id 230 = { newopt(&mkopt, $1, ns("")); } | 231 Save_id EQUALS Opt_value 232 = { newopt(&mkopt, $1, $3); } ; 233 234Dev: 235 ID 236 = { $$ = $1; } 237 ; 238 239Device_spec: 240 DEVICE Dev 241 = { 242 newopt(&opt, devopt($2), ns("1")); 243 /* and the device part */ 244 newdev($2, UNKNOWN); 245 } | 246 DEVICE Dev NUMBER 247 = { 248 newopt(&opt, devopt($2), ns("1")); 249 /* and the device part */ 250 newdev($2, $3); 251 if ($3 == 0) 252 errx(1, "%s:%d: devices with zero units are not " 253 "likely to be correct", yyfile, yyline); 254 } | 255 NODEVICE Dev 256 = {
|
251 rmopt(&opt, devopt($2));
| 257 char *s = devopt($2); 258 259 rmopt(&opt, s); 260 free(s);
|
252 /* and the device part */ 253 rmdev($2); 254 } ; 255 256%% 257 258void 259yyerror(const char *s) 260{ 261 262 errx(1, "%s:%d: %s", yyfile, yyline + 1, s); 263} 264 265/* 266 * add a device to the list of devices 267 */ 268static void 269newdev(char *name, int count) 270{ 271 struct device *np; 272 273 np = (struct device *) malloc(sizeof *np); 274 memset(np, 0, sizeof(*np)); 275 np->d_name = name; 276 np->d_count = count; 277 STAILQ_INSERT_TAIL(&dtab, np, d_next); 278} 279 280/* 281 * remove a device from the list of devices 282 */ 283static void 284rmdev(char *name) 285{ 286 struct device *dp, *rmdp; 287 288 STAILQ_FOREACH(dp, &dtab, d_next) { 289 if (eq(dp->d_name, name)) { 290 rmdp = dp; 291 dp = STAILQ_NEXT(dp, d_next); 292 STAILQ_REMOVE(&dtab, rmdp, device, d_next); 293 free(rmdp->d_name); 294 free(rmdp); 295 if (dp == NULL) 296 break; 297 } 298 } 299} 300 301static void 302newopt(struct opt_head *list, char *name, char *value) 303{ 304 struct opt *op; 305 306 op = (struct opt *)malloc(sizeof (struct opt)); 307 memset(op, 0, sizeof(*op)); 308 op->op_name = name; 309 op->op_ownfile = 0; 310 op->op_value = value; 311 SLIST_INSERT_HEAD(list, op, op_next); 312} 313 314static void 315rmopt(struct opt_head *list, char *name) 316{ 317 struct opt *op, *rmop; 318 319 SLIST_FOREACH(op, list, op_next) { 320 if (eq(op->op_name, name)) { 321 rmop = op; 322 op = SLIST_NEXT(op, op_next); 323 SLIST_REMOVE(list, rmop, opt, op_next); 324 free(rmop->op_name); 325 if (rmop->op_value != NULL) 326 free(rmop->op_value); 327 free(rmop); 328 if (op == NULL) 329 break; 330 } 331 } 332}
| 261 /* and the device part */ 262 rmdev($2); 263 } ; 264 265%% 266 267void 268yyerror(const char *s) 269{ 270 271 errx(1, "%s:%d: %s", yyfile, yyline + 1, s); 272} 273 274/* 275 * add a device to the list of devices 276 */ 277static void 278newdev(char *name, int count) 279{ 280 struct device *np; 281 282 np = (struct device *) malloc(sizeof *np); 283 memset(np, 0, sizeof(*np)); 284 np->d_name = name; 285 np->d_count = count; 286 STAILQ_INSERT_TAIL(&dtab, np, d_next); 287} 288 289/* 290 * remove a device from the list of devices 291 */ 292static void 293rmdev(char *name) 294{ 295 struct device *dp, *rmdp; 296 297 STAILQ_FOREACH(dp, &dtab, d_next) { 298 if (eq(dp->d_name, name)) { 299 rmdp = dp; 300 dp = STAILQ_NEXT(dp, d_next); 301 STAILQ_REMOVE(&dtab, rmdp, device, d_next); 302 free(rmdp->d_name); 303 free(rmdp); 304 if (dp == NULL) 305 break; 306 } 307 } 308} 309 310static void 311newopt(struct opt_head *list, char *name, char *value) 312{ 313 struct opt *op; 314 315 op = (struct opt *)malloc(sizeof (struct opt)); 316 memset(op, 0, sizeof(*op)); 317 op->op_name = name; 318 op->op_ownfile = 0; 319 op->op_value = value; 320 SLIST_INSERT_HEAD(list, op, op_next); 321} 322 323static void 324rmopt(struct opt_head *list, char *name) 325{ 326 struct opt *op, *rmop; 327 328 SLIST_FOREACH(op, list, op_next) { 329 if (eq(op->op_name, name)) { 330 rmop = op; 331 op = SLIST_NEXT(op, op_next); 332 SLIST_REMOVE(list, rmop, opt, op_next); 333 free(rmop->op_name); 334 if (rmop->op_value != NULL) 335 free(rmop->op_value); 336 free(rmop); 337 if (op == NULL) 338 break; 339 } 340 } 341}
|