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