![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpp.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 / lib / cpp|
Return to cpp.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / cpp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)cpp.c 1.6 7/1/83";
3: #endif lint
4:
5: #ifdef FLEXNAMES
6: #define NCPS 128
7: #else
8: #define NCPS 8
9: #endif
10:
11: # include "stdio.h"
12: # include "ctype.h"
13: /* C command
14: /* written by John F. Reiser
15: /* July/August 1978
16: */
17:
18: #define STATIC
19:
20: #define STDIN 0
21: #define STDOUT 1
22: #define STDERR 2
23: #define READ 0
24: #define WRITE 1
25: #define SALT '#'
26: #ifndef BUFSIZ
27: #define BUFSIZ 512
28: #endif
29:
30: char *pbeg,*pbuf,*pend;
31: char *outp,*inp;
32: char *newp;
33: char cinit;
34:
35: /* some code depends on whether characters are sign or zero extended */
36: #if '\377' < 0 /* this works on tahoe */
37: #define COFF 128
38: #else
39: #define COFF 0
40: #endif
41:
42: # if gcos
43: #define ALFSIZ 512 /* alphabet size */
44: # else
45: #define ALFSIZ 256 /* alphabet size */
46: # endif
47: char macbit[ALFSIZ+11];
48: char toktyp[ALFSIZ];
49: #define BLANK 1
50: #define IDENT 2
51: #define NUMBR 3
52:
53: /* a superimposed code is used to reduce the number of calls to the
54: /* symbol table lookup routine. (if the kth character of an identifier
55: /* is 'a' and there are no macro names whose kth character is 'a'
56: /* then the identifier cannot be a macro name, hence there is no need
57: /* to look in the symbol table.) 'scw1' enables the test based on
58: /* single characters and their position in the identifier. 'scw2'
59: /* enables the test based on adjacent pairs of characters and their
60: /* position in the identifier. scw1 typically costs 1 indexed fetch,
61: /* an AND, and a jump per character of identifier, until the identifier
62: /* is known as a non-macro name or until the end of the identifier.
63: /* scw1 is inexpensive. scw2 typically costs 4 indexed fetches,
64: /* an add, an AND, and a jump per character of identifier, but it is also
65: /* slightly more effective at reducing symbol table searches.
66: /* scw2 usually costs too much because the symbol table search is
67: /* usually short; but if symbol table search should become expensive,
68: /* the code is here.
69: /* using both scw1 and scw2 is of dubious value.
70: */
71: #define scw1 1
72: #define scw2 0
73:
74: #if scw2
75: char t21[ALFSIZ],t22[ALFSIZ],t23[ALFSIZ+NCPS];
76: #endif
77:
78: #if scw1
79: #define b0 1
80: #define b1 2
81: #define b2 4
82: #define b3 8
83: #define b4 16
84: #define b5 32
85: #define b6 64
86: #define b7 128
87: #endif
88:
89: #define IB 1
90: #define SB 2
91: #define NB 4
92: #define CB 8
93: #define QB 16
94: #define WB 32
95: char fastab[ALFSIZ];
96: char slotab[ALFSIZ];
97: char *ptrtab;
98: #define isslo (ptrtab==(slotab+COFF))
99: #define isid(a) ((fastab+COFF)[a]&IB)
100: #define isspc(a) (ptrtab[a]&SB)
101: #define isnum(a) ((fastab+COFF)[a]&NB)
102: #define iscom(a) ((fastab+COFF)[a]&CB)
103: #define isquo(a) ((fastab+COFF)[a]&QB)
104: #define iswarn(a) ((fastab+COFF)[a]&WB)
105:
106: #define eob(a) ((a)>=pend)
107: #define bob(a) (pbeg>=(a))
108:
109: # define cputc(a,b) if(!flslvl) putc(a,b)
110:
111: char buffer[NCPS+BUFSIZ+BUFSIZ+NCPS];
112:
113: # define SBSIZE 120000 /* std = 12000, wnj aug 1979 */
114: char sbf[SBSIZE];
115: char *savch = sbf;
116:
117: # define DROP 0xFE /* special character not legal ASCII or EBCDIC */
118: # define WARN DROP
119: # define SAME 0
120: # define MAXINC 10
121: # define MAXFRE 14 /* max buffers of macro pushback */
122: # define MAXFRM 31 /* max number of formals/actuals to a macro */
123:
124: static char warnc = WARN;
125:
126: int mactop,fretop;
127: char *instack[MAXFRE],*bufstack[MAXFRE],*endbuf[MAXFRE];
128:
129: int plvl; /* parenthesis level during scan for macro actuals */
130: int maclin; /* line number of macro call requiring actuals */
131: char *macfil; /* file name of macro call requiring actuals */
132: char *macnam; /* name of macro requiring actuals */
133: int maclvl; /* # calls since last decrease in nesting level */
134: char *macforw; /* pointer which must be exceeded to decrease nesting level */
135: int macdam; /* offset to macforw due to buffer shifting */
136:
137: #if tgp
138: int tgpscan; /* flag for dump(); */
139: #endif
140:
141: STATIC int inctop[MAXINC];
142: STATIC char *fnames[MAXINC];
143: STATIC char *dirnams[MAXINC]; /* actual directory of #include files */
144: STATIC int fins[MAXINC];
145: STATIC int lineno[MAXINC];
146:
147: STATIC char *dirs[10]; /* -I and <> directories */
148: char *strdex(), *copy(), *subst(), *trmdir();
149: struct symtab *stsym();
150: STATIC int fin = STDIN;
151: STATIC FILE *fout = stdout;
152: STATIC int nd = 1;
153: STATIC int pflag; /* don't put out lines "# 12 foo.c" */
154: int passcom; /* don't delete comments */
155: STATIC int rflag; /* allow macro recursion */
156: STATIC int ifno;
157: # define NPREDEF 20
158: STATIC char *prespc[NPREDEF];
159: STATIC char **predef = prespc;
160: STATIC char *punspc[NPREDEF];
161: STATIC char **prund = punspc;
162: STATIC int exfail;
163: struct symtab {
164: char *name;
165: char *value;
166: } *lastsym, *lookup(), *slookup();
167:
168: # if gcos
169: #include <setjmp.h>
170: static jmp_buf env;
171: # define main mainpp
172: # undef exit
173: # define exit(S) longjmp(env, 1)
174: # define open(S,D) fileno(fopen(S, "r"))
175: # define close(F) fclose(_f[F])
176: extern FILE *_f[];
177: # define symsiz 500
178: # else
179: # define symsiz 2000 /* std = 500, wnj aug 1979 */
180: # endif
181: STATIC struct symtab stab[symsiz];
182:
183: STATIC struct symtab *defloc;
184: STATIC struct symtab *udfloc;
185: STATIC struct symtab *incloc;
186: STATIC struct symtab *ifloc;
187: STATIC struct symtab *elsloc;
188: STATIC struct symtab *eifloc;
189: STATIC struct symtab *ifdloc;
190: STATIC struct symtab *ifnloc;
191: STATIC struct symtab *ysysloc;
192: STATIC struct symtab *varloc;
193: STATIC struct symtab *lneloc;
194: STATIC struct symtab *ulnloc;
195: STATIC struct symtab *uflloc;
196: STATIC int trulvl;
197: STATIC int flslvl;
198:
199: sayline() {
200: if (pflag==0) fprintf(fout,"# %d \"%s\"\n", lineno[ifno], fnames[ifno]);
201: }
202:
203: /* data structure guide
204: /*
205: /* most of the scanning takes place in the buffer:
206: /*
207: /* (low address) (high address)
208: /* pbeg pbuf pend
209: /* | <-- BUFSIZ chars --> | <-- BUFSIZ chars --> |
210: /* _______________________________________________________________________
211: /* |_______________________________________________________________________|
212: /* | | |
213: /* |<-- waiting -->| |<-- waiting -->
214: /* | to be |<-- current -->| to be
215: /* | written | token | scanned
216: /* | | |
217: /* outp inp p
218: /*
219: /* *outp first char not yet written to output file
220: /* *inp first char of current token
221: /* *p first char not yet scanned
222: /*
223: /* macro expansion: write from *outp to *inp (chars waiting to be written),
224: /* ignore from *inp to *p (chars of the macro call), place generated
225: /* characters in front of *p (in reverse order), update pointers,
226: /* resume scanning.
227: /*
228: /* symbol table pointers point to just beyond the end of macro definitions;
229: /* the first preceding character is the number of formal parameters.
230: /* the appearance of a formal in the body of a definition is marked by
231: /* 2 chars: the char WARN, and a char containing the parameter number.
232: /* the first char of a definition is preceded by a zero character.
233: /*
234: /* when macro expansion attempts to back up over the beginning of the
235: /* buffer, some characters preceding *pend are saved in a side buffer,
236: /* the address of the side buffer is put on 'instack', and the rest
237: /* of the main buffer is moved to the right. the end of the saved buffer
238: /* is kept in 'endbuf' since there may be nulls in the saved buffer.
239: /*
240: /* similar action is taken when an 'include' statement is processed,
241: /* except that the main buffer must be completely emptied. the array
242: /* element 'inctop[ifno]' records the last side buffer saved when
243: /* file 'ifno' was included. these buffers remain dormant while
244: /* the file is being read, and are reactivated at end-of-file.
245: /*
246: /* instack[0 : mactop] holds the addresses of all pending side buffers.
247: /* instack[inctop[ifno]+1 : mactop-1] holds the addresses of the side
248: /* buffers which are "live"; the side buffers instack[0 : inctop[ifno]]
249: /* are dormant, waiting for end-of-file on the current file.
250: /*
251: /* space for side buffers is obtained from 'savch' and is never returned.
252: /* bufstack[0:fretop-1] holds addresses of side buffers which
253: /* are available for use.
254: */
255:
256: dump() {
257: /* write part of buffer which lies between outp and inp .
258: /* this should be a direct call to 'write', but the system slows to a crawl
259: /* if it has to do an unaligned copy. thus we buffer. this silly loop
260: /* is 15% of the total time, thus even the 'putc' macro is too slow.
261: */
262: register char *p1,*p2; register FILE *f;
263: if ((p1=outp)==inp || flslvl!=0) return;
264: #if tgp
265: #define MAXOUT 80
266: if (!tgpscan) {/* scan again to insure <= MAXOUT chars between linefeeds */
267: register char c,*pblank; char savc,stopc,brk;
268: tgpscan=1; brk=stopc=pblank=0; p2=inp; savc= *p2; *p2='\0';
269: while (c= *p1++) {
270: if (c=='\\') c= *p1++;
271: if (stopc==c) stopc=0;
272: else if (c=='"' || c=='\'') stopc=c;
273: if (p1-outp>MAXOUT && pblank!=0) {
274: *pblank++='\n'; inp=pblank; dump(); brk=1; pblank=0;
275: }
276: if (c==' ' && stopc==0) pblank=p1-1;
277: }
278: if (brk) sayline();
279: *p2=savc; inp=p2; p1=outp; tgpscan=0;
280: }
281: #endif
282: f=fout;
283: # if gcos
284: /* filter out "$ program c" card if first line of input */
285: /* gmatch is a simple pattern matcher in the GCOS Standard Library */
286: { static int gmfirst = 0;
287: if (!gmfirst) {
288: ++gmfirst;
289: if (gmatch(p1, "^$*program[ \t]*c*"))
290: p1 = strdex(p1, '\n');
291: }
292: }
293: # endif
294: while (p1<inp) putc(*p1++,f);
295: outp=p1;
296: }
297:
298: char *
299: refill(p) register char *p; {
300: /* dump buffer. save chars from inp to p. read into buffer at pbuf,
301: /* contiguous with p. update pointers, return new p.
302: */
303: register char *np,*op; register int ninbuf;
304: dump(); np=pbuf-(p-inp); op=inp;
305: if (bob(np+1)) {pperror("token too long"); np=pbeg; p=inp+BUFSIZ;}
306: macdam += np-inp; outp=inp=np;
307: while (op<p) *np++= *op++;
308: p=np;
309: for (;;) {
310: if (mactop>inctop[ifno]) {/* retrieve hunk of pushed-back macro text */
311: op=instack[--mactop]; np=pbuf;
312: do {while (*np++= *op++);} while (op<endbuf[mactop]); pend=np-1;
313: /* make buffer space avail for 'include' processing */
314: if (fretop<MAXFRE) bufstack[fretop++]=instack[mactop];
315: return(p);
316: } else {/* get more text from file(s) */
317: maclvl=0;
318: if (0<(ninbuf=read(fin,pbuf,BUFSIZ))) {
319: pend=pbuf+ninbuf; *pend='\0';
320: return(p);
321: }
322: /* end of #include file */
323: if (ifno==0) {/* end of input */
324: if (plvl!=0) {
325: int n=plvl,tlin=lineno[ifno]; char *tfil=fnames[ifno];
326: lineno[ifno]=maclin; fnames[ifno]=macfil;
327: pperror("%s: unterminated macro call",macnam);
328: lineno[ifno]=tlin; fnames[ifno]=tfil;
329: np=p; *np++='\n'; /* shut off unterminated quoted string */
330: while (--n>=0) *np++=')'; /* supply missing parens */
331: pend=np; *np='\0'; if (plvl<0) plvl=0;
332: return(p);
333: }
334: if (trulvl || flslvl)
335: pperror("missing endif");
336: inp=p; dump(); exit(exfail);
337: }
338: close(fin); fin=fins[--ifno]; dirs[0]=dirnams[ifno]; sayline();
339: }
340: }
341: }
342:
343: #define BEG 0
344: #define LF 1
345:
346: char *
347: cotoken(p) register char *p; {
348: register int c,i; char quoc;
349: static int state = BEG;
350:
351: if (state!=BEG) goto prevlf;
352: for (;;) {
353: again:
354: while (!isspc(*p++));
355: switch (*(inp=p-1)) {
356: case 0: {
357: if (eob(--p)) {p=refill(p); goto again;}
358: else ++p; /* ignore null byte */
359: } break;
360: case '|': case '&': for (;;) {/* sloscan only */
361: if (*p++== *inp) break;
362: if (eob(--p)) p=refill(p);
363: else break;
364: } break;
365: case '=': case '!': for (;;) {/* sloscan only */
366: if (*p++=='=') break;
367: if (eob(--p)) p=refill(p);
368: else break;
369: } break;
370: case '<': case '>': for (;;) {/* sloscan only */
371: if (*p++=='=' || p[-2]==p[-1]) break;
372: if (eob(--p)) p=refill(p);
373: else break;
374: } break;
375: case '\\': for (;;) {
376: if (*p++=='\n') {++lineno[ifno]; break;}
377: if (eob(--p)) p=refill(p);
378: else {++p; break;}
379: } break;
380: case '/': for (;;) {
381: if (*p++=='*') {/* comment */
382: if (!passcom) {inp=p-2; dump(); ++flslvl;}
383: for (;;) {
384: while (!iscom(*p++));
385: if (p[-1]=='*') for (;;) {
386: if (*p++=='/') goto endcom;
387: if (eob(--p)) {
388: if (!passcom) {inp=p; p=refill(p);}
389: else if ((p-inp)>=BUFSIZ) {/* split long comment */
390: inp=p; p=refill(p); /* last char written is '*' */
391: cputc('/',fout); /* terminate first part */
392: /* and fake start of 2nd */
393: outp=inp=p-=3; *p++='/'; *p++='*'; *p++='*';
394: } else p=refill(p);
395: } else break;
396: } else if (p[-1]=='\n') {
397: ++lineno[ifno]; if (!passcom) putc('\n',fout);
398: } else if (eob(--p)) {
399: if (!passcom) {inp=p; p=refill(p);}
400: else if ((p-inp)>=BUFSIZ) {/* split long comment */
401: inp=p; p=refill(p);
402: cputc('*',fout); cputc('/',fout);
403: outp=inp=p-=2; *p++='/'; *p++='*';
404: } else p=refill(p);
405: } else ++p; /* ignore null byte */
406: }
407: endcom:
408: if (!passcom) {outp=inp=p; --flslvl; goto again;}
409: break;
410: }
411: if (eob(--p)) p=refill(p);
412: else break;
413: } break;
414: # if gcos
415: case '`':
416: # endif
417: case '"': case '\'': {
418: quoc=p[-1];
419: for (;;) {
420: while (!isquo(*p++));
421: if (p[-1]==quoc) break;
422: if (p[-1]=='\n') {--p; break;} /* bare \n terminates quotation */
423: if (p[-1]=='\\') for (;;) {
424: if (*p++=='\n') {++lineno[ifno]; break;} /* escaped \n ignored */
425: if (eob(--p)) p=refill(p);
426: else {++p; break;}
427: } else if (eob(--p)) p=refill(p);
428: else ++p; /* it was a different quote character */
429: }
430: } break;
431: case '\n': {
432: ++lineno[ifno]; if (isslo) {state=LF; return(p);}
433: prevlf:
434: state=BEG;
435: for (;;) {
436: if (*p++=='#') return(p);
437: if (eob(inp= --p)) p=refill(p);
438: else goto again;
439: }
440: } break;
441: case '0': case '1': case '2': case '3': case '4':
442: case '5': case '6': case '7': case '8': case '9':
443: for (;;) {
444: while (isnum(*p++));
445: if (eob(--p)) p=refill(p);
446: else break;
447: } break;
448: case 'A': case 'B': case 'C': case 'D': case 'E':
449: case 'F': case 'G': case 'H': case 'I': case 'J':
450: case 'K': case 'L': case 'M': case 'N': case 'O':
451: case 'P': case 'Q': case 'R': case 'S': case 'T':
452: case 'U': case 'V': case 'W': case 'X': case 'Y':
453: case 'Z': case '_':
454: case 'a': case 'b': case 'c': case 'd': case 'e':
455: case 'f': case 'g': case 'h': case 'i': case 'j':
456: case 'k': case 'l': case 'm': case 'n': case 'o':
457: case 'p': case 'q': case 'r': case 's': case 't':
458: case 'u': case 'v': case 'w': case 'x': case 'y':
459: case 'z':
460: #if scw1
461: #define tmac1(c,bit) if (!xmac1(c,bit,&)) goto nomac
462: #define xmac1(c,bit,op) ((macbit+COFF)[c] op (bit))
463: #else
464: #define tmac1(c,bit)
465: #define xmac1(c,bit,op)
466: #endif
467:
468: #if scw2
469: #define tmac2(c0,c1,cpos) if (!xmac2(c0,c1,cpos,&)) goto nomac
470: #define xmac2(c0,c1,cpos,op)\
471: ((macbit+COFF)[(t21+COFF)[c0]+(t22+COFF)[c1]] op (t23+COFF+cpos)[c0])
472: #else
473: #define tmac2(c0,c1,cpos)
474: #define xmac2(c0,c1,cpos,op)
475: #endif
476:
477: if (flslvl) goto nomac;
478: for (;;) {
479: c= p[-1]; tmac1(c,b0);
480: i= *p++; if (!isid(i)) goto endid; tmac1(i,b1); tmac2(c,i,0);
481: c= *p++; if (!isid(c)) goto endid; tmac1(c,b2); tmac2(i,c,1);
482: i= *p++; if (!isid(i)) goto endid; tmac1(i,b3); tmac2(c,i,2);
483: c= *p++; if (!isid(c)) goto endid; tmac1(c,b4); tmac2(i,c,3);
484: i= *p++; if (!isid(i)) goto endid; tmac1(i,b5); tmac2(c,i,4);
485: c= *p++; if (!isid(c)) goto endid; tmac1(c,b6); tmac2(i,c,5);
486: i= *p++; if (!isid(i)) goto endid; tmac1(i,b7); tmac2(c,i,6);
487: tmac2(i,0,7);
488: while (isid(*p++));
489: if (eob(--p)) {refill(p); p=inp+1; continue;}
490: goto lokid;
491: endid:
492: if (eob(--p)) {refill(p); p=inp+1; continue;}
493: tmac2(p[-1],0,-1+(p-inp));
494: lokid:
495: slookup(inp,p,0); if (newp) {p=newp; goto again;}
496: else break;
497: nomac:
498: while (isid(*p++));
499: if (eob(--p)) {p=refill(p); goto nomac;}
500: else break;
501: } break;
502: } /* end of switch */
503:
504: if (isslo) return(p);
505: } /* end of infinite loop */
506: }
507:
508: char *
509: skipbl(p) register char *p; {/* get next non-blank token */
510: do {outp=inp=p; p=cotoken(p);} while ((toktyp+COFF)[*inp]==BLANK);
511: return(p);
512: }
513:
514: char *
515: unfill(p) register char *p; {
516: /* take <= BUFSIZ chars from right end of buffer and put them on instack .
517: /* slide rest of buffer to the right, update pointers, return new p.
518: */
519: register char *np,*op; register int d;
520: if (mactop>=MAXFRE) {
521: pperror("%s: too much pushback",macnam);
522: p=inp=pend; dump(); /* begin flushing pushback */
523: while (mactop>inctop[ifno]) {p=refill(p); p=inp=pend; dump();}
524: }
525: if (fretop>0) np=bufstack[--fretop];
526: else {
527: np=savch; savch+=BUFSIZ;
528: if (savch>=sbf+SBSIZE) {pperror("no space"); exit(exfail);}
529: *savch++='\0';
530: }
531: instack[mactop]=np; op=pend-BUFSIZ; if (op<p) op=p;
532: for (;;) {while (*np++= *op++); if (eob(op)) break;} /* out with old */
533: endbuf[mactop++]=np; /* mark end of saved text */
534: np=pbuf+BUFSIZ; op=pend-BUFSIZ; pend=np; if (op<p) op=p;
535: while (outp<op) *--np= *--op; /* slide over new */
536: if (bob(np)) pperror("token too long");
537: d=np-outp; outp+=d; inp+=d; macdam+=d; return(p+d);
538: }
539:
540: char *
541: doincl(p) register char *p; {
542: int filok,inctype;
543: register char *cp; char **dirp,*nfil; char filname[BUFSIZ];
544:
545: p=skipbl(p); cp=filname;
546: if (*inp++=='<') {/* special <> syntax */
547: inctype=1;
548: ++flslvl; /* prevent macro expansion */
549: for (;;) {
550: outp=inp=p; p=cotoken(p);
551: if (*inp=='\n') {--p; *cp='\0'; break;}
552: if (*inp=='>') { *cp='\0'; break;}
553: # ifdef gimpel
554: if (*inp=='.' && !intss()) *inp='#';
555: # endif
556: while (inp<p) *cp++= *inp++;
557: }
558: --flslvl; /* reenable macro expansion */
559: } else if (inp[-1]=='"') {/* regular "" syntax */
560: inctype=0;
561: # ifdef gimpel
562: while (inp<p) {if (*inp=='.' && !intss()) *inp='#'; *cp++= *inp++;}
563: # else
564: while (inp<p) *cp++= *inp++;
565: # endif
566: if (*--cp=='"') *cp='\0';
567: } else {pperror("bad include syntax",0); inctype=2;}
568: /* flush current file to \n , then write \n */
569: ++flslvl; do {outp=inp=p; p=cotoken(p);} while (*inp!='\n'); --flslvl;
570: inp=p; dump(); if (inctype==2) return(p);
571: /* look for included file */
572: if (ifno+1 >=MAXINC) {
573: pperror("Unreasonable include nesting",0); return(p);
574: }
575: if((nfil=savch)>sbf+SBSIZE-BUFSIZ) {pperror("no space"); exit(exfail);}
576: filok=0;
577: for (dirp=dirs+inctype; *dirp; ++dirp) {
578: if (
579: # if gcos
580: strdex(filname, '/')
581: # else
582: filname[0]=='/'
583: # endif
584: || **dirp=='\0') strcpy(nfil,filname);
585: else {
586: strcpy(nfil,*dirp);
587: # if unix || gcos
588: strcat(nfil,"/");
589: # endif
590: #ifdef ibm
591: #ifndef gimpel
592: strcat(nfil,".");
593: #endif
594: #endif
595: strcat(nfil,filname);
596: }
597: if (0<(fins[ifno+1]=open(nfil,READ))) {
598: filok=1; fin=fins[++ifno]; break;
599: }
600: }
601: if (filok==0) pperror("Can't find include file %s",filname);
602: else {
603: lineno[ifno]=1; fnames[ifno]=cp=nfil; while (*cp++); savch=cp;
604: dirnams[ifno]=dirs[0]=trmdir(copy(nfil));
605: sayline();
606: /* save current contents of buffer */
607: while (!eob(p)) p=unfill(p);
608: inctop[ifno]=mactop;
609: }
610: return(p);
611: }
612:
613: equfrm(a,p1,p2) register char *a,*p1,*p2; {
614: register char c; int flag;
615: c= *p2; *p2='\0';
616: flag=strcmp(a,p1); *p2=c; return(flag==SAME);
617: }
618:
619: char *
620: dodef(p) char *p; {/* process '#define' */
621: register char *pin,*psav,*cf;
622: char **pf,**qf; int b,c,params; struct symtab *np;
623: char *oldval,*oldsavch;
624: char *formal[MAXFRM]; /* formal[n] is name of nth formal */
625: char formtxt[BUFSIZ]; /* space for formal names */
626:
627: if (savch>sbf+SBSIZE-BUFSIZ) {pperror("too much defining"); return(p);}
628: oldsavch=savch; /* to reclaim space if redefinition */
629: ++flslvl; /* prevent macro expansion during 'define' */
630: p=skipbl(p); pin=inp;
631: if ((toktyp+COFF)[*pin]!=IDENT) {
632: ppwarn("illegal macro name"); while (*inp!='\n') p=skipbl(p); return(p);
633: }
634: np=slookup(pin,p,1);
635: if (oldval=np->value) savch=oldsavch; /* was previously defined */
636: b=1; cf=pin;
637: while (cf<p) {/* update macbit */
638: c= *cf++; xmac1(c,b,|=); b=(b+b)&0xFF;
639: if (cf!=p) xmac2(c,*cf,-1+(cf-pin),|=);
640: else xmac2(c,0,-1+(cf-pin),|=);
641: }
642: params=0; outp=inp=p; p=cotoken(p); pin=inp;
643: if (*pin=='(') {/* with parameters; identify the formals */
644: cf=formtxt; pf=formal;
645: for (;;) {
646: p=skipbl(p); pin=inp;
647: if (*pin=='\n') {
648: --lineno[ifno]; --p; pperror("%s: missing )",np->name); break;
649: }
650: if (*pin==')') break;
651: if (*pin==',') continue;
652: if ((toktyp+COFF)[*pin]!=IDENT) {
653: c= *p; *p='\0'; pperror("bad formal: %s",pin); *p=c;
654: } else if (pf>= &formal[MAXFRM]) {
655: c= *p; *p='\0'; pperror("too many formals: %s",pin); *p=c;
656: } else {
657: *pf++=cf; while (pin<p) *cf++= *pin++; *cf++='\0'; ++params;
658: }
659: }
660: if (params==0) --params; /* #define foo() ... */
661: } else if (*pin=='\n') {--lineno[ifno]; --p;}
662: /* remember beginning of macro body, so that we can
663: /* warn if a redefinition is different from old value.
664: */
665: oldsavch=psav=savch;
666: for (;;) {/* accumulate definition until linefeed */
667: outp=inp=p; p=cotoken(p); pin=inp;
668: if (*pin=='\\' && pin[1]=='\n') {putc('\n',fout); continue;} /* ignore escaped lf */
669: if (*pin=='\n') break;
670: if (params) {/* mark the appearance of formals in the definiton */
671: if ((toktyp+COFF)[*pin]==IDENT) {
672: for (qf=pf; --qf>=formal; ) {
673: if (equfrm(*qf,pin,p)) {
674: *psav++=qf-formal+1; *psav++=WARN; pin=p; break;
675: }
676: }
677: } else if (*pin=='"' || *pin=='\''
678: # if gcos
679: || *pin=='`'
680: # endif
681: ) {/* inside quotation marks, too */
682: char quoc= *pin;
683: for (*psav++= *pin++; pin<p && *pin!=quoc; ) {
684: while (pin<p && !isid(*pin)) *psav++= *pin++;
685: cf=pin; while (cf<p && isid(*cf)) ++cf;
686: for (qf=pf; --qf>=formal; ) {
687: if (equfrm(*qf,pin,cf)) {
688: *psav++=qf-formal+1; *psav++=WARN; pin=cf; break;
689: }
690: }
691: while (pin<cf) *psav++= *pin++;
692: }
693: }
694: }
695: while (pin<p) *psav++= *pin++;
696: }
697: *psav++=params; *psav++='\0';
698: if ((cf=oldval)!=NULL) {/* redefinition */
699: --cf; /* skip no. of params, which may be zero */
700: while (*--cf); /* go back to the beginning */
701: if (0!=strcmp(++cf,oldsavch)) {/* redefinition different from old */
702: --lineno[ifno]; ppwarn("%s redefined",np->name); ++lineno[ifno];
703: np->value=psav-1;
704: } else psav=oldsavch; /* identical redef.; reclaim space */
705: } else np->value=psav-1;
706: --flslvl; inp=pin; savch=psav; return(p);
707: }
708:
709: #define fasscan() ptrtab=fastab+COFF
710: #define sloscan() ptrtab=slotab+COFF
711:
712: char *
713: control(p) register char *p; {/* find and handle preprocessor control lines */
714: register struct symtab *np;
715: for (;;) {
716: fasscan(); p=cotoken(p); if (*inp=='\n') ++inp; dump();
717: sloscan(); p=skipbl(p);
718: *--inp=SALT; outp=inp; ++flslvl; np=slookup(inp,p,0); --flslvl;
719: if (np==defloc) {/* define */
720: if (flslvl==0) {p=dodef(p); continue;}
721: } else if (np==incloc) {/* include */
722: if (flslvl==0) {p=doincl(p); continue;}
723: } else if (np==ifnloc) {/* ifndef */
724: ++flslvl; p=skipbl(p); np=slookup(inp,p,0); --flslvl;
725: if (flslvl==0 && np->value==0) ++trulvl;
726: else ++flslvl;
727: } else if (np==ifdloc) {/* ifdef */
728: ++flslvl; p=skipbl(p); np=slookup(inp,p,0); --flslvl;
729: if (flslvl==0 && np->value!=0) ++trulvl;
730: else ++flslvl;
731: } else if (np==eifloc) {/* endif */
732: if (flslvl) {if (--flslvl==0) sayline();}
733: else if (trulvl) --trulvl;
734: else pperror("If-less endif",0);
735: } else if (np==elsloc) {/* else */
736: if (flslvl) {
737: if (--flslvl!=0) ++flslvl;
738: else {++trulvl; sayline();}
739: }
740: else if (trulvl) {++flslvl; --trulvl;}
741: else pperror("If-less else",0);
742: } else if (np==udfloc) {/* undefine */
743: if (flslvl==0) {
744: ++flslvl; p=skipbl(p); slookup(inp,p,DROP); --flslvl;
745: }
746: } else if (np==ifloc) {/* if */
747: #if tgp
748: pperror(" IF not implemented, true assumed", 0);
749: if (flslvl==0) ++trulvl; else ++flslvl;
750: #else
751: newp=p;
752: if (flslvl==0 && yyparse()) ++trulvl; else ++flslvl;
753: p=newp;
754: #endif
755: } else if (np==lneloc) {/* line */
756: if (flslvl==0 && pflag==0) {
757: char *cp, *cp2, *savestring();
758: outp=inp=p; *--outp='#'; while (*inp!='\n') p=cotoken(p);
759: cp = outp + 1;
760: while (isspace(*cp) && cp < inp)
761: cp++;
762: while (isdigit(*cp) && cp < inp)
763: cp++;
764: while (*cp != '"' && cp < inp)
765: cp++;
766: if (cp < inp) {
767: cp++;
768: cp2 = cp;
769: while (*cp2 != '"' && cp2 < inp)
770: cp2++;
771: fnames[ifno] = savestring(cp, cp2);
772: }
773: continue;
774: }
775: } else if (*++inp=='\n') outp=inp; /* allows blank line after # */
776: else pperror("undefined control",0);
777: /* flush to lf */
778: ++flslvl; while (*inp!='\n') {outp=inp=p; p=cotoken(p);} --flslvl;
779: }
780: }
781:
782: char *
783: savestring(start, finish)
784: register char *start, *finish;
785: {
786: char *retbuf;
787: register char *cp;
788:
789: retbuf = (char *) calloc(finish - start + 1, sizeof (char));
790: cp = retbuf;
791: while (start < finish)
792: *cp++ = *start++;
793: *cp = 0;
794: return(retbuf);
795: }
796:
797: struct symtab *
798: stsym(s) register char *s; {
799: char buf[BUFSIZ]; register char *p;
800:
801: /* make definition look exactly like end of #define line */
802: /* copy to avoid running off end of world when param list is at end */
803: p=buf; while (*p++= *s++);
804: p=buf; while (isid(*p++)); /* skip first identifier */
805: if (*--p=='=') {*p++=' '; while (*p++);}
806: else {s=" 1"; while (*p++= *s++);}
807: pend=p; *--p='\n';
808: sloscan(); dodef(buf); return(lastsym);
809: }
810:
811: struct symtab *
812: ppsym(s) char *s; {/* kluge */
813: register struct symtab *sp;
814: cinit=SALT; *savch++=SALT; sp=stsym(s); --sp->name; cinit=0; return(sp);
815: }
816:
817: /* VARARGS1 */
818: pperror(s,x,y) char *s; {
819: if (fnames[ifno][0]) fprintf(stderr,
820: # if gcos
821: "*%c* \"%s\", line ", exfail >= 0 ? 'F' : 'W',
822: # else
823: "%s: ",
824: # endif
825: fnames[ifno]);
826: fprintf(stderr, "%d: ",lineno[ifno]);
827: fprintf(stderr, s, x, y);
828: fprintf(stderr,"\n");
829: ++exfail;
830: }
831:
832: yyerror(s,a,b) char *s; {
833: pperror(s,a,b);
834: }
835:
836: ppwarn(s,x) char *s; {
837: int fail = exfail;
838: exfail = -1;
839: pperror(s,x);
840: exfail = fail;
841: }
842:
843: struct symtab *
844: lookup(namep, enterf)
845: char *namep;
846: {
847: register char *np, *snp;
848: register int c, i; int around;
849: register struct symtab *sp;
850:
851: /* namep had better not be too long (currently, <=NCPS chars) */
852: np=namep; around=0; i=cinit;
853: while (c= *np++) i += i+c; c=i; /* c=i for register usage on pdp11 */
854: c %= symsiz; if (c<0) c += symsiz;
855: sp = &stab[c];
856: while (snp=sp->name) {
857: np = namep;
858: while (*snp++ == *np) if (*np++ == '\0') {
859: if (enterf==DROP) {sp->name[0]= DROP; sp->value=0;}
860: return(lastsym=sp);
861: }
862: if (--sp < &stab[0])
863: if (around) {pperror("too many defines", 0); exit(exfail);}
864: else {++around; sp = &stab[symsiz-1];}
865: }
866: if (enterf==1) sp->name=namep;
867: return(lastsym=sp);
868: }
869:
870: struct symtab *
871: slookup(p1,p2,enterf) register char *p1,*p2; int enterf;{
872: register char *p3; char c2,c3; struct symtab *np;
873: c2= *p2; *p2='\0'; /* mark end of token */
874: if ((p2-p1)>NCPS) p3=p1+NCPS; else p3=p2;
875: c3= *p3; *p3='\0'; /* truncate to NCPS chars or less */
876: if (enterf==1) p1=copy(p1);
877: np=lookup(p1,enterf); *p3=c3; *p2=c2;
878: if (np->value!=0 && flslvl==0) newp=subst(p2,np);
879: else newp=0;
880: return(np);
881: }
882:
883: char *
884: subst(p,sp) register char *p; struct symtab *sp; {
885: static char match[]="%s: argument mismatch";
886: register char *ca,*vp; int params;
887: char *actual[MAXFRM]; /* actual[n] is text of nth actual */
888: char actused[MAXFRM]; /* for newline processing in actuals */
889: char acttxt[BUFSIZ]; /* space for actuals */
890: int nlines = 0;
891:
892: if (0==(vp=sp->value)) return(p);
893: if ((p-macforw)<=macdam) {
894: if (++maclvl>symsiz && !rflag) {
895: pperror("%s: macro recursion",sp->name); return(p);
896: }
897: } else maclvl=0; /* level decreased */
898: macforw=p; macdam=0; /* new target for decrease in level */
899: macnam=sp->name;
900: dump();
901: if (sp==ulnloc) {
902: vp=acttxt; *vp++='\0';
903: sprintf(vp,"%d",lineno[ifno]); while (*vp++);
904: } else if (sp==uflloc) {
905: vp=acttxt; *vp++='\0';
906: sprintf(vp,"\"%s\"",fnames[ifno]); while (*vp++);
907: }
908: if (0!=(params= *--vp&0xFF)) {/* definition calls for params */
909: register char **pa;
910: ca=acttxt; pa=actual;
911: if (params==0xFF) params=1; /* #define foo() ... */
912: sloscan(); ++flslvl; /* no expansion during search for actuals */
913: plvl= -1;
914: do p=skipbl(p); while (*inp=='\n'); /* skip \n too */
915: if (*inp=='(') {
916: maclin=lineno[ifno]; macfil=fnames[ifno];
917: for (plvl=1; plvl!=0; ) {
918: *ca++='\0';
919: for (;;) {
920: outp=inp=p; p=cotoken(p);
921: if (*inp=='(') ++plvl;
922: if (*inp==')' && --plvl==0) {--params; break;}
923: if (plvl==1 && *inp==',') {--params; break;}
924: while (inp<p) *ca++= *inp++;
925: if (ca> &acttxt[BUFSIZ])
926: pperror("%s: actuals too long",sp->name);
927: }
928: if (pa>= &actual[MAXFRM]) ppwarn(match,sp->name);
929: else { actused[pa-actual]=0; *pa++=ca; }
930: }
931: nlines = lineno[ifno] - maclin;
932: lineno[ifno] = maclin; /* don't count newlines here */
933: }
934: if (params!=0) ppwarn(match,sp->name);
935: while (--params>=0) *pa++=""+1; /* null string for missing actuals */
936: --flslvl; fasscan();
937: }
938: for (;;) {/* push definition onto front of input stack */
939: while (!iswarn(*--vp)) {
940: if (bob(p)) {outp=inp=p; p=unfill(p);}
941: *--p= *vp;
942: }
943: if (*vp==warnc) {/* insert actual param */
944: ca=actual[*--vp-1];
945: while (*--ca) {
946: if (bob(p)) {outp=inp=p; p=unfill(p);}
947: /* Actuals with newlines confuse line numbering */
948: if (*ca == '\n' && actused[*vp-1])
949: if (*(ca-1) == '\\') ca--;
950: else *--p = ' ';
951: else { *--p= *ca; if (*ca == '\n') nlines--; }
952: }
953: actused[*vp-1] = 1;
954: } else {
955: if (nlines > 0 )
956: while (nlines-- > 0)
957: *--p = '\n';
958: break;
959: }
960: }
961: outp=inp=p;
962: return(p);
963: }
964:
965:
966:
967:
968: char *
969: trmdir(s) register char *s; {
970: register char *p = s;
971: while (*p++); --p; while (p>s && *--p!='/');
972: # if unix
973: if (p==s) *p++='.';
974: # endif
975: *p='\0';
976: return(s);
977: }
978:
979: STATIC char *
980: copy(s) register char *s; {
981: register char *old;
982:
983: old = savch; while (*savch++ = *s++);
984: return(old);
985: }
986:
987: char *
988: strdex(s,c) char *s,c; {
989: while (*s) if (*s++==c) return(--s);
990: return(0);
991: }
992:
993: yywrap(){ return(1); }
994:
995: main(argc,argv)
996: char *argv[];
997: {
998: register int i,c;
999: register char *p;
1000: char *tf,**cp2;
1001:
1002: # if gcos
1003: if (setjmp(env)) return (exfail);
1004: # endif
1005: p="_$ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
1006: i=0;
1007: while (c= *p++) {
1008: (fastab+COFF)[c] |= IB|NB|SB; (toktyp+COFF)[c]=IDENT;
1009: #if scw2
1010: /* 53 == 63-10; digits rarely appear in identifiers,
1011: /* and can never be the first char of an identifier.
1012: /* 11 == 53*53/sizeof(macbit) .
1013: */
1014: ++i; (t21+COFF)[c]=(53*i)/11; (t22+COFF)[c]=i%11;
1015: #endif
1016: }
1017: p="0123456789.";
1018: while (c= *p++) {(fastab+COFF)[c] |= NB|SB; (toktyp+COFF)[c]=NUMBR;}
1019: # if gcos
1020: p="\n\"'`/\\";
1021: # else
1022: p="\n\"'/\\";
1023: # endif
1024: while (c= *p++) (fastab+COFF)[c] |= SB;
1025: # if gcos
1026: p="\n\"'`\\";
1027: # else
1028: p="\n\"'\\";
1029: # endif
1030: while (c= *p++) (fastab+COFF)[c] |= QB;
1031: p="*\n"; while (c= *p++) (fastab+COFF)[c] |= CB;
1032: (fastab+COFF)[warnc] |= WB;
1033: (fastab+COFF)['\0'] |= CB|QB|SB|WB;
1034: for (i=ALFSIZ; --i>=0; ) slotab[i]=fastab[i]|SB;
1035: p=" \t\013\f\r"; /* note no \n; \v not legal for vertical tab? */
1036: while (c= *p++) (toktyp+COFF)[c]=BLANK;
1037: #if scw2
1038: for ((t23+COFF)[i=ALFSIZ+7-COFF]=1; --i>=-COFF; )
1039: if (((t23+COFF)[i]=(t23+COFF+1)[i]<<1)==0) (t23+COFF)[i]=1;
1040: #endif
1041:
1042: # if unix
1043: fnames[ifno=0] = ""; dirnams[0]=dirs[0]=".";
1044: # endif
1045: # if ibm
1046: fnames[ifno=0] = "";
1047: # endif
1048: # if gcos
1049: if (inquire(stdin, _TTY)) freopen("*src", "rt", stdin);
1050: # endif
1051: # if gimpel || gcos
1052: fnames[ifno=0] = (char *)inquire(stdin, _FILENAME);
1053: dirnams[0] = dirs[0] = trmdir(copy(fnames[0]));
1054: # endif
1055: for(i=1; i<argc; i++)
1056: {
1057: switch(argv[i][0])
1058: {
1059: case '-':
1060: # if gcos
1061: switch(toupper(argv[i][1])) { /* case-independent on GCOS */
1062: # else
1063: switch(argv[i][1]) {
1064: # endif
1065: case 'P': pflag++;
1066: case 'E': continue;
1067: case 'R': ++rflag; continue;
1068: case 'C': passcom++; continue;
1069: case 'D':
1070: if (predef>prespc+NPREDEF) {
1071: pperror("too many -D options, ignoring %s",argv[i]);
1072: continue;
1073: }
1074: /* ignore plain "-D" (no argument) */
1075: if (*(argv[i]+2)) *predef++ = argv[i]+2;
1076: continue;
1077: case 'U':
1078: if (prund>punspc+NPREDEF) {
1079: pperror("too many -U options, ignoring %s",argv[i]);
1080: continue;
1081: }
1082: *prund++ = argv[i]+2;
1083: continue;
1084: case 'I':
1085: if (nd>8) pperror("excessive -I file (%s) ignored",argv[i]);
1086: else dirs[nd++] = argv[i]+2;
1087: continue;
1088: case '\0': continue;
1089: default:
1090: pperror("unknown flag %s", argv[i]);
1091: continue;
1092: }
1093: default:
1094: if (fin==STDIN) {
1095: if (0>(fin=open(argv[i], READ))) {
1096: pperror("No source file %s",argv[i]); exit(8);
1097: }
1098: fnames[ifno]=copy(argv[i]);
1099: dirs[0]=dirnams[ifno]=trmdir(argv[i]);
1100: # ifndef gcos
1101: /* too dangerous to have file name in same syntactic position
1102: be input or output file depending on file redirections,
1103: so force output to stdout, willy-nilly
1104: [i don't see what the problem is. jfr]
1105: */
1106: } else if (fout==stdout) {
1107: extern char _sobuf[BUFSIZ];
1108: if (NULL==(fout=fopen(argv[i], "w"))) {
1109: pperror("Can't create %s", argv[i]); exit(8);
1110: } else {fclose(stdout); setbuf(fout,_sobuf);}
1111: # endif
1112: } else pperror("extraneous name %s", argv[i]);
1113: }
1114: }
1115:
1116: fins[ifno]=fin;
1117: exfail = 0;
1118: /* after user -I files here are the standard include libraries */
1119: # if unix
1120: dirs[nd++] = "/usr/include";
1121: # endif
1122: # if gcos
1123: dirs[nd++] = "cc/include";
1124: # endif
1125: # if ibm
1126: # ifndef gimpel
1127: dirs[nd++] = "BTL$CLIB";
1128: # endif
1129: # endif
1130: # ifdef gimpel
1131: dirs[nd++] = intss() ? "SYS3.C." : "" ;
1132: # endif
1133: /* dirs[nd++] = "/compool"; */
1134: dirs[nd++] = 0;
1135: defloc=ppsym("define");
1136: udfloc=ppsym("undef");
1137: incloc=ppsym("include");
1138: elsloc=ppsym("else");
1139: eifloc=ppsym("endif");
1140: ifdloc=ppsym("ifdef");
1141: ifnloc=ppsym("ifndef");
1142: ifloc=ppsym("if");
1143: lneloc=ppsym("line");
1144: for (i=sizeof(macbit)/sizeof(macbit[0]); --i>=0; ) macbit[i]=0;
1145: # if unix
1146: ysysloc=stsym("unix");
1147: # endif
1148: # if gcos
1149: ysysloc=stsym ("gcos");
1150: # endif
1151: # if ibm
1152: ysysloc=stsym ("ibm");
1153: # endif
1154: # if pdp11
1155: varloc=stsym("pdp11");
1156: # endif
1157: # if tahoe
1158: varloc=stsym("tahoe");
1159: # endif
1160: # if vax
1161: varloc=stsym("vax");
1162: # endif
1163: # if interdata
1164: varloc=stsym ("interdata");
1165: # endif
1166: # if tss
1167: varloc=stsym ("tss");
1168: # endif
1169: # if os
1170: varloc=stsym ("os");
1171: # endif
1172: # if mert
1173: varloc=stsym ("mert");
1174: # endif
1175: # if mc68000
1176: varloc=stsym("mc68000");
1177: # endif
1178: # if sun
1179: varloc=stsym("sun");
1180: # endif
1181: ulnloc=stsym ("__LINE__");
1182: uflloc=stsym ("__FILE__");
1183:
1184: tf=fnames[ifno]; fnames[ifno]="command line"; lineno[ifno]=1;
1185: cp2=prespc;
1186: while (cp2<predef) stsym(*cp2++);
1187: cp2=punspc;
1188: while (cp2<prund) {
1189: if (p=strdex(*cp2, '=')) *p++='\0';
1190: lookup(*cp2++, DROP);
1191: }
1192: fnames[ifno]=tf;
1193: pbeg=buffer+NCPS; pbuf=pbeg+BUFSIZ; pend=pbuf+BUFSIZ;
1194:
1195: trulvl = 0; flslvl = 0;
1196: lineno[0] = 1; sayline();
1197: outp=inp=pend;
1198: control(pend);
1199: return (exfail);
1200: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.