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