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