![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to config.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [XINU] / xinu / con|
Return to config.c CVS log | Up to [XINU] / xinu / con |
1.1 root 1: From allegra!vivace!dec Mon Apr 25 20:21:44 1983
2: Date: Mon Apr 25 20:18:09 1983
3: config: lex.yy.c y.tab.c
4: cc -o config y.tab.c -ll
5:
6: all: config
7:
8: lex.yy.c: config.l
9: lex config.l
10:
11: y.tab.c: config.y
12: yacc config.y
13:
14: install: config
15: mv config ../sys/config
16:
17: clean:
18: rm -f lex.yy.c y.tab.c core
19: -------------------------------------------------------------------------------
20: A [a-z_A-Z]
21: M [a-z_A-Z0-9]
22: int skipping;
23: %%
24: "/*" {skipping = 1;}
25: "*/" {skipping = 0;}
26: "%" {extern int brkcount;
27: if (! skipping)
28: if (++brkcount == 2)
29: return(0); /* end-of-file */
30: else
31: return(DEFBRK);
32: }
33: ":" {if (! skipping) return(COLON);}
34: 0[0-9]* {if (! skipping) return(OCTAL);}
35: [1-9][0-9]+ {if (! skipping) return(INTEGER);}
36: is {if (! skipping) return(IS);}
37: on {if (! skipping) return(ON);}
38: "=" ;
39: "iint" {if (! skipping) return(IINT);}
40: "-iint" {if (! skipping) return(IINT);}
41: "oint" {if (! skipping) return(OINT);}
42: "-oint" {if (! skipping) return(OINT);}
43: "-csr" {if (! skipping) return(CSR);}
44: "csr" {if (! skipping) return(CSR);}
45: "-ivec" {if (! skipping) return(IVEC);}
46: "ivec" {if (! skipping) return(IVEC);}
47: "-ovec" {if (! skipping) return(OVEC);}
48: "ovec" {if (! skipping) return(OVEC);}
49: "-i" {if (! skipping) return(INIT);}
50: "i" {if (! skipping) return(INIT);}
51: "-o" {if (! skipping) return(OPEN);}
52: "o" {if (! skipping) return(OPEN);}
53: "-c" {if (! skipping) return(CLOSE);}
54: "c" {if (! skipping) return(CLOSE);}
55: "-r" {if (! skipping) return(READ);}
56: "r" {if (! skipping) return(READ);}
57: "-g" {if (! skipping) return(GETC);}
58: "g" {if (! skipping) return(GETC);}
59: "-p" {if (! skipping) return(PUTC);}
60: "p" {if (! skipping) return(PUTC);}
61: "-w" {if (! skipping) return(WRITE);}
62: "w" {if (! skipping) return(WRITE);}
63: "-s" {if (! skipping) return(SEEK);}
64: "s" {if (! skipping) return(SEEK);}
65: "-n" {if (! skipping) return(CNTL);}
66: "n" {if (! skipping) return(CNTL);}
67: [ \t]+ ;
68: "\n" {extern int linectr;
69: linectr++;
70: }
71: {A}{M}* {if (! skipping) return(IDENT);}
72: . {if (! skipping) return(yytext[0]);}
73: -------------------------------------------------------------------------------
74: %token DEFBRK COLON OCTAL INTEGER IDENT CSR IVEC OVEC IINT OINT
75: INIT OPEN CLOSE READ WRITE SEEK CNTL IS ON GETC PUTC
76: %{
77: #include <stdio.h>
78:
79: #define NIL (dvptr)0
80:
81: #define CONFIGC "../sys/conf.c" /* name of .c output */
82: #define CONFIGH "../h/conf.h" /* name of .h output */
83: #define CONFIGIN "Configuration" /* name of input file */
84:
85: FILE *confc;
86: FILE *confh;
87:
88: char *dbstr;
89: extern char *malloc();
90: int ndevs = 0;
91: int currname = -1;
92: int currtname = -1;
93: int currdname = -1;
94: int brkcount = 0;
95:
96: struct syment { /* symbol table */
97: char *symname;
98: int symoccurs;
99: } symtab[250];
100:
101: int nsym = 0;
102: int lookup();
103: int linectr = 1;
104: char *doing = "device type declaration";
105: char *s;
106: struct dvtype {
107: char *dvname; /* device name (not used in types)*/
108: char *dvtname; /* type name */
109: int dvtnum; /* symbol table index of type */
110: char *dvdevice; /* device name */
111: int dvcsr; /* Control Status Register addr */
112: int dvivec; /* input interrupt vector */
113: int dvovec; /* Output interrupt vector */
114: char dviint[20]; /* input interrupt routine */
115: char dvoint[20]; /* output interrupt routine */
116: char dvinit[20]; /* init routine name */
117: char dvopen[20]; /* open routine name */
118: char dvclose[20]; /* close routine name */
119: char dvread[20]; /* read routine name */
120: char dvwrite[20]; /* write routine name */
121: char dvcntl[20]; /* control routine name */
122: char dvseek[20]; /* seek routine name */
123: char dvgetc[20]; /* getc routine name */
124: char dvputc[20]; /* putc routine name */
125: int dvminor; /* device number 0,1,... */
126: struct dvtype *dvnext; /* next node on the list */
127: };
128: typedef struct dvtype *dvptr;
129: dvptr ftypes = NIL; /* linked list of device types */
130: dvptr devs = NIL; /* linked list of device decls. */
131: dvptr lastdv = NIL;
132: dvptr currtype = NIL;
133:
134: char *ftout[] =
135: {"struct\tdevsw\t{\t\t\t/* device table entry */\n",
136: "\tint\tdvnum;\n",
137: "\tint\t(*dvinit)();\n",
138: "\tint\t(*dvopen)();\n",
139: "\tint\t(*dvclose)();\n",
140: "\tint\t(*dvread)();\n",
141: "\tint\t(*dvwrite)();\n",
142: "\tint\t(*dvseek)();\n",
143: "\tint\t(*dvgetc)();\n",
144: "\tint\t(*dvputc)();\n",
145: "\tint\t(*dvcntl)();\n",
146: "\tint\tdvcsr;\n",
147: "\tint\tdvivec;\n",
148: "\tint\tdvovec;\n",
149: "\tint\t(*dviint)();\n",
150: "\tint\t(*dvoint)();\n",
151: "\tchar\t*dvioblk;\n",
152: "\tint\tdvminor;\n",
153: "\t};\n\n",
154: "extern\tstruct\tdevsw devtab[];",
155: "\t\t/* one entry per device */\n\n",
156: NULL};
157: %}
158: %%
159: config.input : devicetypes devicedescriptors
160: ;
161: devicetypes : ftypes DEFBRK
162: {doing = "device definitions";}
163: ;
164: ftypes : /**/
165: | ftypes ftype
166: ;
167: ftype : tname device.list
168: ;
169: device.list : devheader attribute.list
170: | device.list devheader attribute.list
171: ;
172: devheader : ON id
173: {mktype($2);}
174: ;
175: tname : id COLON
176: {$$ = currtname = cktname($1);}
177: ;
178: id : IDENT
179: {$$ = currname =
180: lookup(yytext,yyleng);
181: }
182: ;
183: attribute.list : /**/
184: | attribute.list attribute
185: ;
186: attribute : CSR number
187: {newattr(CSR,$2);}
188: | IVEC number
189: {newattr(IVEC,$2);}
190: | OVEC number
191: {newattr(OVEC,$2);}
192: | IINT id
193: {newattr(IINT,$2);}
194: | OINT id
195: {newattr(OINT,$2);}
196: | OPEN id
197: {newattr(OPEN,$2);}
198: | CLOSE id
199: {newattr(CLOSE,$2);}
200: | INIT id
201: {newattr(INIT,$2);}
202: | GETC id
203: {newattr(GETC,$2);}
204: | PUTC id
205: {newattr(PUTC,$2);}
206: | READ id
207: {newattr(READ,$2);}
208: | WRITE id
209: {newattr(WRITE,$2);}
210: | SEEK id
211: {newattr(SEEK,$2);}
212: | CNTL id
213: {newattr(CNTL,$2);}
214: ;
215: number : INTEGER
216: /* Assume all input is octal */
217: /* for now; distinction is */
218: /* made in lexical routines */
219: /* just in case of change */
220:
221: {$$ = otoi(yytext,yyleng);}
222: | OCTAL
223: {$$ = otoi(yytext,yyleng);}
224: ;
225: devicedescriptors : /**/
226: | devicedescriptors descriptor
227: ;
228: descriptor : fspec attribute.list
229: ;
230: fspec : dname IS id optional.on
231: {mkdev($1,$3,$4);}
232: ;
233: dname : id
234: {$$ = currdname = ckdname($1);}
235: ;
236: optional.on : /**/
237: {$$ = 0;}
238: | ON id
239: {$$ = $2;}
240: ;
241: %%
242: #include "lex.yy.c"
243: main(argc, argv)
244: int argc;
245: char *argv[];
246: {
247: int n, i, j, l, fcount;
248: dvptr s;
249: int verbose = 0;
250: char *p;
251: char c;
252:
253: if (argc>1 && (strcmp("-v",argv[1])==0)) {
254: argc--;
255: argv++;
256: verbose++;
257: }
258: if (argc>2) {
259: fprintf(stderr,"use: config [-v] [file]\n");
260: exit(1);
261: }
262: if (verbose)
263: printf("Opening input file...\n");
264: if (argc == 2) {
265: if (freopen(argv[1], "r", stdin) == NULL) {
266: fprintf(stderr,"Can't open %s\n",argv[1]);
267: exit(1);
268: }
269: } else { /* try to open Configuration file */
270: if (freopen(CONFIGIN, "r", stdin) == NULL) {
271: fprintf(stderr,"Can't open %s\n", CONFIGIN);
272: exit(1);
273: }
274: }
275:
276: /* Parse the Configuration file */
277:
278: if (verbose)
279: printf("Parsing configuration specs...\n");
280: if ((n=yyparse()) != 0)
281: exit(n);
282:
283: /* write config.h and config.c */
284:
285: if (verbose)
286: printf("Opening output files...\n");
287: if ( (confc=fopen(CONFIGC,"w") ) == NULL) {
288: fprintf(stderr, "Can't write on %s\n", CONFIGC);
289: exit(1);
290: }
291:
292: if ( (confh=fopen(CONFIGH,"w") ) == NULL) {
293: fprintf(stderr, "Can't write on %s\n", CONFIGH);
294: exit(1);
295: }
296: fprintf(confh,
297: "/* conf.h (GENERATED FILE; DO NOT EDIT) */\n");
298: fprintf(confc,
299: "/* conf.c (GENERATED FILE; DO NOT EDIT) */\n");
300: fprintf(confc, "\n#include \"%s\"\n", CONFIGH);
301: fprintf(confh, "\n#define\tNULLPTR\t(char *)0\n");
302:
303:
304: if (verbose)
305: printf("Writing output...\n");
306: fprintf(confh,"\n/* Device table declarations */\n");
307: for (i=0 ; (p=ftout[i])!=NULL ; i++)
308: fprintf(confh, "%s", p);
309:
310: /* write device declarations and definitions; count type refs. */
311:
312: fprintf(confh, "\n/* Device name definitions */\n\n");
313: for (i=0,s=devs; s!=NIL ; s=s->dvnext,i++) {
314: fprintf(confh, "#define\t%-12s%d\t\t\t/* type %-8s */\n",
315: s->dvname, i, s->dvtname);
316: s->dvminor = symtab[s->dvtnum].symoccurs++;
317: }
318:
319: /* write count of device types */
320:
321: fprintf(confh,"\n/* Control block sizes */\n\n");
322: for (i=0 ; i<nsym ; i++)
323: if (symtab[i].symoccurs > 0) {
324: fprintf(confh, "#define\tN%s\t%d\n",
325: symtab[i].symname, symtab[i].symoccurs);
326: }
327: if (ndevs > 0)
328: fprintf(confh, "\n#define\tNDEVS\t%d\n\n", ndevs);
329:
330: /* empty symbol table, collect, and write names of all I/O routines */
331:
332: nsym = 0;
333: for (s=devs; s!=NIL ; s=s->dvnext) {
334: lookup(s->dvinit,strlen(s->dvinit));
335: lookup(s->dvopen,strlen(s->dvopen));
336: lookup(s->dvclose,strlen(s->dvclose));
337: lookup(s->dvread,strlen(s->dvread));
338: lookup(s->dvwrite,strlen(s->dvwrite));
339: lookup(s->dvseek,strlen(s->dvseek));
340: lookup(s->dvcntl,strlen(s->dvcntl));
341: lookup(s->dvgetc,strlen(s->dvgetc));
342: lookup(s->dvputc,strlen(s->dvputc));
343: lookup(s->dviint,strlen(s->dviint));
344: lookup(s->dvoint,strlen(s->dvoint));
345:
346: }
347: fprintf(confh,
348: "/* Declarations of I/O routines referenced */\n\n");
349: for (i=0 ; i<nsym ; i++)
350: fprintf(confh, "extern\tint\t%s();\n", symtab[i].symname);
351:
352:
353: /* produce devtab (giant I/O switch table) */
354:
355: fprintf(confc, "\n/* device independent I/O switch */\n\n");
356: if (ndevs > 0)
357: fprintf(confc, "struct\tdevsw\tdevtab[NDEVS] = {\n");
358: for (fcount=0,s=devs ; s!=NIL ; s=s->dvnext,fcount++) {
359: fprintf(confc, "\n/* %s */\n", s->dvname, s->dvtname);
360: fprintf(confc, "%d,\n", fcount);
361: fprintf(confc, "%s, %s, %s,\n",
362: s->dvinit, s->dvopen, s->dvclose);
363: fprintf(confc, "%s, %s, %s,\n",
364: s->dvread, s->dvwrite, s->dvseek);
365: fprintf(confc, "%s, %s, %s,\n",
366: s->dvgetc, s->dvputc, s->dvcntl);
367: fprintf(confc, "0%06o, 0%03o, 0%03o,\n",
368: s->dvcsr, s->dvivec, s->dvovec);
369: fprintf(confc, "%s, %s, NULLPTR, %d",
370: s->dviint, s->dvoint, s->dvminor);
371: if ( s->dvnext != NIL )
372: fprintf(confc, ",\n");
373: else
374: fprintf(confc, "\n\t};");
375: }
376:
377: /* Copy definitions to output */
378:
379: if (brkcount == 2 && verbose)
380: printf("Copying definitions to %s...\n", CONFIGH);
381: if (brkcount == 2 )
382: while ( (c=input()) != 0) /* lex input routine */
383: putc(c, confh);
384:
385: /* guarantee conf.c written later than conf.c for make */
386:
387: fclose(confh);
388: fprintf(confc, "\n");
389: fclose(confc);
390:
391: /* finish up and write report for user if requested */
392:
393: if (verbose) {
394: printf("\nConfiguration complete. Number of devs=%d:\n\n",ndevs);
395: for (s=devs; s!=NIL ; s=s->dvnext)
396: printf(
397: "Device %s (on %s) csr=0%-7o, ivec=0%-3o, ovec=0%-3o, minor=%d\n",
398: s->dvname, s->dvdevice, s->dvcsr, s->dvivec, s->dvovec,
399: s->dvminor);
400: }
401:
402:
403: }
404:
405:
406: yyerror(s)
407: char *s;
408: {
409: fprintf(stderr,"Syntax error in %s on line %d\n",
410: doing,linectr);
411: }
412:
413:
414: /* lookup -- lookup a name in the symbol table; return position */
415:
416: lookup(str,len)
417: char *str;
418: int len;
419: {
420: int i;
421: char *s;
422:
423: if (len >= 20) {
424: len = 19;
425: fprintf(stderr,"warning: name %s truncated\n",str);
426: }
427: s = malloc(len+1);
428: strncpy(s,str,len);
429: s[len] = '\000';
430: for (i=0 ; i<nsym ; i++)
431: if (strcmp(s,symtab[i].symname) == 0){
432: return(i);
433: }
434: symtab[nsym].symname = s;
435: symtab[nsym].symoccurs = 0;
436: return(nsym++);
437: }
438:
439: atoi(str,len)
440: char *str;
441: int len;
442: {
443: int i;
444: char c;
445:
446: for (i=0; len > 0 ; len--) {
447: c = *str++;
448: i = 10*i + (c - '0');
449: }
450: }
451: otoi(str,len)
452: char *str;
453: int len;
454: {
455: int i;
456: char c;
457:
458: for (i=0; len > 0 ; len--) {
459: c = *str++;
460: if (c > '7')
461: fprintf(stderr,"invalid octal digit on line %d\n",
462: linectr);
463: else
464: i = 8*i + (c - '0');
465: }
466: }
467:
468: /* newattr -- add a new attribute spec to current type/device description */
469:
470: newattr(tok,val)
471: int tok; /* token type (attribute type) */
472: int val; /* symbol number of value */
473: {
474: char *c;
475: dvptr s;
476:
477: if (devs == NIL) /* doing types */
478: s = currtype;
479: else
480: s = lastdv;
481: if (val>=0 && val<nsym) {
482: c = symtab[val].symname;
483: if (strlen(c) > 20 ) {
484: fprintf(stderr,"Internal overflow\n");
485: exit(1);
486: }
487: } else
488: c = NULL;
489:
490: switch (tok) {
491:
492: case CSR: s->dvcsr = val;
493: break;
494: case IVEC: s->dvivec = val;
495: break;
496: case OVEC: s->dvovec = val;
497: break;
498: case IINT: strcpy(s->dviint,c);
499: break;
500: case OINT: strcpy(s->dvoint,c);
501: break;
502: case READ: strcpy(s->dvread,c);
503: break;
504: case WRITE: strcpy(s->dvwrite,c);
505: break;
506: case GETC: strcpy(s->dvgetc,c);
507: break;
508: case PUTC: strcpy(s->dvputc,c);
509: break;
510: case OPEN: strcpy(s->dvopen,c);
511: break;
512: case CLOSE: strcpy(s->dvclose,c);
513: break;
514: case INIT: strcpy(s->dvinit,c);
515: break;
516: case SEEK: strcpy(s->dvseek,c);
517: break;
518: case CNTL: strcpy(s->dvcntl,c);
519: break;
520: default: fprintf(stderr, "Internal error 1\n");
521: }
522: }
523:
524: /* cktname -- check type name for duplicates */
525:
526: cktname(symid)
527: int symid;
528: {
529: dvptr s;
530: extern dvptr ftypes;
531: char *name;
532:
533: name = symtab[symid].symname;
534: for (s=ftypes; s!=NIL ; s=s->dvnext) {
535: if (s->dvtname == name) {
536: fprintf(stderr,"Duplicate type name %s on line %d\n",
537: name,linectr);
538: exit(1);
539: }
540: }
541: return(symid);
542: }
543:
544: /* mktype -- make a node in the type list and initialize to defaults */
545:
546: mktype(deviceid)
547: int deviceid;
548: {
549: dvptr s,p;
550: char *tn,*dn;
551:
552: p = NIL;
553: tn = symtab[currtname].symname;
554: dn = symtab[deviceid].symname;
555: for (s = ftypes; s!=NIL ; s=s->dvnext) {
556: if (s->dvtname == tn && s->dvdevice==dn) {
557: fprintf(stderr,
558: "Duplicate device %s for type %s on line %d\n",
559: dn, tn, linectr);
560: exit(1);
561: }
562: p = s;
563: }
564: currtype = s = (dvptr) malloc( sizeof(struct dvtype));
565: if (ftypes != NIL) {
566: p->dvnext = s;
567: }
568: else {
569: ftypes = s;
570: }
571: initattr(s, currtname, deviceid);
572: }
573:
574: /* initialize attributes in a type declaration node to typename... */
575:
576: initattr(fstr, tnum, deviceid)
577: dvptr fstr;
578: int tnum;
579: int deviceid;
580: {
581: char *typnam;
582:
583: typnam = symtab[tnum].symname;
584: fstr->dvname = NULL;
585: fstr->dvtname = typnam;
586: fstr->dvtnum = tnum;
587: fstr->dvdevice = symtab[deviceid].symname;
588: fstr->dvcsr = 0;
589: fstr->dvivec = 0;
590: fstr->dvovec = 0;
591: strcpy(fstr->dviint,typnam);
592: strcat(fstr->dviint,"iin");
593: strcpy(fstr->dvoint,typnam);
594: strcat(fstr->dvoint,"oin");
595: strcpy(fstr->dvinit,typnam);
596: strcat(fstr->dvinit,"init");
597: strcpy(fstr->dvopen,typnam);
598: strcat(fstr->dvopen,"open");
599: strcpy(fstr->dvclose,typnam);
600: strcat(fstr->dvclose,"close");
601: strcpy(fstr->dvread,typnam);
602: strcat(fstr->dvread,"read");
603: strcpy(fstr->dvwrite,typnam);
604: strcat(fstr->dvwrite,"write");
605: strcpy(fstr->dvcntl,typnam);
606: strcat(fstr->dvcntl,"control");
607: strcpy(fstr->dvseek,typnam);
608: strcat(fstr->dvseek,"seek");
609: strcpy(fstr->dvgetc,typnam);
610: strcat(fstr->dvgetc,"getc");
611: strcpy(fstr->dvputc,typnam);
612: strcat(fstr->dvputc,"putc");
613: fstr->dvminor = 0;
614: }
615:
616: /* mkdev -- make a node on the device list */
617:
618: mkdev(nameid, typid, deviceid)
619: int nameid, typid, deviceid;
620: {
621: dvptr s;
622: char *devn,*tn,*dn;
623: int found;
624:
625: s = (dvptr) malloc(sizeof(struct dvtype));
626: s->dvnext = NIL;
627: if (devs == NIL) {
628: devs = s;
629: lastdv = s;
630: } else {
631: lastdv->dvnext = s;
632: lastdv = s;
633: }
634: ndevs++;
635: tn = symtab[typid].symname;
636: devn = symtab[nameid].symname;
637: if (deviceid >= 0)
638: dn = symtab[deviceid].symname;
639: else
640: dn = NULL;
641: found = 0;
642: for (s=ftypes ; s != NULL ; s=s->dvnext)
643: if (s->dvtname == tn && (dn==NULL || s->dvdevice==dn)) {
644: strdup(lastdv,s,sizeof(struct dvtype));
645: found=1;
646: break;
647: }
648: if (found==0) {
649: fprintf(stderr,
650: "Bad type or device name in declaration of %s on line %d\n",
651: devn, linectr);
652: exit(1);
653: }
654: lastdv->dvnext = NIL;
655: lastdv->dvname = devn;
656: }
657:
658:
659: /* chdname -- check for duplicate device name */
660:
661: ckdname(devid)
662: int devid;
663: {
664: dvptr s;
665: extern dvptr devs;
666: char *name;
667:
668: name = symtab[devid].symname;
669: for (s=devs; s!=NIL ; s=s->dvnext) {
670: if (s->dvname == name) {
671: fprintf(stderr,"Duplicate device name %s on line %d\n",
672: name,linectr);
673: exit(1);
674: }
675: }
676: return(devid);
677: }
678:
679: strdup(tostr,fromstr,len)
680: char *tostr, *fromstr;
681: int len;
682: {
683: for( ; len > 0 ; len--)
684: *tostr++ = *fromstr++;
685: }
686: -------------------------------------------------------------------------------
687:
688:
689:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.