![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to y.tab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / etc / config|
Return to y.tab.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / etc / config |
1.1 root 1:
2: # line 1 "config.y"
3: typedef union {
4: char *str;
5: int val;
6: struct file_list *file;
7: struct idlst *lst;
8: } YYSTYPE;
9: # define AND 257
10: # define ANY 258
11: # define ARGS 259
12: # define AT 260
13: # define COMMA 261
14: # define CONFIG 262
15: # define CONTROLLER 263
16: # define CPU 264
17: # define CSR 265
18: # define DEVICE 266
19: # define DISK 267
20: # define DRIVE 268
21: # define DST 269
22: # define DUMPS 270
23: # define EQUALS 271
24: # define FLAGS 272
25: # define HZ 273
26: # define IDENT 274
27: # define MACHINE 275
28: # define MAJOR 276
29: # define MASTER 277
30: # define MAXUSERS 278
31: # define MBA 279
32: # define MINOR 280
33: # define MINUS 281
34: # define NEXUS 282
35: # define ON 283
36: # define OPTIONS 284
37: # define PRIORITY 285
38: # define PSEUDO_DEVICE 286
39: # define ROOT 287
40: # define SEMICOLON 288
41: # define SIZE 289
42: # define SLAVE 290
43: # define SWAP 291
44: # define TIMEZONE 292
45: # define TRACE 293
46: # define UBA 294
47: # define VBA 295
48: # define VECTOR 296
49: # define ID 297
50: # define NUMBER 298
51: # define FPNUMBER 299
52:
53: # line 66 "config.y"
54:
55: /* config.y 1.18 83/05/18 */
56:
57: #include "config.h"
58: #include <ctype.h>
59: #include <stdio.h>
60:
61: struct device cur;
62: struct device *curp = 0;
63: char *temp_id;
64: char *val_id;
65: char *malloc();
66:
67: #define yyclearin yychar = -1
68: #define yyerrok yyerrflag = 0
69: extern int yychar;
70: extern short yyerrflag;
71: #ifndef YYMAXDEPTH
72: #define YYMAXDEPTH 150
73: #endif
74: YYSTYPE yylval, yyval;
75: # define YYERRCODE 256
76:
77: # line 460 "config.y"
78:
79:
80: yyerror(s)
81: char *s;
82: {
83:
84: fprintf(stderr, "config: line %d: %s\n", yyline, s);
85: }
86:
87: /*
88: * return the passed string in a new space
89: */
90: char *
91: ns(str)
92: register char *str;
93: {
94: register char *cp;
95:
96: cp = malloc((unsigned)(strlen(str)+1));
97: (void) strcpy(cp, str);
98: return (cp);
99: }
100:
101: /*
102: * add a device to the list of devices
103: */
104: newdev(dp)
105: register struct device *dp;
106: {
107: register struct device *np;
108:
109: np = (struct device *) malloc(sizeof *np);
110: *np = *dp;
111: if (curp == 0)
112: dtab = np;
113: else
114: curp->d_next = np;
115: curp = np;
116: }
117:
118: /*
119: * note that a configuration should be made
120: */
121: mkconf(sysname)
122: char *sysname;
123: {
124: register struct file_list *fl, **flp;
125:
126: fl = (struct file_list *) malloc(sizeof *fl);
127: fl->f_type = SYSTEMSPEC;
128: fl->f_needs = sysname;
129: fl->f_rootdev = NODEV;
130: fl->f_argdev = NODEV;
131: fl->f_dumpdev = NODEV;
132: fl->f_fn = 0;
133: fl->f_next = 0;
134: for (flp = confp; *flp; flp = &(*flp)->f_next)
135: ;
136: *flp = fl;
137: confp = flp;
138: }
139:
140: struct file_list *
141: newswap()
142: {
143: struct file_list *fl = (struct file_list *)malloc(sizeof (*fl));
144:
145: fl->f_type = SWAPSPEC;
146: fl->f_next = 0;
147: fl->f_swapdev = NODEV;
148: fl->f_swapsize = 0;
149: fl->f_needs = 0;
150: fl->f_fn = 0;
151: return (fl);
152: }
153:
154: /*
155: * Add a swap device to the system's configuration
156: */
157: mkswap(system, fl, size)
158: struct file_list *system, *fl;
159: int size;
160: {
161: register struct file_list **flp;
162: char *cp, name[80];
163:
164: if (system == 0 || system->f_type != SYSTEMSPEC) {
165: yyerror("\"swap\" spec precedes \"config\" specification");
166: return;
167: }
168: if (size < 0) {
169: yyerror("illegal swap partition size");
170: return;
171: }
172: /*
173: * Append swap description to the end of the list.
174: */
175: flp = &system->f_next;
176: for (; *flp && (*flp)->f_type == SWAPSPEC; flp = &(*flp)->f_next)
177: ;
178: fl->f_next = *flp;
179: *flp = fl;
180: /*
181: * If first swap device for this system,
182: * set up f_fn field to insure swap
183: * files are created with unique names.
184: */
185: if (system->f_fn)
186: return;
187: if (eq(fl->f_fn, "generic"))
188: system->f_fn = ns(fl->f_fn);
189: else
190: system->f_fn = ns(system->f_needs);
191: }
192:
193: /*
194: * find the pointer to connect to the given device and number.
195: * returns 0 if no such device and prints an error message
196: */
197: struct device *
198: connect(dev, num)
199: register char *dev;
200: register int num;
201: {
202: register struct device *dp;
203: struct device *huhcon();
204:
205: if (num == QUES)
206: return (huhcon(dev));
207: for (dp = dtab; dp != 0; dp = dp->d_next) {
208: if ((num != dp->d_unit) || !eq(dev, dp->d_name))
209: continue;
210: if (dp->d_type != CONTROLLER && dp->d_type != MASTER) {
211: yyerror(sprintf(errbuf,
212: "%s connected to non-controller", dev));
213: return (0);
214: }
215: return (dp);
216: }
217: yyerror(sprintf(errbuf, "%s %d not defined", dev, num));
218: return (0);
219: }
220:
221: /*
222: * connect to an unspecific thing
223: */
224: struct device *
225: huhcon(dev)
226: register char *dev;
227: {
228: register struct device *dp, *dcp;
229: struct device rdev;
230: int oldtype;
231:
232: /*
233: * First make certain that there are some of these to wildcard on
234: */
235: for (dp = dtab; dp != 0; dp = dp->d_next)
236: if (eq(dp->d_name, dev))
237: break;
238: if (dp == 0) {
239: yyerror(sprintf(errbuf, "no %s's to wildcard", dev));
240: return (0);
241: }
242: oldtype = dp->d_type;
243: dcp = dp->d_conn;
244: /*
245: * Now see if there is already a wildcard entry for this device
246: * (e.g. Search for a "uba ?")
247: */
248: for (; dp != 0; dp = dp->d_next)
249: if (eq(dev, dp->d_name) && dp->d_unit == -1)
250: break;
251: /*
252: * If there isn't, make one because everything needs to be connected
253: * to something.
254: */
255: if (dp == 0) {
256: dp = &rdev;
257: init_dev(dp);
258: dp->d_unit = QUES;
259: dp->d_name = ns(dev);
260: dp->d_type = oldtype;
261: newdev(dp);
262: dp = curp;
263: /*
264: * Connect it to the same thing that other similar things are
265: * connected to, but make sure it is a wildcard unit
266: * (e.g. up connected to sc ?, here we make connect sc? to a
267: * uba?). If other things like this are on the NEXUS or
268: * if they aren't connected to anything, then make the same
269: * connection, else call ourself to connect to another
270: * unspecific device.
271: */
272: if (dcp == TO_NEXUS || dcp == 0)
273: dp->d_conn = dcp;
274: else
275: dp->d_conn = connect(dcp->d_name, QUES);
276: }
277: return (dp);
278: }
279:
280: init_dev(dp)
281: register struct device *dp;
282: {
283:
284: dp->d_name = "OHNO!!!";
285: dp->d_type = DEVICE;
286: dp->d_conn = 0;
287: dp->d_vec = 0;
288: dp->d_addr = dp->d_pri = dp->d_flags = dp->d_dk = 0;
289: dp->d_slave = dp->d_drive = dp->d_unit = UNKNOWN;
290: }
291:
292: /*
293: * make certain that this is a reasonable type of thing to connect to a nexus
294: */
295: check_nexus(dev, num)
296: register struct device *dev;
297: int num;
298: {
299:
300: switch (machine) {
301:
302: case MACHINE_VAX:
303: if (!eq(dev->d_name, "uba") && !eq(dev->d_name, "mba"))
304: yyerror("only uba's and mba's should be connected to the nexus");
305: if (num != QUES)
306: yyerror("can't give specific nexus numbers");
307: break;
308:
309: case MACHINE_TAHOE:
310: if (!eq(dev->d_name, "vba"))
311: yyerror("only vba's should be connected to the nexus");
312: break;
313:
314: case MACHINE_SUN:
315: if (!eq(dev->d_name, "mb"))
316: yyerror("only mb's should be connected to the nexus");
317: break;
318: }
319: }
320:
321: /*
322: * Check the timezone to make certain it is sensible
323: */
324:
325: check_tz()
326: {
327: if (abs(timezone) > 12 * 60)
328: yyerror("timezone is unreasonable");
329: else
330: hadtz = 1;
331: }
332:
333: /*
334: * Check system specification and apply defaulting
335: * rules on root, argument, dump, and swap devices.
336: */
337: checksystemspec(fl)
338: register struct file_list *fl;
339: {
340: char buf[BUFSIZ];
341: register struct file_list *swap;
342: int generic;
343:
344: if (fl == 0 || fl->f_type != SYSTEMSPEC) {
345: yyerror("internal error, bad system specification");
346: exit(1);
347: }
348: swap = fl->f_next;
349: generic = swap && swap->f_type == SWAPSPEC && eq(swap->f_fn, "generic");
350: if (fl->f_rootdev == NODEV && !generic) {
351: yyerror("no root device specified");
352: exit(1);
353: }
354: /*
355: * Default swap area to be in 'b' partition of root's
356: * device. If root specified to be other than on 'a'
357: * partition, give warning, something probably amiss.
358: */
359: if (swap == 0 || swap->f_type != SWAPSPEC) {
360: dev_t dev;
361:
362: swap = newswap();
363: dev = fl->f_rootdev;
364: if (minor(dev) & 07) {
365: sprintf(buf,
366: "Warning, swap defaulted to 'b' partition with root on '%c' partition",
367: (minor(dev) & 07) + 'a');
368: yyerror(buf);
369: }
370: swap->f_swapdev =
371: makedev(major(dev), (minor(dev) &~ 07) | ('b' - 'a'));
372: swap->f_fn = devtoname(swap->f_swapdev);
373: mkswap(fl, swap, 0);
374: }
375: /*
376: * Make sure a generic swap isn't specified, along with
377: * other stuff (user must really be confused).
378: */
379: if (generic) {
380: if (fl->f_rootdev != NODEV)
381: yyerror("root device specified with generic swap");
382: if (fl->f_argdev != NODEV)
383: yyerror("arg device specified with generic swap");
384: if (fl->f_dumpdev != NODEV)
385: yyerror("dump device specified with generic swap");
386: return;
387: }
388: /*
389: * Default argument device and check for oddball arrangements.
390: */
391: if (fl->f_argdev == NODEV)
392: fl->f_argdev = swap->f_swapdev;
393: if (fl->f_argdev != swap->f_swapdev)
394: yyerror("Warning, arg device different than primary swap");
395: /*
396: * Default dump device and warn if place is not a
397: * swap area or the argument device partition.
398: */
399: if (fl->f_dumpdev == NODEV)
400: fl->f_dumpdev = swap->f_swapdev;
401: if (fl->f_dumpdev != swap->f_swapdev && fl->f_dumpdev != fl->f_argdev) {
402: struct file_list *p = swap->f_next;
403:
404: for (; p && p->f_type == SWAPSPEC; p = p->f_next)
405: if (fl->f_dumpdev == p->f_swapdev)
406: return;
407: sprintf(buf, "Warning, orphaned dump device, %s",
408: "do you know what you're doing");
409: yyerror(buf);
410: }
411: }
412:
413: /*
414: * Verify all devices specified in the system specification
415: * are present in the device specifications.
416: */
417: verifysystemspecs()
418: {
419: register struct file_list *fl;
420: dev_t checked[50], *verifyswap();
421: register dev_t *pchecked = checked;
422:
423: for (fl = conf_list; fl; fl = fl->f_next) {
424: if (fl->f_type != SYSTEMSPEC)
425: continue;
426: if (!finddev(fl->f_rootdev))
427: deverror(fl->f_needs, "root");
428: *pchecked++ = fl->f_rootdev;
429: pchecked = verifyswap(fl->f_next, checked, pchecked);
430: #define samedev(dev1, dev2) \
431: ((minor(dev1) &~ 07) != (minor(dev2) &~ 07))
432: if (!alreadychecked(fl->f_dumpdev, checked, pchecked)) {
433: if (!finddev(fl->f_dumpdev))
434: deverror(fl->f_needs, "dump");
435: *pchecked++ = fl->f_dumpdev;
436: }
437: if (!alreadychecked(fl->f_argdev, checked, pchecked)) {
438: if (!finddev(fl->f_argdev))
439: deverror(fl->f_needs, "arg");
440: *pchecked++ = fl->f_argdev;
441: }
442: }
443: }
444:
445: /*
446: * Do as above, but for swap devices.
447: */
448: dev_t *
449: verifyswap(fl, checked, pchecked)
450: register struct file_list *fl;
451: dev_t checked[];
452: register dev_t *pchecked;
453: {
454:
455: for (;fl && fl->f_type == SWAPSPEC; fl = fl->f_next) {
456: if (eq(fl->f_fn, "generic"))
457: continue;
458: if (alreadychecked(fl->f_swapdev, checked, pchecked))
459: continue;
460: if (!finddev(fl->f_swapdev))
461: fprintf(stderr,
462: "config: swap device %s not configured", fl->f_fn);
463: *pchecked++ = fl->f_swapdev;
464: }
465: return (pchecked);
466: }
467:
468: /*
469: * Has a device already been checked
470: * for it's existence in the configuration?
471: */
472: alreadychecked(dev, list, last)
473: dev_t dev, list[];
474: register dev_t *last;
475: {
476: register dev_t *p;
477:
478: for (p = list; p < last; p++)
479: if (samedev(*p, dev))
480: return (1);
481: return (0);
482: }
483:
484: deverror(systemname, devtype)
485: char *systemname, *devtype;
486: {
487:
488: fprintf(stderr, "config: %s: %s device not configured\n",
489: systemname, devtype);
490: }
491:
492: /*
493: * Look for the device in the list of
494: * configured hardware devices. Must
495: * take into account stuff wildcarded.
496: */
497: finddev(dev)
498: dev_t dev;
499: {
500:
501: /* punt on this right now */
502: return (1);
503: }
504: short yyexca[] ={
505: -1, 1,
506: 0, -1,
507: -2, 0,
508: };
509: # define YYNPROD 93
510: # define YYLAST 208
511: short yyact[]={
512:
513: 8, 73, 74, 94, 95, 142, 23, 12, 15, 63,
514: 9, 11, 86, 139, 106, 137, 44, 19, 17, 14,
515: 136, 10, 21, 135, 61, 62, 63, 64, 16, 134,
516: 13, 132, 7, 42, 43, 35, 20, 6, 131, 127,
517: 126, 61, 62, 125, 64, 83, 124, 118, 97, 96,
518: 91, 87, 45, 41, 140, 35, 82, 55, 40, 120,
519: 130, 27, 121, 26, 25, 24, 123, 77, 54, 141,
520: 70, 99, 98, 72, 71, 69, 59, 128, 101, 105,
521: 116, 38, 60, 76, 122, 53, 104, 81, 47, 52,
522: 103, 57, 119, 28, 34, 36, 39, 29, 84, 58,
523: 100, 51, 50, 56, 30, 31, 32, 49, 48, 46,
524: 22, 33, 18, 37, 5, 4, 68, 3, 2, 1,
525: 102, 110, 65, 66, 67, 107, 113, 129, 93, 0,
526: 0, 0, 0, 0, 0, 75, 0, 78, 79, 80,
527: 0, 0, 85, 0, 0, 0, 0, 0, 0, 39,
528: 0, 92, 0, 88, 89, 90, 0, 0, 0, 0,
529: 0, 0, 117, 0, 0, 109, 112, 115, 0, 108,
530: 111, 114, 0, 0, 0, 0, 0, 0, 0, 0,
531: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
532: 0, 0, 0, 0, 0, 0, 0, 117, 133, 0,
533: 0, 0, 0, 0, 0, 0, 0, 138 };
534: short yypact[]={
535:
536: -1000,-1000,-256,-1000,-223,-224,-225,-1000,-227,-1000,
537: -1000,-1000,-1000,-1000,-242,-242,-242,-239,-1000,-245,
538: -265,-246,-202,-242,-1000,-1000,-1000,-1000,-184,-253,
539: -184,-184,-184,-253,-1000,-1000,-1000,-186,-1000,-201,
540: -1000,-1000,-195,-196,-297,-1000,-202,-1000,-1000,-1000,
541: -1000,-1000,-216,-216,-216,-216,-1000,-240,-1000,-270,
542: -247,-1000,-1000,-1000,-1000,-240,-240,-240,-248,-242,
543: -294,-249,-250,-197,-198,-1000,-262,-1000,-262,-262,
544: -262,-1000,-242,-251,-206,-252,-255,-1000,-1000,-1000,
545: -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-258,-259,
546: -180,-1000,-229,-1000,-1000,-260,-267,-1000,-1000,-1000,
547: -1000,-1000,-1000,-1000,-1000,-1000,-1000,-242,-1000,-1000,
548: -269,-275,-278,-283,-1000,-1000,-1000,-1000,-262,-1000,
549: -285,-243,-211,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
550: -1000,-293,-1000 };
551: short yypgo[]={
552:
553: 0, 79, 128, 82, 80, 127, 90, 86, 126, 125,
554: 121, 120, 119, 118, 117, 115, 114, 113, 112, 110,
555: 109, 88, 108, 107, 102, 101, 83, 100, 78, 81,
556: 93, 91, 87, 97, 99, 98, 92 };
557: short yyr1[]={
558:
559: 0, 12, 13, 13, 14, 14, 14, 14, 14, 16,
560: 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
561: 16, 16, 16, 16, 16, 16, 16, 16, 18, 19,
562: 20, 20, 21, 21, 21, 21, 22, 27, 27, 28,
563: 11, 11, 23, 9, 9, 24, 10, 10, 25, 8,
564: 8, 7, 26, 26, 5, 5, 6, 6, 6, 17,
565: 17, 29, 29, 2, 2, 1, 3, 3, 3, 3,
566: 15, 15, 15, 15, 15, 15, 30, 33, 31, 31,
567: 34, 34, 35, 35, 36, 36, 36, 36, 32, 32,
568: 32, 4, 4 };
569: short yyr2[]={
570:
571: 0, 1, 2, 0, 2, 2, 2, 1, 2, 2,
572: 2, 2, 2, 1, 2, 2, 4, 3, 2, 4,
573: 3, 3, 5, 4, 3, 5, 4, 2, 2, 2,
574: 2, 1, 1, 1, 1, 1, 3, 3, 1, 2,
575: 1, 1, 3, 1, 1, 3, 1, 1, 3, 1,
576: 1, 4, 1, 0, 2, 0, 1, 2, 3, 3,
577: 1, 1, 3, 1, 1, 1, 1, 1, 1, 1,
578: 4, 4, 4, 4, 3, 4, 3, 0, 2, 0,
579: 3, 3, 2, 0, 2, 2, 2, 2, 2, 2,
580: 0, 1, 2 };
581: short yychk[]={
582:
583: -1000, -12, -13, -14, -15, -16, 293, 288, 256, 266,
584: 277, 267, 263, 286, 275, 264, 284, 274, -18, 273,
585: 292, 278, -19, 262, 288, 288, 288, 288, -30, -33,
586: -30, -30, -30, -33, -1, 297, -1, -17, -29, -1,
587: 297, 298, 298, 299, 281, 298, -20, -21, -22, -23,
588: -24, -25, 291, 287, 270, 259, -1, -31, -34, 260,
589: -3, 294, 295, 279, 297, -31, -31, -31, -3, 261,
590: 271, 269, 269, 298, 299, -21, -26, 283, -26, -26,
591: -26, -32, 296, 285, -35, -3, 282, 298, -32, -32,
592: -32, 298, -29, -2, 297, 298, 298, 298, 269, 269,
593: -27, -28, -11, -6, -7, -1, 276, -9, -6, -7,
594: -10, -6, -7, -8, -6, -7, -4, -1, 298, -36,
595: 265, 268, 290, 272, 298, 298, 298, 298, 257, -5,
596: 289, 298, 298, -4, 298, 298, 298, 298, -28, 298,
597: 297, 280, 298 };
598: short yydef[]={
599:
600: 3, -2, 1, 2, 0, 0, 0, 7, 0, 77,
601: 77, 77, 77, 77, 0, 0, 0, 0, 13, 0,
602: 0, 0, 0, 0, 4, 5, 6, 8, 79, 0,
603: 79, 79, 79, 0, 9, 65, 10, 11, 60, 61,
604: 12, 14, 15, 18, 0, 27, 28, 31, 32, 33,
605: 34, 35, 53, 53, 53, 53, 29, 90, 83, 0,
606: 0, 66, 67, 68, 69, 90, 90, 90, 74, 0,
607: 0, 17, 20, 21, 24, 30, 0, 52, 0, 0,
608: 0, 70, 0, 0, 78, 0, 0, 76, 71, 72,
609: 73, 75, 59, 62, 63, 64, 16, 19, 23, 26,
610: 36, 38, 55, 40, 41, 56, 0, 42, 43, 44,
611: 45, 46, 47, 48, 49, 50, 88, 91, 89, 82,
612: 0, 0, 0, 0, 80, 81, 22, 25, 0, 39,
613: 0, 57, 0, 92, 84, 85, 86, 87, 37, 54,
614: 58, 0, 51 };
615: #ifndef lint
616: static char yaccpar_sccsid[] = "@(#)yaccpar 4.1 (Berkeley) 2/11/83";
617: #endif not lint
618:
619: #
620: # define YYFLAG -1000
621: # define YYERROR goto yyerrlab
622: # define YYACCEPT return(0)
623: # define YYABORT return(1)
624:
625: /* parser for yacc output */
626:
627: #ifdef YYDEBUG
628: int yydebug = 0; /* 1 for debugging */
629: #endif
630: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
631: int yychar = -1; /* current input token number */
632: int yynerrs = 0; /* number of errors */
633: short yyerrflag = 0; /* error recovery flag */
634:
635: yyparse() {
636:
637: short yys[YYMAXDEPTH];
638: short yyj, yym;
639: register YYSTYPE *yypvt;
640: register short yystate, *yyps, yyn;
641: register YYSTYPE *yypv;
642: register short *yyxi;
643:
644: yystate = 0;
645: yychar = -1;
646: yynerrs = 0;
647: yyerrflag = 0;
648: yyps= &yys[-1];
649: yypv= &yyv[-1];
650:
651: yystack: /* put a state and value onto the stack */
652:
653: #ifdef YYDEBUG
654: if( yydebug ) printf( "state %d, char 0%o\n", yystate, yychar );
655: #endif
656: if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
657: *yyps = yystate;
658: ++yypv;
659: *yypv = yyval;
660:
661: yynewstate:
662:
663: yyn = yypact[yystate];
664:
665: if( yyn<= YYFLAG ) goto yydefault; /* simple state */
666:
667: if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
668: if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
669:
670: if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
671: yychar = -1;
672: yyval = yylval;
673: yystate = yyn;
674: if( yyerrflag > 0 ) --yyerrflag;
675: goto yystack;
676: }
677:
678: yydefault:
679: /* default state action */
680:
681: if( (yyn=yydef[yystate]) == -2 ) {
682: if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
683: /* look through exception table */
684:
685: for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
686:
687: while( *(yyxi+=2) >= 0 ){
688: if( *yyxi == yychar ) break;
689: }
690: if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
691: }
692:
693: if( yyn == 0 ){ /* error */
694: /* error ... attempt to resume parsing */
695:
696: switch( yyerrflag ){
697:
698: case 0: /* brand new error */
699:
700: yyerror( "syntax error" );
701: yyerrlab:
702: ++yynerrs;
703:
704: case 1:
705: case 2: /* incompletely recovered error ... try again */
706:
707: yyerrflag = 3;
708:
709: /* find a state where "error" is a legal shift action */
710:
711: while ( yyps >= yys ) {
712: yyn = yypact[*yyps] + YYERRCODE;
713: if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
714: yystate = yyact[yyn]; /* simulate a shift of "error" */
715: goto yystack;
716: }
717: yyn = yypact[*yyps];
718:
719: /* the current yyps has no shift onn "error", pop stack */
720:
721: #ifdef YYDEBUG
722: if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
723: #endif
724: --yyps;
725: --yypv;
726: }
727:
728: /* there is no state on the stack with an error shift ... abort */
729:
730: yyabort:
731: return(1);
732:
733:
734: case 3: /* no shift yet; clobber input char */
735:
736: #ifdef YYDEBUG
737: if( yydebug ) printf( "error recovery discards char %d\n", yychar );
738: #endif
739:
740: if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
741: yychar = -1;
742: goto yynewstate; /* try again in the same state */
743:
744: }
745:
746: }
747:
748: /* reduction by production yyn */
749:
750: #ifdef YYDEBUG
751: if( yydebug ) printf("reduce %d\n",yyn);
752: #endif
753: yyps -= yyr2[yyn];
754: yypvt = yypv;
755: yypv -= yyr2[yyn];
756: yyval = yypv[1];
757: yym=yyn;
758: /* consult goto table to find next state */
759: yyn = yyr1[yyn];
760: yyj = yypgo[yyn] + *yyps + 1;
761: if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
762: switch(yym){
763:
764: case 1:
765: # line 83 "config.y"
766: { verifysystemspecs(); } break;
767: case 4:
768: # line 94 "config.y"
769: { newdev(&cur); } break;
770: case 6:
771: # line 98 "config.y"
772: { do_trace = !do_trace; } break;
773: case 9:
774: # line 106 "config.y"
775: {
776: if (!strcmp(yypvt[-0].str, "vax")) {
777: machine = MACHINE_VAX;
778: machinename = "vax";
779: } else if (!strcmp(yypvt[-0].str, "sun")) {
780: machine = MACHINE_SUN;
781: machinename = "sun";
782: } else if (!strcmp(yypvt[-0].str, "tahoe")) {
783: machine = MACHINE_TAHOE;
784: machinename = "tahoe";
785: } else
786: yyerror("Unknown machine type");
787: } break;
788: case 10:
789: # line 120 "config.y"
790: {
791: struct cputype *cp =
792: (struct cputype *)malloc(sizeof (struct cputype));
793: cp->cpu_name = ns(yypvt[-0].str);
794: cp->cpu_next = cputype;
795: cputype = cp;
796: free(temp_id);
797: } break;
798: case 12:
799: # line 131 "config.y"
800: { ident = ns(yypvt[-0].str); } break;
801: case 14:
802: # line 135 "config.y"
803: { hz = yypvt[-0].val; } break;
804: case 15:
805: # line 137 "config.y"
806: { timezone = 60 * yypvt[-0].val; check_tz(); } break;
807: case 16:
808: # line 139 "config.y"
809: { timezone = 60 * yypvt[-2].val; dst = yypvt[-0].val; check_tz(); } break;
810: case 17:
811: # line 141 "config.y"
812: { timezone = 60 * yypvt[-1].val; dst = 1; check_tz(); } break;
813: case 18:
814: # line 143 "config.y"
815: { timezone = yypvt[-0].val; check_tz(); } break;
816: case 19:
817: # line 145 "config.y"
818: { timezone = yypvt[-2].val; dst = yypvt[-0].val; check_tz(); } break;
819: case 20:
820: # line 147 "config.y"
821: { timezone = yypvt[-1].val; dst = 1; check_tz(); } break;
822: case 21:
823: # line 149 "config.y"
824: { timezone = -60 * yypvt[-0].val; check_tz(); } break;
825: case 22:
826: # line 151 "config.y"
827: { timezone = -60 * yypvt[-2].val; dst = yypvt[-0].val; check_tz(); } break;
828: case 23:
829: # line 153 "config.y"
830: { timezone = -60 * yypvt[-1].val; dst = 1; check_tz(); } break;
831: case 24:
832: # line 155 "config.y"
833: { timezone = -yypvt[-0].val; check_tz(); } break;
834: case 25:
835: # line 157 "config.y"
836: { timezone = -yypvt[-2].val; dst = yypvt[-0].val; check_tz(); } break;
837: case 26:
838: # line 159 "config.y"
839: { timezone = -yypvt[-1].val; dst = 1; check_tz(); } break;
840: case 27:
841: # line 161 "config.y"
842: { maxusers = yypvt[-0].val; } break;
843: case 28:
844: # line 165 "config.y"
845: { checksystemspec(*confp); } break;
846: case 29:
847: # line 170 "config.y"
848: { mkconf(yypvt[-0].str); } break;
849: case 39:
850: # line 196 "config.y"
851: { mkswap(*confp, yypvt[-1].file, yypvt[-0].val); } break;
852: case 40:
853: # line 201 "config.y"
854: {
855: struct file_list *fl = newswap();
856:
857: if (eq(yypvt[-0].str, "generic"))
858: fl->f_fn = yypvt[-0].str;
859: else {
860: fl->f_swapdev = nametodev(yypvt[-0].str, 0, 'b');
861: fl->f_fn = devtoname(fl->f_swapdev);
862: }
863: yyval.file = fl;
864: } break;
865: case 41:
866: # line 213 "config.y"
867: {
868: struct file_list *fl = newswap();
869:
870: fl->f_swapdev = yypvt[-0].val;
871: fl->f_fn = devtoname(yypvt[-0].val);
872: yyval.file = fl;
873: } break;
874: case 42:
875: # line 224 "config.y"
876: {
877: struct file_list *fl = *confp;
878:
879: if (fl && fl->f_rootdev != NODEV)
880: yyerror("extraneous root device specification");
881: else
882: fl->f_rootdev = yypvt[-0].val;
883: } break;
884: case 43:
885: # line 236 "config.y"
886: { yyval.val = nametodev(yypvt[-0].str, 0, 'a'); } break;
887: case 45:
888: # line 242 "config.y"
889: {
890: struct file_list *fl = *confp;
891:
892: if (fl && fl->f_dumpdev != NODEV)
893: yyerror("extraneous dump device specification");
894: else
895: fl->f_dumpdev = yypvt[-0].val;
896: } break;
897: case 46:
898: # line 255 "config.y"
899: { yyval.val = nametodev(yypvt[-0].str, 0, 'b'); } break;
900: case 48:
901: # line 261 "config.y"
902: {
903: struct file_list *fl = *confp;
904:
905: if (fl && fl->f_argdev != NODEV)
906: yyerror("extraneous arg device specification");
907: else
908: fl->f_argdev = yypvt[-0].val;
909: } break;
910: case 49:
911: # line 273 "config.y"
912: { yyval.val = nametodev(yypvt[-0].str, 0, 'b'); } break;
913: case 51:
914: # line 279 "config.y"
915: { yyval.val = makedev(yypvt[-2].val, yypvt[-0].val); } break;
916: case 54:
917: # line 289 "config.y"
918: { yyval.val = yypvt[-0].val; } break;
919: case 55:
920: # line 291 "config.y"
921: { yyval.val = 0; } break;
922: case 56:
923: # line 296 "config.y"
924: { yyval.str = yypvt[-0].str; } break;
925: case 57:
926: # line 298 "config.y"
927: {
928: char buf[80];
929:
930: (void) sprintf(buf, "%s%d", yypvt[-1].str, yypvt[-0].val);
931: yyval.str = ns(buf); free(yypvt[-1].str);
932: } break;
933: case 58:
934: # line 305 "config.y"
935: {
936: char buf[80];
937:
938: (void) sprintf(buf, "%s%d%s", yypvt[-2].str, yypvt[-1].val, yypvt[-0].str);
939: yyval.str = ns(buf); free(yypvt[-2].str);
940: } break;
941: case 61:
942: # line 321 "config.y"
943: {
944: struct opt *op = (struct opt *)malloc(sizeof (struct opt));
945: op->op_name = ns(yypvt[-0].str);
946: op->op_next = opt;
947: op->op_value = 0;
948: opt = op;
949: free(temp_id);
950: } break;
951: case 62:
952: # line 330 "config.y"
953: {
954: struct opt *op = (struct opt *)malloc(sizeof (struct opt));
955: op->op_name = ns(yypvt[-2].str);
956: op->op_next = opt;
957: op->op_value = ns(yypvt[-0].str);
958: opt = op;
959: free(temp_id);
960: free(val_id);
961: } break;
962: case 63:
963: # line 342 "config.y"
964: { yyval.str = val_id = ns(yypvt[-0].str); } break;
965: case 64:
966: # line 344 "config.y"
967: { char nb[16]; yyval.str = val_id = ns(sprintf(nb, "%d", yypvt[-0].val)); } break;
968: case 65:
969: # line 349 "config.y"
970: { yyval.str = temp_id = ns(yypvt[-0].str); } break;
971: case 66:
972: # line 354 "config.y"
973: { yyval.str = ns("uba"); } break;
974: case 67:
975: # line 356 "config.y"
976: { yyval.str = ns("vba"); } break;
977: case 68:
978: # line 358 "config.y"
979: { yyval.str = ns("mba"); } break;
980: case 69:
981: # line 360 "config.y"
982: { yyval.str = ns(yypvt[-0].str); } break;
983: case 70:
984: # line 365 "config.y"
985: { cur.d_type = DEVICE; } break;
986: case 71:
987: # line 367 "config.y"
988: { cur.d_type = MASTER; } break;
989: case 72:
990: # line 369 "config.y"
991: { cur.d_dk = 1; cur.d_type = DEVICE; } break;
992: case 73:
993: # line 371 "config.y"
994: { cur.d_type = CONTROLLER; } break;
995: case 74:
996: # line 373 "config.y"
997: {
998: cur.d_name = yypvt[-0].str;
999: cur.d_type = PSEUDO_DEVICE;
1000: } break;
1001: case 75:
1002: # line 378 "config.y"
1003: {
1004: cur.d_name = yypvt[-1].str;
1005: cur.d_type = PSEUDO_DEVICE;
1006: cur.d_slave = yypvt[-0].val;
1007: } break;
1008: case 76:
1009: # line 386 "config.y"
1010: {
1011: cur.d_name = yypvt[-1].str;
1012: if (eq(yypvt[-1].str, "mba"))
1013: seen_mba = 1;
1014: else if (eq(yypvt[-1].str, "uba"))
1015: seen_uba = 1;
1016: else if (eq(yypvt[-1].str, "vba"))
1017: seen_vba = 1;
1018: cur.d_unit = yypvt[-0].val;
1019: } break;
1020: case 77:
1021: # line 399 "config.y"
1022: { init_dev(&cur); } break;
1023: case 80:
1024: # line 409 "config.y"
1025: {
1026: if (eq(cur.d_name, "mba") || eq(cur.d_name, "uba"))
1027: yyerror(sprintf(errbuf,
1028: "%s must be connected to a nexus", cur.d_name));
1029: cur.d_conn = connect(yypvt[-1].str, yypvt[-0].val);
1030: } break;
1031: case 81:
1032: # line 416 "config.y"
1033: { check_nexus(&cur, yypvt[-0].val); cur.d_conn = TO_NEXUS; } break;
1034: case 84:
1035: # line 426 "config.y"
1036: { cur.d_addr = yypvt[-0].val; } break;
1037: case 85:
1038: # line 428 "config.y"
1039: { cur.d_drive = yypvt[-0].val; } break;
1040: case 86:
1041: # line 430 "config.y"
1042: {
1043: if (cur.d_conn != 0 && cur.d_conn != TO_NEXUS &&
1044: cur.d_conn->d_type == MASTER)
1045: cur.d_slave = yypvt[-0].val;
1046: else
1047: yyerror("can't specify slave--not to master");
1048: } break;
1049: case 87:
1050: # line 438 "config.y"
1051: { cur.d_flags = yypvt[-0].val; } break;
1052: case 88:
1053: # line 442 "config.y"
1054: { cur.d_vec = yypvt[-0].lst; } break;
1055: case 89:
1056: # line 444 "config.y"
1057: { cur.d_pri = yypvt[-0].val; } break;
1058: case 91:
1059: # line 450 "config.y"
1060: {
1061: struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst));
1062: a->id = yypvt[-0].str; a->id_next = 0; yyval.lst = a;
1063: } break;
1064: case 92:
1065: # line 454 "config.y"
1066:
1067: {
1068: struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst));
1069: a->id = yypvt[-1].str; a->id_next = yypvt[-0].lst; yyval.lst = a;
1070: } break;
1071: }
1072: goto yystack; /* stack new state and value */
1073:
1074: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.