Return to cpp.c CVS log

Up to [CSRG BSD Unix] / 43BSD / lib / cpp

Annotation of 43BSD/lib/cpp/cpp.c, revision 1.1

1.1     ! root        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: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.