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