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