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