![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to config.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / config|
Return to config.y CVS log | Up to [Research Unix] / researchv8dc / cmd / config |
1.1 root 1: %union {
2: int i;
3: char *cp;
4: struct idlst *idlst;
5: }
6: %token CPU IDENT CONFIG ANY DEVICE UBA MBA NEXUS CSR DRIVE VECTOR OPTIONS
7: %token CONTROLLER PSEUDO_DEVICE FLAGS ID SEMICOLON NUMBER FPNUMBER TRACE
8: %token DISK SLAVE AT HZ TIMEZONE DST MAXUSERS MASTER COMMA MINUS
9: %type <cp> Save_id ID Dev
10: %type <i> NUMBER FPNUMBER
11: %type <idlst> Id_list
12: %{
13: /* config.y 1.11 81/05/22 */
14: #include "config.h"
15: #include <stdio.h>
16: struct device cur;
17: struct device *curp = NULL;
18: char *temp_id;
19: %}
20: %%
21: Configuration:
22: Many_specs
23: ;
24:
25: Many_specs:
26: Many_specs Spec
27: |
28: ;
29:
30: Spec:
31: Device_spec SEMICOLON = { newdev(&cur); } |
32: Config_spec SEMICOLON |
33: TRACE SEMICOLON = { do_trace = ! do_trace; } |
34: SEMICOLON |
35: error SEMICOLON
36: ;
37:
38: Config_spec:
39: CPU Save_id = {
40: struct cputype *cp = (struct cputype *)malloc(sizeof (struct cputype));
41: cp->cpu_name = ns($2);
42: cp->cpu_next = cputype;
43: cputype = cp;
44: free(temp_id);
45: } |
46: OPTIONS Opt_list |
47: IDENT ID { ident = ns($2); } |
48: CONFIG Save_id ID = { mkconf(temp_id, $3); free(temp_id); } |
49: HZ NUMBER = {
50: yyerror("HZ specification obsolete; delete");
51: hz = 60;
52: } |
53: TIMEZONE NUMBER = { timezone = 60 * $2; check_tz(); } |
54: TIMEZONE NUMBER DST = { timezone = 60 * $2; dst = 1; check_tz(); } |
55: TIMEZONE FPNUMBER = { timezone = $2; check_tz(); } |
56: TIMEZONE FPNUMBER DST = { timezone = $2; dst = 1; check_tz(); } |
57: MINUS TIMEZONE NUMBER =
58: { timezone = -60 * $3; check_tz(); } |
59: MINUS TIMEZONE NUMBER DST =
60: { timezone = -60 * $3; dst = 1; check_tz(); } |
61: MINUS TIMEZONE FPNUMBER =
62: { timezone = -$3; check_tz(); } |
63: MINUS TIMEZONE FPNUMBER DST =
64: { timezone = -$3; dst = 1; check_tz(); } |
65: MAXUSERS NUMBER = { maxusers = $2; }
66: ;
67:
68: Opt_list:
69: Opt_list COMMA Option |
70: Option
71: ;
72:
73: Option:
74: Save_id = {
75: struct opt *op = (struct opt *)malloc(sizeof (struct opt));
76: op->op_name = ns($1);
77: op->op_next = opt;
78: opt = op;
79: free(temp_id);
80: }
81: ;
82:
83: Save_id:
84: ID = { $$ = temp_id = ns($1); }
85: ;
86:
87: Dev:
88: UBA = { $$ = ns("uba"); } |
89: MBA = { $$ = ns("mba"); } |
90: ID = { $$ = ns($1); }
91: ;
92:
93: Device_spec:
94: DEVICE Dev_name Dev_info Int_spec = { cur.d_type = DEVICE; } |
95: MASTER Dev_name Dev_info Int_spec = { cur.d_type = MASTER; } |
96: DISK Dev_name Dev_info Int_spec =
97: { cur.d_dk = 1; cur.d_type = DEVICE; } |
98: CONTROLLER Dev_name Dev_info Int_spec = { cur.d_type = CONTROLLER; } |
99: PSEUDO_DEVICE Init_dev Dev =
100: { cur.d_name = $3; cur.d_type = PSEUDO_DEVICE; } |
101: PSEUDO_DEVICE Init_dev Dev NUMBER =
102: { cur.d_name = $3; cur.d_type = PSEUDO_DEVICE;
103: cur.d_count = $4; }
104: ;
105:
106: Dev_name:
107: Init_dev Dev NUMBER = {
108: cur.d_name = $2;
109: if (eq($2, "mba"))
110: seen_mba = TRUE;
111: else if (eq($2, "uba"))
112: seen_uba = TRUE;
113: cur.d_unit = $3;
114: }
115: ;
116:
117: Init_dev:
118: = { init_dev(&cur); }
119: ;
120:
121: Dev_info:
122: Con_info Info_list
123: |
124: ;
125:
126: Con_info:
127: AT Dev NUMBER = {
128: if (eq(cur.d_name, "mba") || eq(cur.d_name, "uba")) {
129: sprintf(errbuf,
130: "%s must be connected to a nexus", cur.d_name);
131: yyerror(errbuf);
132: }
133: cur.d_conn = connect($2, $3);
134: } |
135: AT NEXUS NUMBER = { check_nexus(&cur, $3); cur.d_conn = TO_NEXUS; }
136: ;
137:
138: Info_list:
139: Info_list Info
140: |
141: ;
142:
143: Info:
144: CSR NUMBER = { cur.d_addr = $2; } |
145: DRIVE NUMBER = { cur.d_drive = $2; } |
146: SLAVE NUMBER =
147: {
148: if (cur.d_conn != NULL && cur.d_conn != TO_NEXUS
149: && cur.d_conn->d_type == MASTER)
150: cur.d_slave = $2;
151: else
152: yyerror("can't specify slave--not to master");
153: } |
154: FLAGS NUMBER = { cur.d_flags = $2; }
155: ;
156:
157: Int_spec:
158: VECTOR Id_list = { cur.d_vec = $2; } | ;
159:
160: Id_list:
161: Save_id =
162: { struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst));
163: a->id = $1; a->id_next = 0; $$ = a; } |
164: Save_id Id_list =
165: { struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst));
166: a->id = $1; a->id_next = $2; $$ = a; } ;
167: %%
168:
169: yyerror(s)
170: char *s;
171: {
172: fprintf(stderr, "config: %s at line %d\n", s, yyline);
173: }
174:
175: /*
176: * ns:
177: * Return the passed string in a new space
178: */
179:
180: char *
181: ns(str)
182: register char *str;
183: {
184: register char *cp;
185:
186: cp = malloc(strlen(str)+1);
187: strcpy(cp, str);
188: return cp;
189: }
190:
191: /*
192: * newdev
193: * Add a device to the list
194: */
195:
196: newdev(dp)
197: register struct device *dp;
198: {
199: register struct device *np;
200:
201: np = (struct device *) malloc(sizeof *np);
202: *np = *dp;
203: if (curp == NULL)
204: dtab = np;
205: else
206: curp->d_next = np;
207: curp = np;
208: }
209:
210: /*
211: * mkconf
212: * Note that a configuration should be made
213: */
214:
215: mkconf(dev, sysname)
216: char *dev, *sysname;
217: {
218: register struct file_list *fl;
219:
220: fl = (struct file_list *) malloc(sizeof *fl);
221: fl->f_fn = ns(dev);
222: fl->f_needs = ns(sysname);
223: if (confp == NULL)
224: conf_list = fl;
225: else
226: confp->f_next = fl;
227: confp = fl;
228: }
229:
230: /*
231: * Connect:
232: * Find the pointer to connect to the given device and number.
233: * returns NULL if no such device and prints an error message
234: */
235:
236: struct device *connect(dev, num)
237: register char *dev;
238: register int num;
239: {
240: register struct device *dp;
241: struct device *huhcon();
242:
243: if (num == QUES)
244: return huhcon(dev);
245: for (dp = dtab; dp != NULL; dp = dp->d_next)
246: if ((num == dp->d_unit) && eq(dev, dp->d_name))
247: if (dp->d_type != CONTROLLER && dp->d_type != MASTER)
248: {
249: sprintf(errbuf, "%s connected to non-controller", dev);
250: yyerror(errbuf);
251: return NULL;
252: }
253: else
254: return dp;
255: sprintf(errbuf, "%s %d not defined", dev, num);
256: yyerror(errbuf);
257: return NULL;
258: }
259:
260: /*
261: * huhcon
262: * Connect to an unspecific thing
263: */
264:
265: struct device *huhcon(dev)
266: register char *dev;
267: {
268: register struct device *dp, *dcp;
269: struct device rdev;
270: int oldtype;
271:
272: /*
273: * First make certain that there are some of these to wildcard on
274: */
275: for (dp = dtab; dp != NULL; dp = dp->d_next)
276: if (eq(dp->d_name, dev))
277: break;
278: if (dp == NULL)
279: {
280: sprintf(errbuf, "no %s's to wildcard", dev);
281: yyerror(errbuf);
282: return NULL;
283: }
284: oldtype = dp->d_type;
285: dcp = dp->d_conn;
286: /*
287: * Now see if there is already a wildcard entry for this device
288: * (e.g. Search for a "uba ?")
289: */
290: for (; dp != NULL; dp = dp->d_next)
291: if (eq(dev, dp->d_name) && dp->d_unit == -1)
292: break;
293: /*
294: * If there isn't, make one becuase everything needs to be connected
295: * to something.
296: */
297: if (dp == NULL)
298: {
299: dp = &rdev;
300: init_dev(dp);
301: dp->d_unit = QUES;
302: dp->d_name = ns(dev);
303: dp->d_type = oldtype;
304: newdev(dp);
305: dp = curp;
306: /*
307: * Connect it to the same thing that other similar things are
308: * connected to, but make sure it is a wildcard unit
309: * (e.g. up connected to sc ?, here we make connect sc? to a uba?)
310: * If other things like this are on the NEXUS or if the aren't
311: * connected to anything, then make the same connection, else
312: * call ourself to connect to another unspecific device.
313: */
314: if (dcp == TO_NEXUS || dcp == NULL)
315: dp->d_conn = dcp;
316: else
317: dp->d_conn = connect(dcp->d_name, QUES);
318: }
319: return dp;
320: }
321:
322: /*
323: * init_dev:
324: * Set up the fields in the current device to their
325: * default values.
326: */
327:
328: init_dev(dp)
329: register struct device *dp;
330: {
331: dp->d_name = "OHNO!!!";
332: dp->d_type = DEVICE;
333: dp->d_conn = NULL;
334: dp->d_vec = NULL;
335: dp->d_addr = dp->d_flags = dp->d_dk = 0;
336: dp->d_slave = dp->d_drive = dp->d_unit = UNKNOWN;
337: dp->d_count = 0;
338: }
339:
340: /*
341: * Check_nexus:
342: * Make certain that this is a reasonable type of thing to put
343: * on the nexus.
344: */
345:
346: check_nexus(dev, num)
347: register struct device *dev;
348: int num;
349: {
350: if (!eq(dev->d_name, "uba") && !eq(dev->d_name, "mba"))
351: yyerror("only uba's and mba's should be connected to the nexus");
352: if (num != QUES)
353: yyerror("can't give specific nexus numbers");
354: }
355:
356: /*
357: * Check the timezone to make certain it is sensible
358: */
359:
360: check_tz()
361: {
362: if (timezone > 24 * 60)
363: yyerror("timezone is unreasonable");
364: else
365: hadtz = TRUE;
366: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.