![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckwart.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / kermit|
Return to ckwart.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / kermit |
1.1 root 1: char *wartv = "Wart Version 1A(003) 27 May 85";
2:
3: /* W A R T */
4:
5: /*
6: pre-process a lex-like file into a C program.
7:
8: Author:Jeff Damens, Columbia University Center for Computing Activites, 11/84.
9: Copyright (C) 1985, Trustees of Columbia University in the City of New York.
10: Permission is granted to any individual or institution to use, copy, or
11: redistribute this software so long as it is not sold for profit, provided this
12: copyright notice is retained.
13:
14: * input format is:
15: * lines to be copied | %state <state names...>
16: * %%
17: * <state> | <state,state,...> CHAR { actions }
18: * ...
19: * %%
20: */
21:
22: #include "ckcdeb.h" /* Includes */
23: #include <stdio.h>
24: #include <ctype.h>
25:
26: #define C_L 014 /* Formfeed */
27:
28: #define SEP 1 /* Token types */
29: #define LBRACK 2
30: #define RBRACK 3
31: #define WORD 4
32: #define COMMA 5
33:
34: /* Storage sizes */
35:
36: #define MAXSTATES 50 /* max number of states */
37: #define MAXWORD 50 /* max # of chars/word */
38: #define SBYTES ((MAXSTATES+7)/8) /* # of bytes for state bitmask */
39:
40: /* Name of wart function in generated program */
41:
42: #ifndef FNAME
43: #define FNAME "wart"
44: #endif
45:
46: /* Structure for state information */
47:
48: struct trans { CHAR states[SBYTES]; /* included states */
49: int anyst; /* true if this good from any state */
50: CHAR inchr; /* input character */
51: int actno; /* associated action */
52: struct trans *nxt; }; /* next transition */
53:
54: typedef struct trans *Trans;
55:
56: char *malloc(); /* Returns pointer (not int) */
57:
58:
59: /* Variables and tables */
60:
61: int lines,nstates,nacts;
62:
63: char tokval[MAXWORD];
64:
65: int tbl[MAXSTATES*128];
66:
67:
68:
69: char *txt1 = "\n#define BEGIN state =\n\nint state = 0;\n\n";
70:
71: char *fname = FNAME; /* function name goes here */
72:
73: /* rest of program... */
74:
75: char *txt2 = "()\n\
76: {\n\
77: int c,actno;\n\
78: extern int tbl[];\n\
79: while (1) {\n\
80: c = input();\n\
81: if ((actno = tbl[c + state*128]) != -1)\n\
82: switch(actno) {\n";
83:
84: /* this program's output goes here, followed by final text... */
85:
86: char *txt3 = "\n }\n }\n}\n\n";
87:
88:
89: /*
90: * turn on the bit associated with the given state
91: *
92: */
93: setstate(state,t)
94: int state;
95: Trans t;
96: {
97: int idx,msk;
98: idx = state/8; /* byte associated with state */
99: msk = 0x80 >> (state % 8); /* bit mask for state */
100: t->states[idx] |= msk;
101: }
102:
103: /*
104: * see if the state is involved in the transition
105: *
106: */
107:
108: teststate(state,t)
109: int state;
110: Trans t;
111: {
112: int idx,msk;
113: idx = state/8;
114: msk = 0x80 >> (state % 8);
115: return(t->states[idx] & msk);
116: }
117:
118:
119: /*
120: * read input from here...
121: *
122: */
123:
124: Trans
125: rdinput(infp,outfp)
126: FILE *infp,*outfp;
127: {
128: Trans x,rdrules();
129: lines = 1; /* line counter */
130: nstates = 0; /* no states */
131: nacts = 0; /* no actions yet */
132: fprintf(outfp,"\n%c* WARNING -- This C source program generated by ",'/');
133: fprintf(outfp,"Wart preprocessor. */\n");
134: fprintf(outfp,"%c* Do not edit this file; edit the Wart-format ",'/');
135: fprintf(outfp,"source file instead, */\n");
136: fprintf(outfp,"%c* and then run it through Wart to produce a new ",'/');
137: fprintf(outfp,"C source file. */\n\n");
138: fprintf(outfp,"%c* Wart Version Info: */\n",'/');
139: fprintf(outfp,"char *wartv = \"%s\";\n\n",wartv);
140:
141: initial(infp,outfp); /* read state names, initial defs */
142: prolog(outfp); /* write out our initial code */
143: x = rdrules(infp,outfp); /* read rules */
144: epilogue(outfp); /* write out epilogue code */
145: return(x);
146: }
147:
148:
149: /*
150: * initial - read initial definitions and state names. Returns
151: * on EOF or %%.
152: *
153: */
154:
155: initial(infp,outfp)
156: FILE *infp,*outfp;
157: {
158: int c;
159: char wordbuf[MAXWORD];
160: while ((c = getc(infp)) != EOF) {
161: if (c == '%') {
162: rdword(infp,wordbuf);
163: if (strcmp(wordbuf,"states") == 0)
164: rdstates(infp,outfp);
165: else if (strcmp(wordbuf,"%") == 0) return;
166: else fprintf(outfp,"%%%s",wordbuf);
167: }
168: else putc(c,outfp);
169: if (c == '\n') lines++;
170: }
171: }
172:
173: /*
174: * boolean function to tell if the given character can be part of
175: * a word.
176: *
177: */
178: isin(s,c) char *s; int c; {
179: for (; *s != '\0'; s++)
180: if (*s == c) return(1);
181: return(0);
182: }
183: isword(c)
184: int c;
185: {
186: static char special[] = ".%_-$@"; /* these are allowable */
187: return(isalnum(c) || isin(special,c));
188: }
189:
190: /*
191: * read the next word into the given buffer.
192: *
193: */
194: rdword(fp,buf)
195: FILE *fp;
196: char *buf;
197: {
198: int len = 0,c;
199: while (isword(c = getc(fp)) && ++len < MAXWORD) *buf++ = c;
200: *buf++ = '\0'; /* tie off word */
201: ungetc(c,fp); /* put break char back */
202: }
203:
204:
205: /*
206: * read state names, up to a newline.
207: *
208: */
209:
210: rdstates(fp,ofp)
211: FILE *fp,*ofp;
212: {
213: int c;
214: char wordbuf[MAXWORD];
215: while ((c = getc(fp)) != EOF && c != '\n')
216: {
217: if (isspace(c) || c == C_L) continue; /* skip whitespace */
218: ungetc(c,fp); /* put char back */
219: rdword(fp,wordbuf); /* read the whole word */
220: enter(wordbuf,++nstates); /* put into symbol tbl */
221: fprintf(ofp,"#define %s %d\n",wordbuf,nstates);
222: }
223: lines++;
224: }
225:
226: /*
227: * allocate a new, empty transition node
228: *
229: */
230:
231: Trans
232: newtrans()
233: {
234: Trans new;
235: int i;
236: new = (Trans) malloc(sizeof (struct trans));
237: for (i=0; i<SBYTES; i++) new->states[i] = 0;
238: new->anyst = 0;
239: new->nxt = NULL;
240: return(new);
241: }
242:
243:
244: /*
245: * read all the rules.
246: *
247: */
248:
249: Trans
250: rdrules(fp,out)
251: FILE *fp,*out;
252: {
253: Trans head,cur,prev;
254: int curtok,i;
255: head = cur = NULL;
256: while ((curtok = gettoken(fp)) != SEP)
257:
258: switch(curtok) {
259: case LBRACK: if (cur == NULL) cur = newtrans();
260: else fatal("duplicate state list");
261: statelist(fp,cur);/* set states */
262: continue; /* prepare to read char */
263:
264: case WORD: if (strlen(tokval) != 1)
265: fatal("multiple chars in state");
266: if (cur == NULL) {
267: cur = newtrans();
268: cur->anyst = 1;
269: }
270: cur->actno = ++nacts;
271: cur->inchr = tokval[0];
272: if (head == NULL) head = cur;
273: else prev->nxt = cur;
274: prev = cur;
275: cur = NULL;
276: copyact(fp,out,nacts);
277: break;
278: default: fatal("bad input format");
279: }
280:
281: return(head);
282: }
283:
284:
285: /*
286: * read a list of (comma-separated) states, set them in the
287: * given transition.
288: *
289: */
290: statelist(fp,t)
291: FILE *fp;
292: Trans t;
293: {
294: int curtok,sval;
295: curtok = COMMA;
296: while (curtok != RBRACK) {
297: if (curtok != COMMA) fatal("missing comma");
298: if ((curtok = gettoken(fp)) != WORD) fatal("missing state name");
299: if ((sval = lkup(tokval)) == -1) {
300: fprintf(stderr,"state %s undefined\n",tokval);
301: fatal("undefined state");
302: }
303: setstate(sval,t);
304: curtok = gettoken(fp);
305: }
306: }
307:
308: /*
309: * copy an action from the input to the output file
310: *
311: */
312: copyact(inp,outp,actno)
313: FILE *inp,*outp;
314: int actno;
315: {
316: int c,bcnt;
317: fprintf(outp,"case %d:\n",actno);
318: while (((c = getc(inp)) != '\n') && (isspace(c) || c == C_L));
319: if (c == '{') {
320: bcnt = 1;
321: putc(c,outp);
322: while (bcnt > 0 && (c = getc(inp)) != EOF) {
323: if (c == '{') bcnt++;
324: else if (c == '}') bcnt--;
325: else if (c == '\n') lines++;
326: putc(c,outp);
327: }
328: if (bcnt > 0) fatal("action doesn't end");
329: }
330: else {
331: while (c != '\n' && c != EOF) {
332: putc(c,outp);
333: c = getc(inp);
334: }
335: lines++;
336: }
337: fprintf(outp,"\nbreak;\n");
338: }
339:
340:
341: /*
342: * find the action associated with a given character and state.
343: * returns -1 if one can't be found.
344: *
345: */
346: faction(hd,state,chr)
347: Trans hd;
348: int state,chr;
349: {
350: while (hd != NULL) {
351: if (hd->anyst || teststate(state,hd))
352: if (hd->inchr == '.' || hd->inchr == chr) return(hd->actno);
353: hd = hd->nxt;
354: }
355: return(-1);
356: }
357:
358:
359: /*
360: * empty the table...
361: *
362: */
363: emptytbl()
364: {
365: int i;
366: for (i=0; i<nstates*128; i++) tbl[i] = -1;
367: }
368:
369: /*
370: * add the specified action to the output for the given state and chr.
371: *
372: */
373:
374: addaction(act,state,chr)
375: int act,state,chr;
376: {
377: tbl[state*128 + chr] = act;
378: }
379:
380: writetbl(fp)
381: FILE *fp;
382: {
383: warray(fp,"tbl",tbl,128*(nstates+1));
384: }
385:
386:
387: /*
388: * write an array to the output file, given its name and size.
389: *
390: */
391: warray(fp,nam,cont,siz)
392: FILE *fp;
393: char *nam;
394: int cont[],siz;
395: {
396: int i;
397: fprintf(fp,"int %s[] = {\n",nam);
398: for (i = 0; i < siz; i++) {
399: fprintf(fp,"%d, ",cont[i]);
400: if ((i % 20) == 0) putc('\n',fp);
401: }
402: fprintf(fp,"};\n");
403: }
404:
405: main(argc,argv)
406: int argc;
407: char *argv[];
408: {
409: Trans head;
410: int state,c;
411: FILE *infile,*outfile;
412:
413: if (argc > 1) {
414: if ((infile = fopen(argv[1],"r")) == NULL) {
415: fprintf(stderr,"Can't open %s\n",argv[1]);
416: fatal("unreadable input file"); } }
417: else infile = stdin;
418:
419: if (argc > 2) {
420: if ((outfile = fopen(argv[2],"w")) == NULL) {
421: fprintf(stderr,"Can't write to %s\n",argv[2]);
422: fatal("bad output file"); } }
423: else outfile = stdout;
424:
425: clrhash(); /* empty hash table */
426: head = rdinput(infile,outfile); /* read input file */
427: emptytbl(); /* empty our tables */
428: for (state = 0; state <= nstates; state++)
429: for (c = 1; c < 128; c++)
430: addaction(faction(head,state,c),state,c); /* find actions, add to tbl */
431: writetbl(outfile);
432: copyrest(infile,outfile);
433: fprintf(stderr,"%d states, %d actions\n",nstates,nacts);
434: #ifdef undef
435: for (state = 1; state <= nstates; state ++)
436: for (c = 1; c < 128; c++)
437: if (tbl[state*128 + c] != -1) printf("state %d, chr %d, act %d\n",
438: state,c,tbl[state*128 + c]);
439: #endif
440: exit(GOOD_EXIT);
441: }
442:
443:
444: /*
445: * fatal error handler
446: *
447: */
448:
449: fatal(msg)
450: char *msg;
451: {
452: fprintf(stderr,"error in line %d: %s\n",lines,msg);
453: exit(BAD_EXIT);
454: }
455:
456: prolog(outfp)
457: FILE *outfp;
458: {
459: int c;
460: while ((c = *txt1++) != '\0') putc(c,outfp);
461: while ((c = *fname++) != '\0') putc(c,outfp);
462: while ((c = *txt2++) != '\0') putc(c,outfp);
463: }
464:
465: epilogue(outfp)
466: FILE *outfp;
467: {
468: int c;
469: while ((c = *txt3++) != '\0') putc(c,outfp);
470: }
471:
472: copyrest(in,out)
473: FILE *in,*out;
474: {
475: int c;
476: while ((c = getc(in)) != EOF) putc(c,out);
477: }
478:
479:
480: /*
481: * gettoken - returns token type of next token, sets tokval
482: * to the string value of the token if appropriate.
483: *
484: */
485:
486: gettoken(fp)
487: FILE *fp;
488: {
489: int c;
490: while (1) { /* loop if reading comments... */
491: do {
492: c = getc(fp);
493: if (c == '\n') lines++;
494: } while ((isspace(c) || c == C_L)); /* skip whitespace */
495: switch(c) {
496: case EOF: return(SEP);
497: case '%': if ((c = getc(fp)) == '%') return(SEP);
498: tokval[0] = '%';
499: tokval[1] = c;
500: rdword(fp,tokval+2);
501: return(WORD);
502: case '<': return(LBRACK);
503: case '>': return(RBRACK);
504: case ',': return(COMMA);
505: case '/': if ((c = getc(fp)) == '*') {
506: rdcmnt(fp); /* skip over the comment */
507: continue; } /* and keep looping */
508: else {
509: ungetc(c); /* put this back into input */
510: c = '/'; } /* put character back, fall thru */
511:
512: default: if (isword(c)) {
513: ungetc(c,fp);
514: rdword(fp,tokval);
515: return(WORD);
516: }
517: else fatal("Invalid character in input");
518: }
519: }
520: }
521:
522: /*
523: * skip over a comment
524: *
525: */
526:
527: rdcmnt(fp)
528: FILE *fp;
529: {
530: int c,star,prcnt;
531: prcnt = star = 0; /* no star seen yet */
532: while (!((c = getc(fp)) == '/' && star)) {
533: if (c == EOF || (prcnt && c == '%')) fatal("Unterminated comment");
534: prcnt = (c == '%');
535: star = (c == '*');
536: if (c == '\n') lines++; }
537: }
538:
539:
540:
541: /*
542: * symbol table management for wart
543: *
544: * entry points:
545: * clrhash - empty hash table.
546: * enter - enter a name into the symbol table
547: * lkup - find a name's value in the symbol table.
548: *
549: */
550:
551: #define HASHSIZE 101 /* # of entries in hash table */
552:
553: struct sym { char *name; /* symbol name */
554: int val; /* value */
555: struct sym *hnxt; } /* next on collision chain */
556: *htab[HASHSIZE]; /* the hash table */
557:
558:
559: /*
560: * empty the hash table before using it...
561: *
562: */
563: clrhash()
564: {
565: int i;
566: for (i=0; i<HASHSIZE; i++) htab[i] = NULL;
567: }
568:
569: /*
570: * compute the value of the hash for a symbol
571: *
572: */
573: hash(name)
574: char *name;
575: {
576: int sum;
577: for (sum = 0; *name != '\0'; name++) sum += (sum + *name);
578: sum %= HASHSIZE; /* take sum mod hashsize */
579: if (sum < 0) sum += HASHSIZE; /* disallow negative hash value */
580: return(sum);
581: }
582:
583: /*
584: * make a private copy of a string...
585: *
586: */
587: char *
588: copy(s)
589: char *s;
590: {
591: char *new;
592: new = (char *) malloc(strlen(s) + 1);
593: strcpy(new,s);
594: return(new);
595: }
596:
597:
598: /*
599: * enter state name into the hash table
600: *
601: */
602: enter(name,svalue)
603: char *name;
604: int svalue;
605: {
606: int h;
607: struct sym *cur;
608: if (lkup(name) != -1) {
609: fprintf(stderr,"state %s appears twice...\n");
610: exit(BAD_EXIT); }
611: h = hash(name);
612: cur = (struct sym *)malloc(sizeof (struct sym));
613: cur->name = copy(name);
614: cur->val = svalue;
615: cur->hnxt = htab[h];
616: htab[h] = cur;
617: }
618:
619: /*
620: * find name in the symbol table, return its value. Returns -1
621: * if not found.
622: *
623: */
624: lkup(name)
625: char *name;
626: {
627: struct sym *cur;
628: for (cur = htab[hash(name)]; cur != NULL; cur = cur->hnxt)
629: if (strcmp(cur->name,name) == 0) return(cur->val);
630: return(-1);
631: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.