![[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 [XINU] / xinu / con|
Return to y.tab.c CVS log | Up to [XINU] / xinu / con |
1.1 root 1: # define DEFBRK 257
2: # define COLON 258
3: # define OCTAL 259
4: # define INTEGER 260
5: # define IDENT 261
6: # define CSR 262
7: # define IVEC 263
8: # define OVEC 264
9: # define IINT 265
10: # define OINT 266
11: # define INIT 267
12: # define OPEN 268
13: # define CLOSE 269
14: # define READ 270
15: # define WRITE 271
16: # define SEEK 272
17: # define CNTL 273
18: # define IS 274
19: # define ON 275
20: # define GETC 276
21: # define PUTC 277
22:
23: # line 4 "config.y"
24: #include <stdio.h>
25:
26: #define NIL (dvptr)0
27:
28: #define CONFIGC "../sys/conf.c" /* name of .c output */
29: #define CONFIGH "../h/conf.h" /* name of .h output */
30: #define DISPCONF "../h/dispconf.h" /* name of dispatcher .h*/
31: #define IODISP "../h/iodisp.h" /* name of dispat loc .h*/
32: #define CONFHREF "<conf.h>" /* how conf.h referenced*/
33: #define CONFIGIN "Configuration" /* name of input file */
34:
35: FILE *confc;
36: FILE *confh;
37: FILE *dispconf;
38: FILE *iodisp;
39:
40: char *dbstr;
41: extern char *malloc();
42: int ndevs = 0;
43: int currname = -1;
44: int currtname = -1;
45: int currdname = -1;
46: int brkcount = 0;
47:
48: struct syment { /* symbol table */
49: char *symname;
50: int symoccurs;
51: } symtab[250];
52:
53: int nsym = 0;
54: int lookup();
55: int linectr = 1;
56: char *doing = "device type declaration";
57: char *s;
58: struct dvtype {
59: char *dvname; /* device name (not used in types)*/
60: char *dvtname; /* type name */
61: int dvtnum; /* symbol table index of type */
62: char *dvdevice; /* device name */
63: int dvcsr; /* Control Status Register addr */
64: int dvivec; /* input interrupt vector */
65: int dvovec; /* Output interrupt vector */
66: char dviint[20]; /* input interrupt routine */
67: char dvoint[20]; /* output interrupt routine */
68: char dvinit[20]; /* init routine name */
69: char dvopen[20]; /* open routine name */
70: char dvclose[20]; /* close routine name */
71: char dvread[20]; /* read routine name */
72: char dvwrite[20]; /* write routine name */
73: char dvcntl[20]; /* control routine name */
74: char dvseek[20]; /* seek routine name */
75: char dvgetc[20]; /* getc routine name */
76: char dvputc[20]; /* putc routine name */
77: int dvminor; /* device number 0,1,... */
78: struct dvtype *dvnext; /* next node on the list */
79: };
80: typedef struct dvtype *dvptr;
81: dvptr ftypes = NIL; /* linked list of device types */
82: dvptr devs = NIL; /* linked list of device decls. */
83: dvptr lastdv = NIL;
84: dvptr currtype = NIL;
85:
86: char *ftout[] =
87: {"#ifndef\tASM\n",
88: "struct\tdevsw\t{\t\t\t/* device table entry */\n",
89: "\tint\tdvnum;\n",
90: "\tchar\t*dvname;\n",
91: "\tint\t(*dvinit)();\n",
92: "\tint\t(*dvopen)();\n",
93: "\tint\t(*dvclose)();\n",
94: "\tint\t(*dvread)();\n",
95: "\tint\t(*dvwrite)();\n",
96: "\tint\t(*dvseek)();\n",
97: "\tint\t(*dvgetc)();\n",
98: "\tint\t(*dvputc)();\n",
99: "\tint\t(*dvcntl)();\n",
100: "\tint\tdvcsr;\n",
101: "\tint\tdvivec;\n",
102: "\tint\tdvovec;\n",
103: "\tint\t(*dviint)();\n",
104: "\tint\t(*dvoint)();\n",
105: "\tchar\t*dvioblk;\n",
106: "\tint\tdvminor;\n",
107: "\t};\n\n",
108: "extern\tstruct\tdevsw devtab[];",
109: "\t\t/* one entry per device */\n",
110: "#endif\n\n",
111: NULL};
112: #define yyclearin yychar = -1
113: #define yyerrok yyerrflag = 0
114: extern int yychar;
115: extern short yyerrflag;
116: #ifndef YYMAXDEPTH
117: #define YYMAXDEPTH 150
118: #endif
119: #ifndef YYSTYPE
120: #define YYSTYPE int
121: #endif
122: YYSTYPE yylval, yyval;
123: # define YYERRCODE 256
124:
125: # line 176 "config.y"
126:
127: #include "lex.yy.c"
128: main(argc, argv)
129: int argc;
130: char *argv[];
131: {
132: int n, i, j, l, fcount;
133: dvptr s;
134: int verbose = 0;
135: char *p;
136: char c;
137:
138: if (argc>1 && (strcmp("-v",argv[1])==0)) {
139: argc--;
140: argv++;
141: verbose++;
142: }
143: if (argc>2) {
144: fprintf(stderr,"use: config [-v] [file]\n");
145: exit(1);
146: }
147: if (verbose)
148: printf("Opening input file...\n");
149: if (argc == 2) {
150: if (freopen(argv[1], "r", stdin) == NULL) {
151: fprintf(stderr,"Can't open %s\n",argv[1]);
152: exit(1);
153: }
154: } else { /* try to open Configuration file */
155: if (freopen(CONFIGIN, "r", stdin) == NULL) {
156: fprintf(stderr,"Can't open %s\n", CONFIGIN);
157: exit(1);
158: }
159: }
160:
161: /* Parse the Configuration file */
162:
163: if (verbose)
164: printf("Parsing configuration specs...\n");
165: if ((n=yyparse()) != 0)
166: exit(n);
167:
168: /* write config.h and config.c */
169:
170: if (verbose)
171: printf("Opening output files...\n");
172: if ( (confc=fopen(CONFIGC,"w") ) == NULL) {
173: fprintf(stderr, "Can't write on %s\n", CONFIGC);
174: exit(1);
175: }
176:
177: if ( (confh=fopen(CONFIGH,"w") ) == NULL) {
178: fprintf(stderr, "Can't write on %s\n", CONFIGH);
179: exit(1);
180: }
181: if ( (dispconf=fopen(DISPCONF,"w") ) == NULL) {
182: fprintf(stderr, "Can't write on %s\n",DISPCONF);
183: exit(1);
184: }
185: if ( (iodisp=fopen(IODISP,"w") ) == NULL) {
186: fprintf(stderr, "Can't write on %s\n",IODISP);
187: exit(1);
188: }
189: fprintf(confh,
190: "/* conf.h (GENERATED FILE; DO NOT EDIT) */\n");
191: fprintf(confc,
192: "/* conf.c (GENERATED FILE; DO NOT EDIT) */\n");
193: fprintf(dispconf,
194: "/* dispconf.h (GENERATED FILE; DO NOT EDIT) */\n");
195: fprintf(iodisp,
196: "/* iodisp.h (GENERATED FILE; DO NOT EDIT) */\n");
197: fprintf(confc, "\n#include %s\n", CONFHREF);
198: fprintf(confh, "\n#define\tNULLPTR\t(char *)0\n");
199:
200:
201: if (verbose)
202: printf("Writing output...\n");
203: fprintf(confh,"\n/* Device table declarations */\n");
204: for (i=0 ; (p=ftout[i])!=NULL ; i++)
205: fprintf(confh, "%s", p);
206: fprintf(dispconf,"\n/* vector-to points for each device */\n\n");
207: fprintf(iodisp,"\n/* i/o dispatch vector-to location externs */\n\n");
208: /* write device declarations and definitions; count type refs. */
209:
210: fprintf(confh, "\n/* Device name definitions */\n\n");
211: for (i=0,s=devs; s!=NIL ; s=s->dvnext,i++) {
212: fprintf(confh, "#define\t%-12s%d\t\t\t/* type %-8s */\n",
213: s->dvname, i, s->dvtname);
214: s->dvminor = symtab[s->dvtnum].symoccurs++;
215: }
216:
217: /* write count of device types */
218:
219: fprintf(confh,"\n/* Control block sizes */\n\n");
220: for (i=0 ; i<nsym ; i++)
221: if (symtab[i].symoccurs > 0) {
222: fprintf(confh, "#define\tN%s\t%d\n",
223: symtab[i].symname, symtab[i].symoccurs);
224: }
225: if (ndevs > 0)
226: fprintf(confh, "\n#define\tNDEVS\t%d\n\n", ndevs);
227:
228: /* empty symbol table, collect, and write names of all I/O routines */
229:
230: nsym = 0;
231: for (s=devs; s!=NIL ; s=s->dvnext) {
232: lookup(s->dvinit,strlen(s->dvinit));
233: lookup(s->dvopen,strlen(s->dvopen));
234: lookup(s->dvclose,strlen(s->dvclose));
235: lookup(s->dvread,strlen(s->dvread));
236: lookup(s->dvwrite,strlen(s->dvwrite));
237: lookup(s->dvseek,strlen(s->dvseek));
238: lookup(s->dvcntl,strlen(s->dvcntl));
239: lookup(s->dvgetc,strlen(s->dvgetc));
240: lookup(s->dvputc,strlen(s->dvputc));
241: lookup(s->dviint,strlen(s->dviint));
242: lookup(s->dvoint,strlen(s->dvoint));
243:
244: }
245: fprintf(confh,
246: "/* Declarations of I/O routines referenced */\n\n");
247: fprintf(confh, "#ifndef\tASM\n");
248: for (i=0 ; i<nsym ; i++)
249: fprintf(confh, "extern\tint\t%s();\n", symtab[i].symname);
250: fprintf(confh, "#endif\n");
251:
252:
253: /* produce devtab (giant I/O switch table) */
254:
255: fprintf(confc, "\n/* device independent I/O switch */\n\n");
256: if (ndevs > 0) {
257: fprintf(confc, "struct\tdevsw\tdevtab[NDEVS] = {\n");
258: fprintf(confc, "\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n",
259: "/* Format of entries is:",
260: "device-number, device-name,",
261: "init, open, close,",
262: "read, write, seek,",
263: "getc, putc, cntl,",
264: "device-csr-address, input-vector, output-vector,",
265: "iint-handler, oint-handler, control-block, minor-device,",
266: "*/");
267: }
268: for (fcount=0,s=devs ; s!=NIL ; s=s->dvnext,fcount++) {
269: fprintf(confc, "\n/* %s is %s */\n\n",s->dvname,s->dvtname);
270: fprintf(confc, "%d, \"%s\",\n", fcount, s->dvname);
271: fprintf(confc, "%s, %s, %s,\n",
272: s->dvinit, s->dvopen, s->dvclose);
273: fprintf(confc, "%s, %s, %s,\n",
274: s->dvread, s->dvwrite, s->dvseek);
275: fprintf(confc, "%s, %s, %s,\n",
276: s->dvgetc, s->dvputc, s->dvcntl);
277: fprintf(confc, "0%06o, 0%03o, 0%03o,\n",
278: s->dvcsr, s->dvivec, s->dvovec);
279: fprintf(confc, "%s, %s, NULLPTR, %d",
280: s->dviint, s->dvoint, s->dvminor);
281: if ( s->dvnext != NIL )
282: fprintf(confc, ",\n");
283: else
284: fprintf(confc, "\n\t};");
285: }
286: for (i=0; i<ndevs; i++) {
287: fprintf(dispconf,"\t.globl\t_devveci%-1d\n",i);
288: fprintf(dispconf,"\t.globl\t_devveco%-1d\n",i);
289: fprintf(dispconf,"\t.align\t2\n");
290: fprintf(dispconf,"_devveci%-1d:\n",i);
291: fprintf(dispconf,"\tmtpr\t$DISABLE, $IPL\n");
292: fprintf(dispconf,"\tbsbw\tioint\n");
293: fprintf(dispconf,"\t.align\t2\n");
294: fprintf(dispconf,"_devveco%-1d:\n",i);
295: fprintf(dispconf,"\tmtpr\t$DISABLE, $IPL\n");
296: fprintf(dispconf,"\tbsbw\tioint\n\n",i);
297: fprintf(iodisp, "extern\tint\tdevveci%-1d();\n",i);
298: fprintf(iodisp, "extern\tint\tdevveco%-1d();\n",i);
299: }
300:
301: /* Copy definitions to output */
302:
303: if (brkcount == 2 && verbose)
304: printf("Copying definitions to %s...\n", CONFIGH);
305: if (brkcount == 2 )
306: while ( (c=input()) != 0) /* lex input routine */
307: putc(c, confh);
308:
309: /* guarantee conf.c written later than conf.c for make */
310:
311: fclose(confh);
312: fprintf(confc, "\n");
313: fclose(confc);
314: fclose(dispconf);
315: fclose(iodisp);
316:
317: /* finish up and write report for user if requested */
318:
319: if (verbose) {
320: printf("\nConfiguration complete. Number of devs=%d:\n\n",ndevs);
321: for (s=devs; s!=NIL ; s=s->dvnext)
322: printf(
323: "Device %s (on %s) csr=0%-7o, ivec=0%-3o, ovec=0%-3o, minor=%d\n",
324: s->dvname, s->dvdevice, s->dvcsr, s->dvivec, s->dvovec,
325: s->dvminor);
326: }
327:
328:
329: }
330:
331:
332: yyerror(s)
333: char *s;
334: {
335: fprintf(stderr,"Syntax error in %s on line %d\n",
336: doing,linectr);
337: }
338:
339:
340: /* lookup -- lookup a name in the symbol table; return position */
341:
342: lookup(str,len)
343: char *str;
344: int len;
345: {
346: int i;
347: char *s;
348:
349: if (len >= 20) {
350: len = 19;
351: fprintf(stderr,"warning: name %s truncated\n",str);
352: }
353: s = malloc(len+1);
354: strncpy(s,str,len);
355: s[len] = '\000';
356: for (i=0 ; i<nsym ; i++)
357: if (strcmp(s,symtab[i].symname) == 0){
358: return(i);
359: }
360: symtab[nsym].symname = s;
361: symtab[nsym].symoccurs = 0;
362: return(nsym++);
363: }
364:
365: atoi(str,len)
366: char *str;
367: int len;
368: {
369: int i;
370: char c;
371:
372: for (i=0; len > 0 ; len--) {
373: c = *str++;
374: i = 10*i + (c - '0');
375: }
376: }
377: otoi(str,len)
378: char *str;
379: int len;
380: {
381: int i;
382: char c;
383:
384: for (i=0; len > 0 ; len--) {
385: c = *str++;
386: if (c > '7')
387: fprintf(stderr,"invalid octal digit on line %d\n",
388: linectr);
389: else
390: i = 8*i + (c - '0');
391: }
392: }
393:
394: /* newattr -- add a new attribute spec to current type/device description */
395:
396: newattr(tok,val)
397: int tok; /* token type (attribute type) */
398: int val; /* symbol number of value */
399: {
400: char *c;
401: dvptr s;
402:
403: if (devs == NIL) /* doing types */
404: s = currtype;
405: else
406: s = lastdv;
407: if (val>=0 && val<nsym) {
408: c = symtab[val].symname;
409: if (strlen(c) > 20 ) {
410: fprintf(stderr,"Internal overflow\n");
411: exit(1);
412: }
413: } else
414: c = NULL;
415:
416: switch (tok) {
417:
418: case CSR: s->dvcsr = val;
419: break;
420: case IVEC: s->dvivec = val;
421: break;
422: case OVEC: s->dvovec = val;
423: break;
424: case IINT: strcpy(s->dviint,c);
425: break;
426: case OINT: strcpy(s->dvoint,c);
427: break;
428: case READ: strcpy(s->dvread,c);
429: break;
430: case WRITE: strcpy(s->dvwrite,c);
431: break;
432: case GETC: strcpy(s->dvgetc,c);
433: break;
434: case PUTC: strcpy(s->dvputc,c);
435: break;
436: case OPEN: strcpy(s->dvopen,c);
437: break;
438: case CLOSE: strcpy(s->dvclose,c);
439: break;
440: case INIT: strcpy(s->dvinit,c);
441: break;
442: case SEEK: strcpy(s->dvseek,c);
443: break;
444: case CNTL: strcpy(s->dvcntl,c);
445: break;
446: default: fprintf(stderr, "Internal error 1\n");
447: }
448: }
449:
450: /* cktname -- check type name for duplicates */
451:
452: cktname(symid)
453: int symid;
454: {
455: dvptr s;
456: extern dvptr ftypes;
457: char *name;
458:
459: name = symtab[symid].symname;
460: for (s=ftypes; s!=NIL ; s=s->dvnext) {
461: if (s->dvtname == name) {
462: fprintf(stderr,"Duplicate type name %s on line %d\n",
463: name,linectr);
464: exit(1);
465: }
466: }
467: return(symid);
468: }
469:
470: /* mktype -- make a node in the type list and initialize to defaults */
471:
472: mktype(deviceid)
473: int deviceid;
474: {
475: dvptr s,p;
476: char *tn,*dn;
477:
478: p = NIL;
479: tn = symtab[currtname].symname;
480: dn = symtab[deviceid].symname;
481: for (s = ftypes; s!=NIL ; s=s->dvnext) {
482: if (s->dvtname == tn && s->dvdevice==dn) {
483: fprintf(stderr,
484: "Duplicate device %s for type %s on line %d\n",
485: dn, tn, linectr);
486: exit(1);
487: }
488: p = s;
489: }
490: currtype = s = (dvptr) malloc( sizeof(struct dvtype));
491: if (ftypes != NIL) {
492: p->dvnext = s;
493: }
494: else {
495: ftypes = s;
496: }
497: initattr(s, currtname, deviceid);
498: }
499:
500: /* initialize attributes in a type declaration node to typename... */
501:
502: initattr(fstr, tnum, deviceid)
503: dvptr fstr;
504: int tnum;
505: int deviceid;
506: {
507: char *typnam;
508:
509: typnam = symtab[tnum].symname;
510: fstr->dvname = NULL;
511: fstr->dvtname = typnam;
512: fstr->dvtnum = tnum;
513: fstr->dvdevice = symtab[deviceid].symname;
514: fstr->dvcsr = 0;
515: fstr->dvivec = 0;
516: fstr->dvovec = 0;
517: strcpy(fstr->dviint,typnam);
518: strcat(fstr->dviint,"iin");
519: strcpy(fstr->dvoint,typnam);
520: strcat(fstr->dvoint,"oin");
521: strcpy(fstr->dvinit,typnam);
522: strcat(fstr->dvinit,"init");
523: strcpy(fstr->dvopen,typnam);
524: strcat(fstr->dvopen,"open");
525: strcpy(fstr->dvclose,typnam);
526: strcat(fstr->dvclose,"close");
527: strcpy(fstr->dvread,typnam);
528: strcat(fstr->dvread,"read");
529: strcpy(fstr->dvwrite,typnam);
530: strcat(fstr->dvwrite,"write");
531: strcpy(fstr->dvcntl,typnam);
532: strcat(fstr->dvcntl,"control");
533: strcpy(fstr->dvseek,typnam);
534: strcat(fstr->dvseek,"seek");
535: strcpy(fstr->dvgetc,typnam);
536: strcat(fstr->dvgetc,"getc");
537: strcpy(fstr->dvputc,typnam);
538: strcat(fstr->dvputc,"putc");
539: fstr->dvminor = 0;
540: }
541:
542: /* mkdev -- make a node on the device list */
543:
544: mkdev(nameid, typid, deviceid)
545: int nameid, typid, deviceid;
546: {
547: dvptr s;
548: char *devn,*tn,*dn;
549: int found;
550:
551: s = (dvptr) malloc(sizeof(struct dvtype));
552: s->dvnext = NIL;
553: if (devs == NIL) {
554: devs = s;
555: lastdv = s;
556: } else {
557: lastdv->dvnext = s;
558: lastdv = s;
559: }
560: ndevs++;
561: tn = symtab[typid].symname;
562: devn = symtab[nameid].symname;
563: if (deviceid >= 0)
564: dn = symtab[deviceid].symname;
565: else
566: dn = NULL;
567: found = 0;
568: for (s=ftypes ; s != NULL ; s=s->dvnext)
569: if (s->dvtname == tn && (dn==NULL || s->dvdevice==dn)) {
570: strdup(lastdv,s,sizeof(struct dvtype));
571: found=1;
572: break;
573: }
574: if (found==0) {
575: fprintf(stderr,
576: "Bad type or device name in declaration of %s on line %d\n",
577: devn, linectr);
578: exit(1);
579: }
580: lastdv->dvnext = NIL;
581: lastdv->dvname = devn;
582: }
583:
584:
585: /* chdname -- check for duplicate device name */
586:
587: ckdname(devid)
588: int devid;
589: {
590: dvptr s;
591: extern dvptr devs;
592: char *name;
593:
594: name = symtab[devid].symname;
595: for (s=devs; s!=NIL ; s=s->dvnext) {
596: if (s->dvname == name) {
597: fprintf(stderr,"Duplicate device name %s on line %d\n",
598: name,linectr);
599: exit(1);
600: }
601: }
602: return(devid);
603: }
604:
605: strdup(tostr,fromstr,len)
606: char *tostr, *fromstr;
607: int len;
608: {
609: for( ; len > 0 ; len--)
610: *tostr++ = *fromstr++;
611: }
612: short yyexca[] ={
613: -1, 1,
614: 0, -1,
615: -2, 0,
616: };
617: # define YYNPROD 36
618: # define YYLAST 79
619: short yyact[]={
620:
621: 24, 25, 26, 27, 28, 31, 29, 30, 34, 35,
622: 36, 37, 57, 19, 32, 33, 16, 5, 9, 17,
623: 8, 9, 42, 41, 15, 13, 18, 56, 12, 11,
624: 10, 23, 14, 40, 7, 6, 3, 22, 4, 20,
625: 38, 2, 21, 1, 0, 0, 0, 39, 45, 46,
626: 47, 48, 49, 50, 51, 52, 53, 54, 55, 43,
627: 44, 0, 0, 0, 0, 0, 0, 0, 0, 0,
628: 0, 0, 0, 0, 0, 0, 0, 0, 58 };
629: short yypact[]={
630:
631: -1000,-1000,-1000,-240,-243,-1000,-1000,-259,-239,-1000,
632: -1000,-1000,-261,-1000,-259,-1000,-243,-1000,-262,-243,
633: -1000,-262,-1000,-1000,-237,-237,-237,-243,-243,-243,
634: -243,-243,-243,-243,-243,-243,-243,-243,-263,-262,
635: -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
636: -1000,-1000,-1000,-1000,-1000,-1000,-1000,-243,-1000 };
637: short yypgo[]={
638:
639: 0, 43, 41, 38, 36, 35, 34, 32, 24, 26,
640: 20, 31, 33, 30, 29, 28, 27 };
641: short yyr1[]={
642:
643: 0, 1, 2, 4, 4, 5, 7, 7, 8, 6,
644: 10, 9, 9, 11, 11, 11, 11, 11, 11, 11,
645: 11, 11, 11, 11, 11, 11, 11, 12, 12, 3,
646: 3, 13, 14, 15, 16, 16 };
647: short yyr2[]={
648:
649: 0, 2, 2, 0, 2, 2, 2, 3, 2, 2,
650: 1, 0, 2, 2, 2, 2, 2, 2, 2, 2,
651: 2, 2, 2, 2, 2, 2, 2, 1, 1, 0,
652: 2, 2, 4, 1, 0, 2 };
653: short yychk[]={
654:
655: -1000, -1, -2, -4, -3, 257, -5, -6, -10, 261,
656: -13, -14, -15, -10, -7, -8, 275, 258, -9, 274,
657: -8, -9, -10, -11, 262, 263, 264, 265, 266, 268,
658: 269, 267, 276, 277, 270, 271, 272, 273, -10, -9,
659: -12, 260, 259, -12, -12, -10, -10, -10, -10, -10,
660: -10, -10, -10, -10, -10, -10, -16, 275, -10 };
661: short yydef[]={
662:
663: 3, -2, 29, 0, 1, 2, 4, 0, 0, 10,
664: 30, 11, 0, 33, 5, 11, 0, 9, 31, 0,
665: 11, 6, 8, 12, 0, 0, 0, 0, 0, 0,
666: 0, 0, 0, 0, 0, 0, 0, 0, 34, 7,
667: 13, 27, 28, 14, 15, 16, 17, 18, 19, 20,
668: 21, 22, 23, 24, 25, 26, 32, 0, 35 };
669: #ifndef lint
670: static char yaccpar_sccsid[] = "@(#)yaccpar 4.1 (Berkeley) 2/11/83";
671: #endif not lint
672:
673: #
674: # define YYFLAG -1000
675: # define YYERROR goto yyerrlab
676: # define YYACCEPT return(0)
677: # define YYABORT return(1)
678:
679: /* parser for yacc output */
680:
681: #ifdef YYDEBUG
682: int yydebug = 0; /* 1 for debugging */
683: #endif
684: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
685: int yychar = -1; /* current input token number */
686: int yynerrs = 0; /* number of errors */
687: short yyerrflag = 0; /* error recovery flag */
688:
689: yyparse() {
690:
691: short yys[YYMAXDEPTH];
692: short yyj, yym;
693: register YYSTYPE *yypvt;
694: register short yystate, *yyps, yyn;
695: register YYSTYPE *yypv;
696: register short *yyxi;
697:
698: yystate = 0;
699: yychar = -1;
700: yynerrs = 0;
701: yyerrflag = 0;
702: yyps= &yys[-1];
703: yypv= &yyv[-1];
704:
705: yystack: /* put a state and value onto the stack */
706:
707: #ifdef YYDEBUG
708: if( yydebug ) printf( "state %d, char 0%o\n", yystate, yychar );
709: #endif
710: if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
711: *yyps = yystate;
712: ++yypv;
713: *yypv = yyval;
714:
715: yynewstate:
716:
717: yyn = yypact[yystate];
718:
719: if( yyn<= YYFLAG ) goto yydefault; /* simple state */
720:
721: if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
722: if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
723:
724: if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
725: yychar = -1;
726: yyval = yylval;
727: yystate = yyn;
728: if( yyerrflag > 0 ) --yyerrflag;
729: goto yystack;
730: }
731:
732: yydefault:
733: /* default state action */
734:
735: if( (yyn=yydef[yystate]) == -2 ) {
736: if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
737: /* look through exception table */
738:
739: for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
740:
741: while( *(yyxi+=2) >= 0 ){
742: if( *yyxi == yychar ) break;
743: }
744: if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
745: }
746:
747: if( yyn == 0 ){ /* error */
748: /* error ... attempt to resume parsing */
749:
750: switch( yyerrflag ){
751:
752: case 0: /* brand new error */
753:
754: yyerror( "syntax error" );
755: yyerrlab:
756: ++yynerrs;
757:
758: case 1:
759: case 2: /* incompletely recovered error ... try again */
760:
761: yyerrflag = 3;
762:
763: /* find a state where "error" is a legal shift action */
764:
765: while ( yyps >= yys ) {
766: yyn = yypact[*yyps] + YYERRCODE;
767: if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
768: yystate = yyact[yyn]; /* simulate a shift of "error" */
769: goto yystack;
770: }
771: yyn = yypact[*yyps];
772:
773: /* the current yyps has no shift onn "error", pop stack */
774:
775: #ifdef YYDEBUG
776: if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
777: #endif
778: --yyps;
779: --yypv;
780: }
781:
782: /* there is no state on the stack with an error shift ... abort */
783:
784: yyabort:
785: return(1);
786:
787:
788: case 3: /* no shift yet; clobber input char */
789:
790: #ifdef YYDEBUG
791: if( yydebug ) printf( "error recovery discards char %d\n", yychar );
792: #endif
793:
794: if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
795: yychar = -1;
796: goto yynewstate; /* try again in the same state */
797:
798: }
799:
800: }
801:
802: /* reduction by production yyn */
803:
804: #ifdef YYDEBUG
805: if( yydebug ) printf("reduce %d\n",yyn);
806: #endif
807: yyps -= yyr2[yyn];
808: yypvt = yypv;
809: yypv -= yyr2[yyn];
810: yyval = yypv[1];
811: yym=yyn;
812: /* consult goto table to find next state */
813: yyn = yyr1[yyn];
814: yyj = yypgo[yyn] + *yyps + 1;
815: if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
816: switch(yym){
817:
818: case 2:
819: # line 97 "config.y"
820: {doing = "device definitions";} break;
821: case 8:
822: # line 108 "config.y"
823: {mktype(yypvt[-0]);} break;
824: case 9:
825: # line 111 "config.y"
826: {yyval = currtname = cktname(yypvt[-1]);} break;
827: case 10:
828: # line 114 "config.y"
829: {yyval = currname =
830: lookup(yytext,yyleng);
831: } break;
832: case 13:
833: # line 122 "config.y"
834: {newattr(CSR,yypvt[-0]);} break;
835: case 14:
836: # line 124 "config.y"
837: {newattr(IVEC,yypvt[-0]);} break;
838: case 15:
839: # line 126 "config.y"
840: {newattr(OVEC,yypvt[-0]);} break;
841: case 16:
842: # line 128 "config.y"
843: {newattr(IINT,yypvt[-0]);} break;
844: case 17:
845: # line 130 "config.y"
846: {newattr(OINT,yypvt[-0]);} break;
847: case 18:
848: # line 132 "config.y"
849: {newattr(OPEN,yypvt[-0]);} break;
850: case 19:
851: # line 134 "config.y"
852: {newattr(CLOSE,yypvt[-0]);} break;
853: case 20:
854: # line 136 "config.y"
855: {newattr(INIT,yypvt[-0]);} break;
856: case 21:
857: # line 138 "config.y"
858: {newattr(GETC,yypvt[-0]);} break;
859: case 22:
860: # line 140 "config.y"
861: {newattr(PUTC,yypvt[-0]);} break;
862: case 23:
863: # line 142 "config.y"
864: {newattr(READ,yypvt[-0]);} break;
865: case 24:
866: # line 144 "config.y"
867: {newattr(WRITE,yypvt[-0]);} break;
868: case 25:
869: # line 146 "config.y"
870: {newattr(SEEK,yypvt[-0]);} break;
871: case 26:
872: # line 148 "config.y"
873: {newattr(CNTL,yypvt[-0]);} break;
874: case 27:
875: # line 156 "config.y"
876: {yyval = otoi(yytext,yyleng);} break;
877: case 28:
878: # line 158 "config.y"
879: {yyval = otoi(yytext,yyleng);} break;
880: case 32:
881: # line 166 "config.y"
882: {mkdev(yypvt[-3],yypvt[-1],yypvt[-0]);} break;
883: case 33:
884: # line 169 "config.y"
885: {yyval = currdname = ckdname(yypvt[-0]);} break;
886: case 34:
887: # line 172 "config.y"
888: {yyval = 0;} break;
889: case 35:
890: # line 174 "config.y"
891: {yyval = yypvt[-0];} break;
892: }
893: goto yystack; /* stack new state and value */
894:
895: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.