4.3BSD - /usr/src/lib/cpp/cpp.c

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

Defined functions

Defined variables

Defined struct's

Defined macros