![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tabgen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / coh|
Return to tabgen.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / coh |
1.1 root 1: /*
2: * Table processor for the
3: * new compiler, machine independent.
4: * Runs under Coherent. Uses
5: * two output files for compatability with
6: * the VAX cross compilers.
7: * Caches pattern flags, node flags, and type flags.
8: * Overlays common sequences before end of macros.
9: */
10: char helpmessage[] = "\
11: Usage: tabgen [-s] [-d define] [-p pfn] [-m mfn] file ...\n\
12: ";
13: /*
14: * Options:
15: * -s report statistics
16: * -d define treat 'define' as defined in #ifdef and #ifndef
17: * NDEF is limit on number of -d define's
18: * -p pfn make 'pfn' the pattern file name
19: * -m mfn make 'mfn' the macro file name
20: * Arguments are concatenated into the tables with attention
21: * #ifdef's and #ifndef's.
22: */
23:
24: #include <ctype.h>
25: #define YATC 1
26: #ifdef vax
27: #include "INC$LIB:host.h"
28: #include "INC$LIB:cc1.h"
29: #else
30: #include "host.h"
31: #include "cc1.h"
32: #endif
33:
34: #define nel(x) (sizeof(x)/sizeof(x[0]))
35:
36: #define NCPS 8 /* Max identifier size */
37: #define NDEF 32 /* Limit on number of -d defines */
38: #define NHASH 512 /* Size of macro element hash */
39: #define NMAC 256 /* Max number of elements in macro */
40:
41: typedef struct cache {
42: struct cache *c_fp;
43: int c_type;
44: int c_sequence;
45: char c_data[];
46: } CACHE;
47:
48: #define CPAT 0
49: #define CTYPE 1
50: #define CFLAG 2
51: #define CICON 3
52: #define CLCON 4
53: #define CGID 5
54: #define CFILE 6
55: #define NCACHE 7
56:
57: typedef struct hash {
58: char s_name[NCPS];
59: } HASH;
60:
61: HASH hash[NHASH];
62: HASH *macv[NMAC];
63: HASH *m_end, *m_newl, *m_jmp, *m_gid, *m_icon, *m_lcon;
64: HASH *mlookup();
65: int nmac = 0;
66:
67: typedef struct sort {
68: int t_boffs;
69: HASH *t_symb;
70: struct sort *t_diff, *t_same;
71: } SORT;
72:
73: SORT *root;
74:
75: FILE *ifp;
76: FILE *pfp;
77: FILE *mfp;
78:
79: int fnseq = 0;
80: char *fname = NULL;
81: int lineno = 0;
82: CACHE *cache = NULL;
83: int boffs = 0;
84: int bsave = 0;
85: int npats = 0;
86: int sflag = 0;
87: int nflag = 0;
88: int flevel = 0;
89: int tlevel = 0;
90: int getnc = 0;
91: int nbol = 0;
92: int ndef = 0;
93: int hiteof = 0;
94: int ungetc = -1;
95: int opseq = 1;
96: int fargc;
97: char **fargv;
98:
99: int cacheseq[NCACHE];
100: char pbuf[128];
101: char *def[NDEF];
102: char *getcp;
103: char getbuf[128];
104:
105: struct optable {
106: char o_id[NCPS]; /* Name */
107: short o_value; /* Op value */
108: short o_seq; /* Pattern sequence */
109: short o_npat; /* # of patterns */
110: } optable[] = {
111: { "ADD", ADD },
112: { "SUB", SUB },
113: { "MUL", MUL },
114: { "DIV", DIV },
115: { "REM", REM },
116: { "AND", AND },
117: { "OR", OR },
118: { "XOR", XOR },
119: { "SHL", SHL },
120: { "SHR", SHR },
121: { "AADD", AADD },
122: { "ASUB", ASUB },
123: { "AMUL", AMUL },
124: { "ADIV", ADIV },
125: { "AREM", AREM },
126: { "AAND", AAND },
127: { "AOR", AOR },
128: { "AXOR", AXOR },
129: { "ASHL", ASHL },
130: { "ASHR", ASHR },
131: { "EQ", EQ },
132: { "NE", NE },
133: { "GT", GT },
134: { "GE", GE },
135: { "LE", LE },
136: { "LT", LT },
137: { "UGT", UGT },
138: { "UGE", UGE },
139: { "ULE", ULE },
140: { "ULT", ULT },
141: { "STAR", STAR },
142: { "ADDR", ADDR },
143: { "NEG", NEG },
144: { "COM", COM },
145: { "NOT", NOT },
146: { "QUEST", QUEST },
147: { "COLON", COLON },
148: { "INCBEF", INCBEF },
149: { "DECBEF", DECBEF },
150: { "INCAFT", INCAFT },
151: { "DECAFT", DECAFT },
152: { "COMMA", COMMA },
153: { "CALL", CALL },
154: { "ANDAND", ANDAND },
155: { "OROR", OROR },
156: { "CAST", CAST },
157: { "CONVERT", CONVERT },
158: { "FIELD", FIELD },
159: { "SIZEOF", SIZEOF },
160: { "ASSIGN", ASSIGN },
161: { "NOP", NOP },
162: { "INIT", INIT },
163: { "ARGLST", ARGLST },
164: { "LEAF", LEAF },
165: { "FIXUP", FIXUP },
166: { "BLKMOVE", BLKMOVE }
167: };
168:
169: /*
170: * Only macros which must be recognized
171: * are listed, the rest are output symbolically.
172: */
173: struct mtab {
174: char m_id[NCPS];
175: short m_byte;
176: } mtab[] = {
177: { "IFR", M_IFR },
178: { "IFE", M_IFE },
179: { "IFV", M_IFV },
180: { "CONST", M_ICON },
181: { "LCONST", M_LCON },
182: { "REGNO", M_REGNO },
183: { "GID", M_GID }
184: };
185:
186: #ifdef Z8001
187: FILE *ofp;
188: char file[2];
189: int line;
190: VARIANT variant;
191: #endif
192:
193: main(argc, argv)
194: char *argv[];
195: {
196: char *pfn;
197: char *mfn;
198: char *p;
199: int c;
200: int i;
201:
202: pfn = "patern.c";
203: mfn = "macros.c";
204: for (i=1; i<argc; ++i) {
205: p = argv[i];
206: if (*p == '-') {
207: while ((c = *++p) != 0) {
208: switch (c) {
209:
210: case 'p':
211: if (++i >= argc)
212: usage();
213: pfn = argv[i];
214: break;
215:
216: case 'm':
217: if (++i >= argc)
218: usage();
219: mfn = argv[i];
220: break;
221:
222: case 's':
223: sflag = 1;
224: break;
225:
226: case 'n':
227: nflag = 1;
228: break;
229:
230: case 'd':
231: if (++i >= argc)
232: usage();
233: def[ndef++] = argv[i];
234: break;
235:
236: default:
237: usage();
238: }
239: }
240: } else
241: break;
242: }
243: fargc = argc - i;
244: fargv = argv + i;
245: if (fargc == 0)
246: usage();
247: pinit(pfn);
248: minit(mfn);
249: if (sflag)
250: for (i=0; i<ndef; ++i)
251: fprintf(stderr, "def[%d] = \"%s\"\n", i, def[i]);
252: ncompile();
253: pfinis();
254: mfinis();
255: if (sflag) {
256: fprintf(stderr, "%d patterns, %d bytes.\n", npats, boffs);
257: fprintf(stderr, "%d bytes saved by goto\n", bsave);
258: fprintf(stderr, "%d patflags\n", cacheseq[CPAT]);
259: fprintf(stderr, "%d types\n", cacheseq[CTYPE]);
260: fprintf(stderr, "%d flags\n", cacheseq[CFLAG]);
261: fprintf(stderr, "%d constants\n", cacheseq[CICON]);
262: fprintf(stderr, "%d long constants\n", cacheseq[CLCON]);
263: fprintf(stderr, "%d global identifiers\n", cacheseq[CGID]);
264: fprintf(stderr, "%d files\n", cacheseq[CFILE]);
265: }
266: exit (OK);
267: }
268:
269: usage()
270: {
271: fprintf(stderr, helpmessage);
272: exit(ABORT);
273: }
274:
275:
276: pinit(pfn)
277: char *pfn;
278: {
279: if ((pfp = fopen(pfn, "w")) == NULL) {
280: fprintf(stderr, "%s: cannot create\n", pfn);
281: exit(ABORT);
282: }
283: intro(pfp);
284: fprintf(pfp, "#if !TINY\n");
285: fprintf(pfp, "#define fl(f,l) , f, l\n");
286: fprintf(pfp, "#else\n");
287: fprintf(pfp, "#define fl(f,l) /* f, l */\n");
288: fprintf(pfp, "#endif\n");
289: fprintf(pfp, "extern char macros[];\n");
290: }
291:
292: minit(mfn)
293: char *mfn;
294: {
295: if ((mfp = fopen(mfn, "w")) == NULL) {
296: fprintf(stderr, "%s: cannot create\n", mfn);
297: exit(ABORT);
298: }
299: intro(mfp);
300: fprintf(mfp, "char macros[] = {\n");
301: m_end = mlookup("M_END");
302: m_newl = mlookup("\n");
303: m_jmp = mlookup("M_JMP");
304: m_gid = mlookup("M_GID");
305: m_icon = mlookup("M_ICON");
306: m_lcon = mlookup("M_LCON");
307: }
308:
309: pfinis()
310: {
311: opindex();
312: dumpcache("PATFLAG\tpatcache", CPAT);
313: fprintf(pfp, "int patcsize=sizeof(patcache)/sizeof(PATFLAG);\n");
314: dumpcache("TYPESET\ttypecache", CTYPE);
315: dumpcache("FLAG\tflagcache", CFLAG);
316: dumpcache("ival_t\tivalcache", CICON);
317: dumpcache("lval_t\tlvalcache", CLCON);
318: dumpcache("char\t*gidcache", CGID);
319: fprintf(pfp, "#if !TINY\n");
320: dumpcache("char\t*namecache", CFILE);
321: fprintf(pfp, "#endif\n");
322: fclose(pfp);
323: }
324:
325: mfinis()
326: {
327: fprintf(mfp, " 0\n};\n");
328: fclose(mfp);
329: }
330:
331: intro(fp)
332: FILE *fp;
333: {
334: fprintf(fp, "#ifdef vax\n");
335: fprintf(fp, "#include \"INC$LIB:cc1.h\"\n");
336: fprintf(fp, "#else\n");
337: fprintf(fp, "#include \"cc1.h\"\n");
338: fprintf(fp, "#endif\n");
339: }
340:
341: ncompile()
342: {
343: extern char *rindex();
344: for (fnseq = 0; fnseq < fargc; fnseq += 1) {
345: fname = fargv[fnseq];
346: if ((ifp = fopen(fname, "r")) == NULL) {
347: fprintf(stderr, "%s: cannot open\n", fname);
348: exit(ABORT);
349: }
350: lineno = 0;
351: hiteof = 0;
352: fprintf(pfp, "/* %s */\n", fname);
353: fprintf(mfp, "/* %s */\n", fname);
354: if (rindex(fname, '/') != 0)
355: fname = rindex(fname, '/')+1;
356: findcache(fname, CFILE);
357: compile();
358: if (tlevel!=0 || flevel!=0)
359: fatal("dangeling #if");
360: fclose(ifp);
361: }
362: }
363:
364: compile()
365: {
366: register struct optable *opp;
367: register c;
368: struct optable *oplookup();
369: char id[NCPS];
370: int npat;
371:
372: c = getnb();
373: while (c != EOF) {
374: if (!isalpha(c))
375: fatal("missing op name");
376: do {
377: getid(c, id);
378: opp = oplookup(id);
379: opp->o_seq = opseq;
380: if (getnb() != ':')
381: fatal("missing ':'");
382: } while (isalpha(c = getnb()));
383: if (c != '%')
384: fatal("missing '%'");
385: fprintf(pfp, "PAT p%d[] = {\n", opseq);
386: npat = 0;
387: do {
388: do {
389: pat(npat);
390: ++npat;
391: ++npats;
392: } while ((c = getnb()) == '%');
393: if (c == EOF)
394: fatal("eof");
395: unget(c);
396: c = body();
397: } while (c == '%');
398: fprintf(pfp, "\n};\n");
399: for (opp = &optable[0]; opp < &optable[nel(optable)]; ++opp)
400: if (opp->o_seq == opseq)
401: opp->o_npat = npat;
402: ++opseq;
403: }
404: }
405:
406: pat(nth)
407: {
408: register char *cbp;
409: register int c;
410: register int i;
411: register int needtbar;
412: int pline;
413: /*
414: * Pattern fields requiring mapping with T_ prefixes
415: * and * translation.
416: */
417: static int tbars[] = {
418: 0,
419: 0, 0, 0, 0, 0,
420: 1, 0,
421: 1, 0
422: };
423: static char none[] = " NONE";
424: static char zero[] = " 0";
425: static char *stars[] = {
426: zero,
427: zero, none, none, none, none,
428: zero, zero,
429: zero, zero
430: };
431:
432: pline = lineno;
433: if (nth > 0)
434: fprintf(pfp, ",\n");
435: fprintf(pfp, " {");
436: for (i=0; i<10; ++i) {
437: cbp = pbuf;
438: if ((c = getnb()) == EOF)
439: fatal("eof");
440: needtbar = tbars[i];
441: do {
442: if (needtbar != 0) {
443: needtbar = 0;
444: if (c != '*') {
445: *cbp++ = 'T';
446: *cbp++ = '_';
447: }
448: }
449: *cbp++ = c;
450: if (c == '|')
451: needtbar = tbars[i];
452: c = get();
453: } while (c!=' ' && c!='\t' && c!='\n');
454: *cbp++ = 0;
455: unget(c);
456: if (strcmp(pbuf, "*") == 0)
457: fprintf(pfp, stars[i]);
458: else {
459: switch (i) {
460: case 0:
461: fprintf(pfp, " %2d", findcache(pbuf, CPAT));
462: break;
463: case 1:
464: case 7:
465: case 9:
466: fprintf(pfp, " %2d", findcache(pbuf, CTYPE));
467: break;
468: case 6:
469: case 8:
470: fprintf(pfp, " %2d", findcache(pbuf, CFLAG));
471: break;
472: default:
473: fprintf(pfp, " %4s", pbuf);
474: }
475: }
476: putc(',', pfp);
477: }
478: fprintf(pfp, " ¯os[%4d]", boffs);
479: fprintf(pfp, " fl(%d,%d)", fnseq, pline);
480: fprintf(pfp, " }");
481: }
482:
483: findcache(p, t)
484: char *p;
485: {
486: register struct cache *cp;
487:
488: cp = cache;
489: while (cp != NULL) {
490: if (cp->c_type==t && strcmp(p, cp->c_data)==0)
491: return (cp->c_sequence);
492: cp = cp->c_fp;
493: }
494: cp = (struct cache *) malloc(sizeof(struct cache)+strlen(p)+1);
495: if (cp == NULL)
496: fatal("out of cache!");
497: cp->c_fp = cache;
498: cache = cp;
499: cp->c_type = t;
500: cp->c_sequence = ++cacheseq[t];
501: strcpy(cp->c_data, p);
502: return (cp->c_sequence);
503: }
504:
505: dumpcache(p, t)
506: char *p;
507: {
508: register struct cache *cp;
509: register int i;
510:
511: fprintf(pfp, "%s[] = {\n", p);
512: for (i=1; i<=cacheseq[t]; ++i) {
513: cp = cache;
514: while (cp != NULL) {
515: if (cp->c_type==t && cp->c_sequence==i)
516: break;
517: cp = cp->c_fp;
518: }
519: if (i > 1)
520: fprintf(pfp, ",\n\t");
521: else
522: fprintf(pfp, "\t");
523: if (t==CGID || t==CFILE)
524: fprintf(pfp, "\"%s\"", cp->c_data);
525: else
526: fprintf(pfp, "%s", cp->c_data);
527: }
528: if (i==1)
529: fprintf(pfp, "\t0");
530: fprintf(pfp, "\n};\n");
531: }
532:
533: struct optable *
534: oplookup(id)
535: register char *id;
536: {
537: register struct optable *opp;
538:
539: opp = &optable[0];
540: while (opp < &optable[sizeof(optable)/sizeof(optable[0])]) {
541: if (strncmp(id, opp->o_id, NCPS) == 0)
542: return (opp);
543: ++opp;
544: }
545: fatal("operator not defined");
546: }
547:
548: body()
549: {
550: int c;
551:
552: c = body1();
553: body2();
554: return (c);
555: }
556:
557: /*
558: * Parse body.
559: */
560: body1()
561: {
562: register b, c;
563: static char id[NCPS];
564: int iff;
565:
566: fprintf(mfp, "/* %4d */\n", boffs);
567: /* Read body and subsequent blank lines */
568: for (;;) {
569: c = getnb();
570: /* End of body reached */
571: if (c==EOF || c=='%' || (c>='A' && c<='Z'))
572: break;
573: if (c == ';')
574: continue; /* Eat them */
575: /* No conditional yet */
576: iff = 0;
577: /* Parse line */
578: do {
579: /* Eat intermediate spaces */
580: while (c==' ' || c=='\t')
581: c = get();
582: /* Catch trailing spaces */
583: if (c == '\n')
584: break;
585: /* Read bracketed macros */
586: if (c == '[') {
587: /* Until matching ] found */
588: do {
589: /* No more tab spacing */
590: while ((c = get()) == ' ')
591: ;
592: getid(c, id);
593: c = get();
594: b = maclookup(id);
595: /* Output most macros */
596: if (b != M_ICON && b != M_LCON) {
597: if (id[0] == 'Z')
598: mbyte(id);
599: else
600: mbar(id);
601: }
602: /* Output register name */
603: if (b == M_REGNO) {
604: while (c == ' ')
605: c = get();
606: getid(c, id);
607: mbyte(id);
608: c = get();
609: }
610: /* Output identifier */
611: if (b == M_GID) {
612: while (c == ' ')
613: c = get();
614: getid(c, id);
615: mnum(findcache(id, CGID));
616: c = get();
617: }
618: /* Note conditional macros */
619: if (b==M_IFR || b==M_IFV || b==M_IFE)
620: iff = 1;
621: /* Pack constants */
622: if (b == M_ICON || b == M_LCON)
623: c = getcon(b, c);
624: } while (c == ' ');
625: if (c != ']')
626: fatal("missing ']' in macro");
627: }
628: c = get();
629: } while (c!=EOF && c!='\n');
630: /* Terminate conditional */
631: if (iff != 0)
632: mbyte("M_ENDIF");
633: macv[nmac++] = m_newl;
634: if (nmac >= NMAC)
635: fatal("macro too big");
636: }
637: /* Terminate macro */
638: macv[nmac++] = m_end;
639: boffs += 1;
640: macv[nmac++] = m_newl;
641: return (c);
642: }
643:
644: maclookup(id)
645: register char *id;
646: {
647: register struct mtab *mtp;
648:
649: for (mtp = &mtab[0]; mtp < &mtab[sizeof(mtab)/sizeof(mtab[0])]; ++mtp)
650: if (strncmp(id, mtp->m_id, NCPS) == 0) {
651: return (mtp->m_byte);
652: }
653: return (-1);
654: }
655:
656: getcon(m, c)
657: int m;
658: register int c;
659: {
660: register long l;
661: register int b;
662: register char *p;
663: static char digita[] = "0123456789ABCDEF";
664: static char digitb[] = "0123456789abcdef";
665: static char nbuf[16];
666: extern char *index();
667:
668: while (c == ' ')
669: c = get();
670: l = 0;
671: b = 10;
672: if (c == '0') {
673: b = 8;
674: c = get();
675: if (c=='x' || c == 'X') {
676: b = 16;
677: c = get();
678: }
679: }
680: for (;;) {
681: if ((p = index(digita, c)) && (p-digita) < b)
682: c = p - digita;
683: else if ((p = index(digitb, c)) && (p-digitb) < b)
684: c = p - digitb;
685: else
686: break;
687: l = b*l + c;
688: c = get();
689: }
690: sprintf(nbuf, "0x%lx", l);
691: if (m == M_ICON) {
692: mbar("ICON");
693: mnum(findcache(nbuf, CICON));
694: } else {
695: strcat(nbuf, "L");
696: mbar("LCON");
697: mnum(findcache(nbuf, CLCON));
698: }
699: return (c);
700: }
701:
702: mbyte(id)
703: char *id;
704: {
705: macv[nmac++] = mlookup(id);
706: boffs += 1;
707: }
708:
709: HASH *
710: mlookup(id)
711: char *id;
712: {
713: register HASH *sp;
714: register char *p;
715: register int i;
716: unsigned h;
717:
718: p = id;
719: h = 0;
720: i = NCPS;
721: while (--i >= 0)
722: if (*p)
723: h += *p++;
724: sp = &hash[h%NHASH];
725: p = id;
726: i = NHASH;
727: while (--i >= 0) {
728: if (sp->s_name[0] == 0) {
729: strncpy(sp->s_name, p, NCPS);
730: return (sp);
731: }
732: if (strncmp(sp->s_name, p, NCPS) == 0)
733: return (sp);
734: if (++sp >= &hash[NHASH])
735: sp = &hash[0];
736: }
737: fatal("out of hash");
738: }
739:
740: mbar(id)
741: register char *id;
742: {
743: static char t[NCPS] = "M_";
744:
745: strncpy(t+2, id, NCPS-2);
746: mbyte(t);
747: }
748:
749: mnum(num)
750: int num;
751: {
752: static char t[] = "0x??";
753:
754: mknum(t, num);
755: mbyte(t);
756: }
757:
758: mknum(id, n)
759: register char *id;
760: register int n;
761: {
762: static char d[] = "0123456789ABCDEF";
763:
764: id[0] = '0';
765: id[1] = 'x';
766: id[3] = d[n&0xf];
767: n >>= 4;
768: id[2] = d[n&0xf];
769: id[4] = 0;
770: }
771:
772: /*
773: * Match body into reverse sorted tree,
774: * replace common ends with jumps,
775: * print body.
776: */
777: body2()
778: {
779: int sboffs; /* Saved byte size of macro */
780: int jto; /* Byte offset to jump to */
781: int jfrom; /* Byte offset to jump from */
782: int jnmac; /* The element which becomes M_JMP */
783: int noto; /* We're in the middle of a macro, don't jump */
784: register SORT **tpp;
785: register HASH *sp;
786: static char t1[] = "0x??";
787: static char t2[] = "0x??";
788: register int i;
789:
790: sboffs = boffs;
791: jto = -1;
792: tpp = &root;
793: i = nmac;
794: /* For each input macro element */
795: while (--i >= 0) {
796: /* Avoid gotos from within two byte macros */
797: noto = 0;
798: if (i > 0) {
799: sp = macv[i-1];
800: if (sp==m_gid || sp==m_icon || sp==m_lcon)
801: noto += 1;
802: }
803: /* Count down the byte offset */
804: if ((sp = macv[i]) != m_newl)
805: boffs -= 1;
806: /* Until match or new entry */
807: for (;;) {
808: /* New entry */
809: if (*tpp == NULL) {
810: if ((*tpp = malloc(sizeof(SORT))) == NULL)
811: fatal("out of trees");
812: (*tpp)->t_boffs = boffs;
813: (*tpp)->t_symb = sp;
814: (*tpp)->t_diff = NULL;
815: (*tpp)->t_same = NULL;
816: break;
817: }
818: /* Match */
819: if ((*tpp)->t_symb == sp) {
820: if (noto == 0) {
821: jto = (*tpp)->t_boffs;
822: jfrom = boffs;
823: jnmac = i;
824: }
825: break;
826: }
827: /* Search for match or empty */
828: tpp = &(*tpp)->t_same;
829: }
830: /* Advance to next element in macro */
831: tpp = &(*tpp)->t_diff;
832: }
833: /* Ignore any matches if nflag is set */
834: if (nflag)
835: jto = -1;
836: /* See if we found a jump */
837: if (jto >= 0) {
838: /* Make the offset strings for each form of jump */
839: if (jto < 256) {
840: mknum(t1, jto);
841: i = 2;
842: } else if ((jfrom-jto) < 256) {
843: mknum(t1, jfrom-jto);
844: i = 2;
845: } else {
846: mknum(t1, jto);
847: mknum(t2, jto>>8);
848: i = 3;
849: }
850: /* If we save space, make the jump */
851: if ((jfrom+i) < sboffs) {
852: nmac = jnmac;
853: if (nmac != 0 && macv[nmac-1] != m_newl)
854: macv[nmac++] = m_newl;
855: macv[nmac++] = m_jmp;
856: }
857: }
858: /* Print out the macro */
859: for (i = 0; --nmac > 0; i += 1)
860: if ((sp = macv[i]) == m_newl)
861: putc('\n', mfp);
862: else {
863: if (i==0 || macv[i-1] == m_newl)
864: putc('\t', mfp);
865: else
866: putc(' ', mfp);
867: fprintf(mfp, "%.8s,", sp->s_name);
868: boffs += 1;
869: }
870: /* The last entry is m_jmp or a m_newl */
871: if (macv[i] == m_jmp) {
872: if (jto < 256) {
873: fprintf(mfp, "\tM_JMP1, %s,\t\t", t1);
874: boffs += 2;
875: } else if ((jfrom-jto) < 256) {
876: fprintf(mfp, "\tM_JMPB, %s,\t\t", t1);
877: boffs += 2;
878: } else {
879: fprintf(mfp, "\tM_JMP2, %s, %s,\t", t1, t2);
880: boffs += 3;
881: }
882: /* Identify the destination */
883: fprintf(mfp, "/* %d */\n", jto);
884: } else
885: putc('\n', mfp);
886: bsave += sboffs - boffs;
887: }
888:
889: getnb()
890: {
891: register int c;
892:
893: while ((c=get())==' ' || c=='\t' || c=='\n')
894: ;
895: return (c);
896: }
897:
898: get()
899: {
900: register char *p1;
901: register char *p2;
902: register int c;
903: register int hitslash;
904: register int isdef;
905: register int i;
906:
907: if ((c=ungetc) >= 0) {
908: ungetc = -1;
909: return (c);
910: }
911: if (hiteof != 0)
912: return (EOF);
913: while (getnc == 0) {
914: p1 = &getbuf[0];
915: hitslash = 0;
916: while ((c=getc(ifp))!=EOF && c!='\n') {
917: if (hitslash == 0) {
918: if (c == '/')
919: hitslash = 1;
920: else
921: *p1++ = c;
922: }
923: }
924: if (c == EOF) {
925: hiteof = 1;
926: return (EOF);
927: }
928: *p1++ = '\n';
929: ++lineno;
930: if (getbuf[0] == '#') {
931: static char endif[] = "endif";
932: static char ifdef[] = "ifdef";
933: static char ifndef[] = "ifndef";
934:
935: p2 = &getbuf[1];
936: if (match(p2, endif)) {
937: if (tlevel != 0)
938: --tlevel;
939: else if (flevel != 0)
940: --flevel;
941: else
942: fatal(endif);
943: if ((tlevel+flevel) == 0)
944: fprintf(pfp, "\n/* #%s */", endif);
945: continue;
946: }
947: if (match(p2, ifdef) || match(p2, ifndef)) {
948: if (flevel != 0) {
949: ++flevel;
950: continue;
951: }
952: while ((c = *p2)!=' ' && c!='\t' && c!='\n')
953: ++p2;
954: while ((c = *p2)==' ' || c=='\t')
955: ++p2;
956: if (c == '\n')
957: fatal("if name");
958: p1 = p2;
959: while (*p2!=' ' && *p2!='\t' && *p2!='\n')
960: ++p2;
961: *p2 = 0;
962: isdef = 0;
963: for (i=0; i<ndef; ++i) {
964: if (strcmp(def[i], p1) == 0) {
965: isdef = 1;
966: break;
967: }
968: }
969: if (getbuf[3] == 'n') /* #ifndef */
970: isdef = !isdef;
971: if (isdef != 0)
972: ++tlevel;
973: else
974: ++flevel;
975: fprintf(pfp, "\n/* %s */", getbuf);
976: continue;
977: }
978: if (flevel == 0) {
979: p2 = &getbuf[0];
980: while (p2 < p1)
981: putc(*p2++, pfp);
982: }
983: continue;
984: }
985: if (flevel == 0) {
986: getnc = p1 - &getbuf[0];
987: getcp = &getbuf[0];
988: }
989: }
990: --getnc;
991: return (*getcp++);
992: }
993:
994: unget(c)
995: {
996: ungetc = c;
997: }
998:
999: getid(c, id)
1000: register c;
1001: char id[];
1002: {
1003: register char *p;
1004:
1005: if (!isalpha(c) && c != '_')
1006: fatal("missing identifier");
1007: p = id;
1008: do {
1009: if (p < &id[NCPS])
1010: *p++ = c;
1011: c = get();
1012: } while (isalnum(c));
1013: while (p < &id[NCPS])
1014: *p++ = 0;
1015: unget(c);
1016: }
1017:
1018: fatal(s)
1019: char *s;
1020: {
1021: fprintf(stderr, "%s: %d: %s\n", fname, lineno, s);
1022: exit(ABORT);
1023: }
1024:
1025: opindex()
1026: {
1027: register struct optable *opp;
1028:
1029: fprintf(pfp, "PATX patx[] = {\n");
1030: opp = &optable[0];
1031: while (opp < &optable[nel(optable)]) {
1032: fprintf(pfp, "\t");
1033: if (opp->o_seq == 0)
1034: fprintf(pfp, "NULL,\t0");
1035: else
1036: fprintf(pfp, "p%d,\t%d", opp->o_seq, opp->o_npat);
1037: if (opp != &optable[nel(optable)-1])
1038: putc(',', pfp);
1039: putc('\n', pfp);
1040: ++opp;
1041: }
1042: fprintf(pfp, "};\n");
1043: }
1044:
1045: match(p1, p2)
1046: register char *p1;
1047: register char *p2;
1048: {
1049: register int c;
1050:
1051: while ((c = *p2++) != 0) {
1052: if (*p1++ != c)
1053: return (0);
1054: }
1055: return (1);
1056: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.