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