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