1 /*
2 * C command
3 * written by John F. Reiser
4 * July/August 1978
5 */
6 /* Copyright (c) 2012 Joyent, Inc. All rights reserved. */
7 /*
8 * This implementation is based on the UNIX 32V release from 1978
9 * with permission from Caldera Inc.
10 *
11 * Copyright (c) 2010 J. Schilling
12 * All rights reserved.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
16 * are met:
17 * 1. Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in the
21 * documentation and/or other materials provided with the distribution.
22 * 3. Neither the name of the copyright holder nor the names of contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 */
38 /*
39 * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
40 *
41 * Redistribution and use in source and binary forms, with or without
42 * modification, are permitted provided that the following conditions are
43 * met:
44 * 1. Redistributions of source code and documentation must retain the above
45 * copyright notice, this list of conditions and the following
46 * disclaimer.
47 *
48 * 2. Redistributions in binary form must reproduce the above copyright
49 * notice, this list of conditions and the following disclaimer in the
50 * documentation and/or other materials provided with the distribution.
51 *
52 * 3. All advertising materials mentioning features or use of this software
53 * must display the following acknowledgement: This product includes
54 * software developed or owned by Caldera International, Inc.
55 *
56 * 4. Neither the name of Caldera International, Inc. nor the names of other
57 * contributors may be used to endorse or promote products derived from
58 * this software without specific prior written permission.
59 *
60 * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
61 * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
62 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
63 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
64 * DISCLAIMED. IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE FOR
65 * ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
66 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
67 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
68 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
69 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
70 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
71 * POSSIBILITY OF SUCH DAMAGE.
72 */
73 #include <stdio.h>
74 #include <unistd.h>
75 #include <stdlib.h>
76 #include <fcntl.h>
77 #include <string.h>
78 #include <stdarg.h>
79
80 #include "cpp.h"
81
82 #define SYMLEN 128
83 static int symlen = SYMLEN;
84
85
86 #define SALT '#'
87 #ifndef BUFSIZ
88 #define BUFSIZ 512
89 #endif
90
91 static char *pbeg;
92 static char *pbuf;
93 static char *pend;
94 char *outp,*inp;
95 char *newp;
96 static char cinit;
97
98 /* some code depends on whether characters are sign or zero extended */
99 /* #if '\377' < 0 not used here, old cpp doesn't understand */
100 #if pdp11 | vax | '\377' < 0
101 #define COFF 128
102 #else
103 #define COFF 0
104 #endif
105
106 #define ALFSIZ 256 /* alphabet size */
107 static char macbit[ALFSIZ+11];
108 static char toktyp[ALFSIZ];
109 #define BLANK 1 /* white space (" \t\v\f\r") */
110 #define IDENT 2 /* valid char for identifier names */
111 #define NUMBR 3 /* chars is of "0123456789." */
112
113 /*
114 * a superimposed code is used to reduce the number of calls to the
115 * symbol table lookup routine. (if the kth character of an identifier
116 * is 'a' and there are no macro names whose kth character is 'a'
117 * then the identifier cannot be a macro name, hence there is no need
118 * to look in the symbol table.) 'scw1' enables the test based on
119 * single characters and their position in the identifier. 'scw2'
120 * enables the test based on adjacent pairs of characters and their
121 * position in the identifier. scw1 typically costs 1 indexed fetch,
122 * an AND, and a jump per character of identifier, until the identifier
123 * is known as a non-macro name or until the end of the identifier.
124 * scw1 is inexpensive. scw2 typically costs 4 indexed fetches,
125 * an add, an AND, and a jump per character of identifier, but it is also
126 * slightly more effective at reducing symbol table searches.
127 * scw2 usually costs too much because the symbol table search is
128 * usually short; but if symbol table search should become expensive,
129 * the code is here.
130 * using both scw1 and scw2 is of dubious value.
131 */
132 #define scw1 1
133 #define scw2 0
134
135 #if scw2
136 char t21[ALFSIZ],t22[ALFSIZ],t23[ALFSIZ+SYMLEN];
137 #endif
138
139 #if scw1
140 #define b0 1
141 #define b1 2
142 #define b2 4
143 #define b3 8
144 #define b4 16
145 #define b5 32
146 #define b6 64
147 #define b7 128
148 #endif
149
150 #define IB 1
151 #define SB 2
152 #define NB 4
153 #define CB 8
154 #define QB 16
155 #define WB 32
156 char fastab[ALFSIZ];
157 static char slotab[ALFSIZ];
158 static char *ptrtab;
159
160 /*
161 * Cast the array index to int in order to avoid GCCs warnings:
162 * warning: subscript has type `char'
163 */
164 #define isslo (ptrtab==(slotab+COFF))
165 #define isid(a) ((fastab+COFF)[(int)a]&IB)
166 #define isspc(a) (ptrtab[(int)a]&SB)
167 #define isnum(a) ((fastab+COFF)[(int)a]&NB)
168 #define iscom(a) ((fastab+COFF)[(int)a]&CB)
169 #define isquo(a) ((fastab+COFF)[(int)a]&QB)
170 #define iswarn(a) ((fastab+COFF)[(int)a]&WB)
171
172 #define eob(a) ((a)>=pend)
173 #define bob(a) (pbeg>=(a))
174
175 #define BUFFERSIZ 8192
176 static char buffer[SYMLEN+BUFFERSIZ+BUFFERSIZ+SYMLEN];
177
178 /*
179 * SBSIZE was 12000 in 1978, we need to have a way to
180 * malloc more space.
181 */
182 #define SBSIZE 512000
183 static char sbf[SBSIZE];
184 static char *savch = sbf;
185
186 # define DROP 0xFE /* special character not legal ASCII or EBCDIC */
187 # define WARN DROP
188 # define SAME 0
189 # define MAXINC 16 /* max include nesting depth */
190 # define MAXIDIRS 20 /* max # of -I directories */
191 # define MAXFRE 14 /* max buffers of macro pushback */
192 # define MAXFRM 31 /* max number of formals/actuals to a macro */
193
194 static char warnc = (char)WARN;
195
196 static int mactop;
197 static int fretop;
198 static char *instack[MAXFRE];
199 static char *bufstack[MAXFRE];
200 static char *endbuf[MAXFRE];
201
202 static int plvl; /* parenthesis level during scan for macro actuals */
203 static int maclin; /* line number of macro call requiring actuals */
204 static char *macfil; /* file name of macro call requiring actuals */
205 static char *macnam; /* name of macro requiring actuals */
206 static int maclvl; /* # calls since last decrease in nesting level */
207 static char *macforw; /* ptr which must be exceeded to decrease nesting lvl */
208 static int macdam; /* offset to macforw due to buffer shifting */
209
210 #if tgp
211 int tgpscan; /* flag for dump(); */
212 #endif
213
214 static int inctop[MAXINC];
215 static char *fnames[MAXINC];
216 static char *dirnams[MAXINC]; /* actual directory of #include files */
217 static int fins[MAXINC];
218 static int lineno[MAXINC];
219
220 /*
221 * We need:
222 * "" include dir as dirs[0] +
223 * MAXIDIRS +
224 * system default include dir +
225 * a NULL pointer at the end
226 */
227 static char *dirs[MAXIDIRS+3]; /* -I and <> directories */
228 static int fin = STDIN_FILENO;
229 static FILE *fout; /* Init in main(), Mac OS is nonPOSIX */
230 static int nd = 1;
231 static int pflag; /* don't put out lines "# 12 foo.c" */
232 static int passcom; /* don't delete comments */
233 static int rflag; /* allow macro recursion */
234 static int hflag; /* Print included filenames */
235 static int nopredef; /* -undef all */
236 static int ifno;
237 # define NPREDEF 64
238 static char *prespc[NPREDEF];
239 static char **predef = prespc;
240 static char *punspc[NPREDEF];
241 static char **prund = punspc;
242 static int exfail;
243 static struct symtab *lastsym;
244
245
246 static void sayline(char *);
247 static void dump(void);
248 static char *refill(char *);
249 static char *cotoken(char *);
250 char *skipbl(char *);
251 static char *unfill(char *);
252 static char *doincl(char *);
253 static int equfrm(char *, char *, char *);
254 static char *dodef(char *);
255 static char *control(char *);
256 static struct symtab *stsym(char *);
257 static struct symtab *ppsym(char *);
258 void pperror(char *fmt, ...);
259 void yyerror(char *fmt, ...);
260 static void ppwarn(char *fmt, ...);
261 struct symtab *lookup(char *, int);
262 static struct symtab *slookup(char *, char *, int);
263 static char *subst(char *, struct symtab *);
264 static char *trmdir(char *);
265 static char *copy(char *);
266 static char *strdex(char *, int);
267 int yywrap(void);
268 int main(int argc, char **argav);
269
270
271 #define symsiz 4000
272 static struct symtab stab[symsiz];
273
274 static struct symtab *defloc;
275 static struct symtab *udfloc;
276 static struct symtab *incloc;
277 static struct symtab *ifloc;
278 static struct symtab *elsloc;
279 static struct symtab *eifloc;
280 static struct symtab *elifloc;
281 static struct symtab *ifdloc;
282 static struct symtab *ifnloc;
283 static struct symtab *ysysloc;
284 static struct symtab *varloc;
285 static struct symtab *lneloc;
286 static struct symtab *ulnloc;
287 static struct symtab *uflloc;
288 static struct symtab *idtloc;
289 static struct symtab *pragmaloc;
290 static struct symtab *errorloc;
291 static int trulvl;
292 int flslvl;
293 static int elflvl;
294 static int elslvl;
295
296 /*
297 * The sun cpp prints a classification token past the
298 * "# linenumber filename" lines:
299 */
300 #define NOINCLUDE "" /* Not related to enter/leave incl. file */
301 #define ENTERINCLUDE "1" /* We are just entering an include file */
302 #define LEAVEINCLUDE "2" /* We are just leaving an include file */
303
304 /* ARGSUSED */
305 static void
306 sayline(what)
307 char *what;
308 {
309 if (pflag==0)
310 fprintf(fout,"# %d \"%s\" %s\n", lineno[ifno], fnames[ifno], what);
311 }
312
313 /*
314 * data structure guide
315 *
316 * most of the scanning takes place in the buffer:
317 *
318 * (low address) (high address)
319 * pbeg pbuf pend
320 * | <-- BUFFERSIZ chars --> | <-- BUFFERSIZ chars --> |
321 * _______________________________________________________________________
322 * |_______________________________________________________________________|
323 * | | |
324 * |<-- waiting -->| |<-- waiting -->
325 * | to be |<-- current -->| to be
326 * | written | token | scanned
327 * | | |
328 * outp inp p
329 *
330 * *outp first char not yet written to output file
331 * *inp first char of current token
332 * *p first char not yet scanned
333 *
334 * macro expansion: write from *outp to *inp (chars waiting to be written),
335 * ignore from *inp to *p (chars of the macro call), place generated
336 * characters in front of *p (in reverse order), update pointers,
337 * resume scanning.
338 *
339 * symbol table pointers point to just beyond the end of macro definitions;
340 * the first preceding character is the number of formal parameters.
341 * the appearance of a formal in the body of a definition is marked by
342 * 2 chars: the char WARN, and a char containing the parameter number.
343 * the first char of a definition is preceded by a zero character.
344 *
345 * when macro expansion attempts to back up over the beginning of the
346 * buffer, some characters preceding *pend are saved in a side buffer,
347 * the address of the side buffer is put on 'instack', and the rest
348 * of the main buffer is moved to the right. the end of the saved buffer
349 * is kept in 'endbuf' since there may be nulls in the saved buffer.
350 *
351 * similar action is taken when an 'include' statement is processed,
352 * except that the main buffer must be completely emptied. the array
353 * element 'inctop[ifno]' records the last side buffer saved when
354 * file 'ifno' was included. these buffers remain dormant while
355 * the file is being read, and are reactivated at end-of-file.
356 *
357 * instack[0 : mactop] holds the addresses of all pending side buffers.
358 * instack[inctop[ifno]+1 : mactop-1] holds the addresses of the side
359 * buffers which are "live"; the side buffers instack[0 : inctop[ifno]]
360 * are dormant, waiting for end-of-file on the current file.
361 *
362 * space for side buffers is obtained from 'savch' and is never returned.
363 * bufstack[0:fretop-1] holds addresses of side buffers which
364 * are available for use.
365 */
366
367 static void
368 dump() {
369 /*
370 * write part of buffer which lies between outp and inp .
371 * this should be a direct call to 'write', but the system slows to a crawl
372 * if it has to do an unaligned copy. thus we buffer. this silly loop
373 * is 15% of the total time, thus even the 'putc' macro is too slow.
374 */
375 register char *p1;
376 #if tgp
377 register char *p2;
378 #endif
379 register FILE *f;
380 if ((p1=outp)==inp || flslvl!=0) return;
381 #if tgp
382 #define MAXOUT 80
383 if (!tgpscan) {
384 /* scan again to insure <= MAXOUT chars between linefeeds */
385 register char c,*pblank; char savc,stopc,brk;
386 tgpscan=1; brk=stopc=pblank=0; p2=inp; savc= *p2; *p2='\0';
387 while (c= *p1++) {
388 if (c=='\\') c= *p1++;
389 if (stopc==c) stopc=0;
390 else if (c=='"' || c=='\'') stopc=c;
391 if (p1-outp>MAXOUT && pblank!=0) {
392 *pblank++='\n';
393 inp=pblank;
394 dump();
395 brk=1;
396 pblank=0;
397 }
398 if (c==' ' && stopc==0) pblank=p1-1;
399 }
400 if (brk) sayline(NOINCLUDE);
401 *p2=savc; inp=p2; p1=outp; tgpscan=0;
402 }
403 #endif
404 f=fout;
405 while (p1<inp)
406 putc(*p1++,f);
407 outp=p1;
408 }
409
410 static char *
411 refill(p) register char *p; {
412 /*
413 * dump buffer. save chars from inp to p. read into buffer at pbuf,
414 * contiguous with p. update pointers, return new p.
415 */
416 register char *np,*op; register int ninbuf;
417 dump(); np=pbuf-(p-inp); op=inp;
418 if (bob(np+1)) {pperror("token too long"); np=pbeg; p=inp+BUFFERSIZ;}
419 macdam += np-inp; outp=inp=np;
420 while (op<p) *np++= *op++;
421 p=np;
422 for (;;) {
423 if (mactop>inctop[ifno]) {
424 /* retrieve hunk of pushed-back macro text */
425 op=instack[--mactop]; np=pbuf;
426 do {
427 while ((*np++= *op++) != '\0');
428 } while (op<endbuf[mactop]); pend=np-1;
429 /* make buffer space avail for 'include' processing */
430 if (fretop<MAXFRE) bufstack[fretop++]=instack[mactop];
431 return(p);
432 } else {/* get more text from file(s) */
433 maclvl=0;
434 if (0<(ninbuf=read(fin,pbuf,BUFFERSIZ))) {
435 pend=pbuf+ninbuf; *pend='\0';
436 return(p);
437 }
438 /* end of #include file */
439 if (ifno==0) {/* end of input */
440 if (plvl!=0) {
441 int n=plvl,tlin=lineno[ifno];
442 char *tfil=fnames[ifno];
443 lineno[ifno]=maclin;
444 fnames[ifno]=macfil;
445 pperror("%s: unterminated macro call",
446 macnam);
447 lineno[ifno]=tlin; fnames[ifno]=tfil;
448 np=p;
449 /*
450 * shut off unterminated quoted string
451 */
452 *np++='\n';
453 /* supply missing parens */
454 while (--n>=0) *np++=')';
455 pend=np; *np='\0';
456 if (plvl<0) plvl=0;
457 return(p);
458 }
459 inp=p; dump(); exit(exfail);
460 }
461 close(fin);
462 fin=fins[--ifno];
463 dirs[0]=dirnams[ifno];
464 sayline(LEAVEINCLUDE);
465 }
466 }
467 }
468
469 #define BEG 0
470 #define LF 1
471
472 static char *
473 cotoken(p) register char *p; {
474 register int c,i; char quoc;
475 static int state = BEG;
476
477 if (state!=BEG) goto prevlf;
478 for (;;) {
479 again:
480 while (!isspc(*p++));
481 switch (*(inp=p-1)) {
482 case 0: {
483 if (eob(--p)) {p=refill(p); goto again;}
484 else ++p; /* ignore null byte */
485 } break;
486 case '|': case '&': for (;;) {/* sloscan only */
487 if (*p++== *inp) break;
488 if (eob(--p)) p=refill(p);
489 else break;
490 } break;
491 case '=': case '!': for (;;) {/* sloscan only */
492 if (*p++=='=') break;
493 if (eob(--p)) p=refill(p);
494 else break;
495 } break;
496 case '<': case '>': for (;;) {/* sloscan only */
497 if (*p++=='=' || p[-2]==p[-1]) break;
498 if (eob(--p)) p=refill(p);
499 else break;
500 } break;
501 case '\\': for (;;) {
502 if (*p++=='\n') {++lineno[ifno]; break;}
503 if (eob(--p)) p=refill(p);
504 else {++p; break;}
505 } break;
506 case '/': for (;;) {
507 if (*p++=='*') {/* comment */
508 if (!passcom) {inp=p-2; dump(); ++flslvl;}
509 for (;;) {
510 while (!iscom(*p++));
511 if (p[-1]=='*') for (;;) {
512 if (*p++=='/') goto endcom;
513 if (eob(--p)) {
514 if (!passcom) {
515 inp=p;
516 p=refill(p);
517 } else if ((p-inp)>=BUFFERSIZ) {
518 /* split long comment */
519 inp=p;
520 /*
521 * last char written
522 * is '*'
523 */
524 p=refill(p);
525 /*
526 * terminate first part
527 */
528 putc('/',fout);
529 /*
530 * and fake start of 2nd
531 */
532 outp=inp=p-=3;
533 *p++='/';
534 *p++='*';
535 *p++='*';
536 } else {
537 p=refill(p);
538 }
539 } else {
540 break;
541 }
542 } else if (p[-1]=='\n') {
543 ++lineno[ifno];
544 if (!passcom)
545 putc('\n',fout);
546 } else if (eob(--p)) {
547 if (!passcom) {
548 inp=p; p=refill(p);
549 } else if ((p-inp)>=BUFFERSIZ) {
550 /* split long comment */
551 inp=p; p=refill(p);
552 putc('*',fout); putc('/',fout);
553 outp=inp=p-=2;
554 *p++='/';
555 *p++='*';
556 } else {
557 p=refill(p);
558 }
559 } else {
560 ++p; /* ignore null byte */
561 }
562 }
563 endcom:
564 if (!passcom) {outp=inp=p; --flslvl; goto again;}
565 break;
566 }
567 if (eob(--p)) p=refill(p);
568 else break;
569 } break;
570 case '"': case '\'': {
571 quoc=p[-1];
572 for (;;) {
573 while (!isquo(*p++));
574 if (p[-1]==quoc)
575 break;
576 if (p[-1]=='\n') {
577 --p;
578 break;
579 } /* bare \n terminates quotation */
580 if (p[-1]=='\\') {
581 for (;;) {
582 if (*p++=='\n') {
583 ++lineno[ifno];
584 break;
585 } /* escaped \n ignored */
586 if (eob(--p)) {
587 p=refill(p);
588 } else {
589 ++p;
590 break;
591 }
592 }
593 } else if (eob(--p)) {
594 p=refill(p);
595 } else {
596 ++p; /* it was a different quote character */
597 }
598 }
599 } break;
600 case '\n': {
601 ++lineno[ifno]; if (isslo) {state=LF; return(p);}
602 prevlf:
603 state=BEG;
604 for (;;) {
605 if (*p++=='#') return(p);
606 if (eob(inp= --p)) p=refill(p);
607 else goto again;
608 }
609 }
610 /* NOTREACHED */
611 case '0': case '1': case '2': case '3': case '4':
612 case '5': case '6': case '7': case '8': case '9':
613 for (;;) {
614 while (isnum(*p++));
615 if (eob(--p)) p=refill(p);
616 else break;
617 } break;
618 case 'A': case 'B': case 'C': case 'D': case 'E':
619 case 'F': case 'G': case 'H': case 'I': case 'J':
620 case 'K': case 'L': case 'M': case 'N': case 'O':
621 case 'P': case 'Q': case 'R': case 'S': case 'T':
622 case 'U': case 'V': case 'W': case 'X': case 'Y':
623 case 'Z': case '_':
624 case 'a': case 'b': case 'c': case 'd': case 'e':
625 case 'f': case 'g': case 'h': case 'i': case 'j':
626 case 'k': case 'l': case 'm': case 'n': case 'o':
627 case 'p': case 'q': case 'r': case 's': case 't':
628 case 'u': case 'v': case 'w': case 'x': case 'y':
629 case 'z':
630 #if scw1
631 #define tmac1(c,bit) if (!xmac1(c,bit,&)) goto nomac
632 #define xmac1(c,bit,op) ((macbit+COFF)[c] op (bit))
633 #else
634 #define tmac1(c,bit)
635 #define xmac1(c,bit,op)
636 #endif
637
638 #if scw2
639 #define tmac2(c0,c1,cpos) if (!xmac2(c0,c1,cpos,&)) goto nomac
640 #define xmac2(c0,c1,cpos,op)\
641 ((macbit+COFF)[(t21+COFF)[c0]+(t22+COFF)[c1]] op (t23+COFF+cpos)[c0])
642 #else
643 #define tmac2(c0,c1,cpos)
644 #define xmac2(c0,c1,cpos,op)
645 #endif
646
647 if (flslvl) goto nomac;
648 for (;;) {
649 c= p[-1]; tmac1(c,b0);
650 i= *p++; if (!isid(i)) goto endid; tmac1(i,b1); tmac2(c,i,0);
651 c= *p++; if (!isid(c)) goto endid; tmac1(c,b2); tmac2(i,c,1);
652 i= *p++; if (!isid(i)) goto endid; tmac1(i,b3); tmac2(c,i,2);
653 c= *p++; if (!isid(c)) goto endid; tmac1(c,b4); tmac2(i,c,3);
654 i= *p++; if (!isid(i)) goto endid; tmac1(i,b5); tmac2(c,i,4);
655 c= *p++; if (!isid(c)) goto endid; tmac1(c,b6); tmac2(i,c,5);
656 i= *p++; if (!isid(i)) goto endid; tmac1(i,b7); tmac2(c,i,6);
657 tmac2(i,0,7);
658 while (isid(*p++));
659 if (eob(--p)) {refill(p); p=inp+1; continue;}
660 goto lokid;
661 endid:
662 if (eob(--p)) {refill(p); p=inp+1; continue;}
663 tmac2(p[-1],0,-1+(p-inp));
664 lokid:
665 slookup(inp,p,0); if (newp) {p=newp; goto again;}
666 else break;
667 nomac:
668 while (isid(*p++));
669 if (eob(--p)) {p=refill(p); goto nomac;}
670 else break;
671 } break;
672 } /* end of switch */
673
674 if (isslo) return(p);
675 } /* end of infinite loop */
676 }
677
678 char *
679 skipbl(p) register char *p; {/* get next non-blank token */
680 do {
681 outp=inp=p;
682 p=cotoken(p);
683 } while ((toktyp+COFF)[(int)*inp]==BLANK);
684 return(p);
685 }
686
687 static char *
688 unfill(p) register char *p; {
689 /*
690 * take <= BUFFERSIZ chars from right end of buffer and put them on instack .
691 * slide rest of buffer to the right, update pointers, return new p.
692 */
693 register char *np,*op; register int d;
694 if (mactop>=MAXFRE) {
695 pperror("%s: too much pushback",macnam);
696 p=inp=pend; dump(); /* begin flushing pushback */
697 while (mactop>inctop[ifno]) {p=refill(p); p=inp=pend; dump();}
698 }
699 if (fretop>0)
700 np=bufstack[--fretop];
701 else {
702 np=savch; savch+=BUFFERSIZ;
703 if (savch>=sbf+SBSIZE) {pperror("no space"); exit(exfail);}
704 *savch++='\0';
705 }
706 instack[mactop]=np; op=pend-BUFFERSIZ; if (op<p) op=p;
707 for (;;) {
708 while ((*np++= *op++) != '\0');
709 if (eob(op))
710 break;
711 } /* out with old */
712 endbuf[mactop++]=np; /* mark end of saved text */
713 np=pbuf+BUFFERSIZ;
714 op=pend-BUFFERSIZ;
715 pend=np;
716 if (op<p)
717 op=p;
718 while (outp<op) *--np= *--op; /* slide over new */
719 if (bob(np))
720 pperror("token too long");
721 d=np-outp; outp+=d; inp+=d; macdam+=d;
722 return(p+d);
723 }
724
725 static char *
726 doincl(p) register char *p; {
727 int filok,inctype;
728 register char *cp; char **dirp,*nfil; char filname[BUFFERSIZ];
729
730 filname[0] = '\0'; /* Make lint quiet */
731 p=skipbl(p); cp=filname;
732 if (*inp++=='<') {/* special <> syntax */
733 inctype=1;
734 for (;;) {
735 outp=inp=p; p=cotoken(p);
736 if (*inp=='\n') {--p; *cp='\0'; break;}
737 if (*inp=='>') { *cp='\0'; break;}
738 # ifdef gimpel
739 if (*inp=='.' && !intss()) *inp='#';
740 # endif
741 while (inp<p) *cp++= *inp++;
742 }
743 } else if (inp[-1]=='"') {/* regular "" syntax */
744 inctype=0;
745 # ifdef gimpel
746 while (inp<p) {if (*inp=='.' && !intss()) *inp='#'; *cp++= *inp++;}
747 # else
748 while (inp<p) *cp++= *inp++;
749 # endif
750 if (*--cp=='"') *cp='\0';
751 } else {pperror("bad include syntax",0); inctype=2;}
752 /* flush current file to \n , then write \n */
753 ++flslvl; do {outp=inp=p; p=cotoken(p);} while (*inp!='\n'); --flslvl;
754 inp=p; dump(); if (inctype==2) return(p);
755 /* look for included file */
756 if (ifno+1 >=MAXINC) {
757 pperror("Unreasonable include nesting",0); return(p);
758 }
759 if ((nfil=savch)>sbf+SBSIZE-BUFFERSIZ) {
760 pperror("no space");
761 exit(exfail);
762 }
763 filok=0;
764 for (dirp=dirs+inctype; *dirp; ++dirp) {
765 if (filname[0]=='/' || **dirp=='\0') {
766 strcpy(nfil,filname);
767 } else {
768 strcpy(nfil,*dirp);
769 # if unix
770 strcat(nfil,"/");
771 # endif
772 strcat(nfil,filname);
773 }
774 if (0<(fins[ifno+1]=open(nfil, O_RDONLY))) {
775 filok=1; fin=fins[++ifno]; break;
776 }
777 }
778 if (filok==0) {
779 pperror("Can't find include file %s",filname);
780 } else {
781 lineno[ifno]=1; fnames[ifno]=cp=nfil; while (*cp++); savch=cp;
782 dirnams[ifno]=dirs[0]=trmdir(copy(nfil));
783 sayline(ENTERINCLUDE);
784 if (hflag)
785 fprintf(stderr, "%s\n", nfil);
786 /* save current contents of buffer */
787 while (!eob(p)) p=unfill(p);
788 inctop[ifno]=mactop;
789 }
790 return(p);
791 }
792
793 static int
794 equfrm(a,p1,p2) register char *a,*p1,*p2; {
795 register char c; int flag;
796 c= *p2; *p2='\0';
797 flag=strcmp(a,p1); *p2=c; return(flag==SAME);
798 }
799
800 static char *
801 dodef(p) char *p; {/* process '#define' */
802 register char *pin,*psav,*cf;
803 char **pf,**qf; int b,c,params; struct symtab *np;
804 char *oldval,*oldsavch;
805 char *formal[MAXFRM]; /* formal[n] is name of nth formal */
806 char formtxt[BUFFERSIZ]; /* space for formal names */
807
808 formtxt[0] = '\0'; /* Make lint quiet */
809
810 if (savch>sbf+SBSIZE-BUFFERSIZ) {
811 pperror("too much defining");
812 return(p);
813 }
814 oldsavch=savch; /* to reclaim space if redefinition */
815 ++flslvl; /* prevent macro expansion during 'define' */
816 p=skipbl(p); pin=inp;
817 if ((toktyp+COFF)[(int)*pin]!=IDENT) {
818 ppwarn("illegal macro name");
819 while (*inp!='\n')
820 p=skipbl(p);
821 return(p);
822 }
823 np=slookup(pin,p,1);
824 if (getenv("CPP_DEBUG_DEFINITIONS") != NULL)
825 fprintf(stderr, "*** defining %s at %s:%d\n",
826 np->name, fnames[ifno], lineno[ifno]);
827 if ((oldval=np->value) != NULL)
828 savch=oldsavch; /* was previously defined */
829 b=1; cf=pin;
830 while (cf<p) {/* update macbit */
831 c= *cf++; xmac1(c,b,|=); b=(b+b)&0xFF;
832 if (cf!=p) {
833 xmac2(c,*cf,-1+(cf-pin),|=);
834 } else {
835 xmac2(c,0,-1+(cf-pin),|=);
836 }
837 }
838 params=0; outp=inp=p; p=cotoken(p); pin=inp;
839 formal[0] = ""; /* Prepare for hack at next line... */
840 pf = formal; /* Make gcc/lint quiet, pf only used with params!=0 */
841 if (*pin=='(') {/* with parameters; identify the formals */
842 cf=formtxt; pf=formal;
843 for (;;) {
844 p=skipbl(p); pin=inp;
845 if (*pin=='\n') {
846 --lineno[ifno];
847 --p;
848 pperror("%s: missing )",np->name);
849 break;
850 }
851 if (*pin==')') break;
852 if (*pin==',') continue;
853 if ((toktyp+COFF)[(int)*pin]!=IDENT) {
854 c= *p;
855 *p='\0';
856 pperror("bad formal: %s",pin);
857 *p=c;
858 } else if (pf>= &formal[MAXFRM]) {
859 c= *p;
860 *p='\0';
861 pperror("too many formals: %s",pin);
862 *p=c;
863 } else {
864 *pf++=cf;
865 while (pin<p)
866 *cf++= *pin++;
867 *cf++='\0';
868 ++params;
869 }
870 }
871 if (params==0)
872 --params; /* #define foo() ... */
873 } else if (*pin=='\n') {
874 --lineno[ifno];
875 --p;
876 }
877 /*
878 * remember beginning of macro body, so that we can
879 * warn if a redefinition is different from old value.
880 */
881 oldsavch=psav=savch;
882 for (;;) {/* accumulate definition until linefeed */
883 outp=inp=p; p=cotoken(p); pin=inp;
884 if (*pin=='\\' && pin[1]=='\n')
885 continue; /* ignore escaped lf */
886 if (*pin=='\n') break;
887 if (params) {
888 /* mark the appearance of formals in the definiton */
889 if ((toktyp+COFF)[(int)*pin]==IDENT) {
890 for (qf=pf; --qf>=formal; ) {
891 if (equfrm(*qf,pin,p)) {
892 *psav++=qf-formal+1;
893 *psav++=WARN;
894 pin=p;
895 break;
896 }
897 }
898 } else if (*pin=='"' || *pin=='\'') {
899 /* inside quotation marks, too */
900 char quoc= *pin;
901 for (*psav++= *pin++; pin<p && *pin!=quoc; ) {
902 while (pin<p && !isid(*pin))
903 *psav++= *pin++;
904 cf=pin;
905 while (cf<p && isid(*cf))
906 ++cf;
907 for (qf=pf; --qf>=formal; ) {
908 if (equfrm(*qf,pin,cf)) {
909 *psav++=qf-formal+1;
910 *psav++=WARN;
911 pin=cf;
912 break;
913 }
914 }
915 while (pin<cf)
916 *psav++= *pin++;
917 }
918 }
919 }
920 while (pin<p) *psav++= *pin++;
921 }
922 *psav++=params; *psav++='\0';
923 if ((cf=oldval)!=NULL) {/* redefinition */
924 --cf; /* skip no. of params, which may be zero */
925 while (*--cf); /* go back to the beginning */
926 if (0!=strcmp(++cf,oldsavch)) {
927 /* redefinition different from old */
928 --lineno[ifno];
929 ppwarn("%s redefined",np->name);
930 ++lineno[ifno];
931 np->value=psav-1;
932 } else {
933 psav=oldsavch; /* identical redef.; reclaim space */
934 }
935 } else {
936 np->value=psav-1;
937 }
938 --flslvl; inp=pin; savch=psav; return(p);
939 }
940
941 #define fasscan() ptrtab=fastab+COFF
942 #define sloscan() ptrtab=slotab+COFF
943
944 static char *
945 control(p) register char *p; {/* find and handle preprocessor control lines */
946 register struct symtab *np;
947 for (;;) {
948 fasscan(); p=cotoken(p); if (*inp=='\n') ++inp; dump();
949 sloscan(); p=skipbl(p);
950 *--inp=SALT; outp=inp; ++flslvl; np=slookup(inp,p,0); --flslvl;
951 if (np==defloc) {/* define */
952 if (flslvl==0) {p=dodef(p); continue;}
953 } else if (np==incloc) {/* include */
954 if (flslvl==0) {p=doincl(p); continue;}
955 } else if (np==ifnloc) {/* ifndef */
956 ++flslvl; p=skipbl(p); np=slookup(inp,p,0); --flslvl;
957 if (flslvl==0 && np->value==0) ++trulvl;
958 else ++flslvl;
959 } else if (np==ifdloc) {/* ifdef */
960 ++flslvl; p=skipbl(p); np=slookup(inp,p,0); --flslvl;
961 if (flslvl==0 && np->value!=0) ++trulvl;
962 else ++flslvl;
963 } else if (np==eifloc) {/* endif */
964 if (flslvl) {if (--flslvl==0) sayline(NOINCLUDE);}
965 else if (trulvl) --trulvl;
966 else pperror("If-less endif",0);
967
968 if (flslvl == 0)
969 elflvl = 0;
970 elslvl = 0;
971 } else if (np==elifloc) {/* elif */
972 if (flslvl == 0)
973 elflvl = trulvl;
974 if (flslvl) {
975 if (elflvl > trulvl) {
976 ;
977 } else if (--flslvl != 0) {
978 ++flslvl;
979 } else {
980 newp = p;
981 if (yyparse()) {
982 ++trulvl;
983 sayline(NOINCLUDE);
984 } else {
985 ++flslvl;
986 }
987 p = newp;
988 }
989 } else if (trulvl) {
990 ++flslvl;
991 --trulvl;
992 } else
993 pperror("If-less elif");
994
995 } else if (np==elsloc) {/* else */
996 if (flslvl) {
997 if (elflvl > trulvl)
998 ;
999 else if (--flslvl!=0) ++flslvl;
1000 else {++trulvl; sayline(NOINCLUDE);}
1001 }
1002 else if (trulvl) {++flslvl; --trulvl;}
1003 else pperror("If-less else",0);
1004
1005 if (elslvl==trulvl+flslvl)
1006 pperror("Too many #else's");
1007 elslvl=trulvl+flslvl;
1008
1009 } else if (np==udfloc) {/* undefine */
1010 if (flslvl==0) {
1011 ++flslvl; p=skipbl(p); slookup(inp,p,DROP); --flslvl;
1012 }
1013 } else if (np==ifloc) {/* if */
1014 #if tgp
1015 pperror(" IF not implemented, true assumed", 0);
1016 if (flslvl==0) ++trulvl; else ++flslvl;
1017 #else
1018 newp=p;
1019 if (flslvl==0 && yyparse()) ++trulvl; else ++flslvl;
1020 p=newp;
1021 #endif
1022 } else if (np == idtloc) { /* ident */
1023 if (pflag == 0)
1024 while (*inp != '\n') /* pass text */
1025 p = cotoken(p);
1026 } else if (np == pragmaloc) { /* pragma */
1027 while (*inp != '\n') /* pass text */
1028 p = cotoken(p);
1029 } else if (np == errorloc) { /* error */
1030 #ifdef EXIT_ON_ERROR
1031 if (trulvl > 0) {
1032 char ebuf[BUFFERSIZ];
1033
1034 p = ebuf;
1035 while (*inp != '\n') {
1036 if (*inp == '\0')
1037 if (eob(--inp)) {
1038 inp = refill(inp);
1039 continue;
1040 }
1041 *p++ = *inp++;
1042 if (p >= &ebuf[BUFFERSIZ-1])
1043 break;
1044 }
1045 *p = '\0';
1046 pperror(ebuf);
1047 exit(exfail);
1048 }
1049 #else
1050 while (*inp != '\n') /* pass text */
1051 p = cotoken(p);
1052 #endif
1053 } else if (np==lneloc) {/* line */
1054 if (flslvl==0 && pflag==0) {
1055 outp=inp=p;
1056 *--outp='#';
1057 while (*inp!='\n')
1058 p=cotoken(p);
1059 continue;
1060 }
1061 } else if (*++inp=='\n') {
1062 outp=inp; /* allows blank line after # */
1063 } else {
1064 pperror("undefined control",0);
1065 }
1066 /* flush to lf */
1067 ++flslvl;
1068 while (*inp!='\n') {
1069 outp=inp=p;
1070 p=cotoken(p);
1071 }
1072 --flslvl;
1073 }
1074 }
1075
1076 static struct symtab *
1077 stsym(s) register char *s; {
1078 char buf[BUFFERSIZ]; register char *p;
1079
1080 /* make definition look exactly like end of #define line */
1081 /* copy to avoid running off end of world when param list is at end */
1082 p=buf; while ((*p++= *s++) != '\0');
1083 p=buf; while (isid(*p++)); /* skip first identifier */
1084 if (*--p=='=') {*p++=' '; while (*p++);}
1085 else {s=" 1"; while ((*p++= *s++) != '\0');}
1086 pend=p; *--p='\n';
1087 sloscan(); dodef(buf); return(lastsym);
1088 }
1089
1090 static struct symtab *
1091 ppsym(s) char *s; {/* kluge */
1092 register struct symtab *sp;
1093 cinit=SALT; *savch++=SALT; sp=stsym(s); --sp->name; cinit=0; return(sp);
1094 }
1095
1096 void
1097 verror(char *fmt, va_list args)
1098 {
1099 if (fnames[ifno][0])
1100 fprintf(stderr, "%s: ", fnames[ifno]);
1101 fprintf(stderr, "%d: ",lineno[ifno]);
1102
1103 (void)vfprintf(stderr, fmt, args);
1104 fputc('\n', stderr);
1105 }
1106
1107 /* VARARGS1 */
1108 void
1109 pperror(char *fmt, ...)
1110 {
1111 va_list args;
1112
1113 va_start(args, fmt);
1114 verror(fmt, args);
1115 va_end(args);
1116
1117 ++exfail;
1118 }
1119
1120 /* VARARGS1 */
1121 void
1122 yyerror(char *fmt, ...)
1123 {
1124 va_list args;
1125
1126 va_start(args, fmt);
1127 verror(fmt, args);
1128 va_end(args);
1129 }
1130
1131 /* VARARGS1 */
1132 static void
1133 ppwarn(char *fmt, ...)
1134 {
1135 va_list args;
1136 int fail = exfail;
1137 exfail = -1;
1138
1139 va_start(args, fmt);
1140 verror(fmt, args);
1141 va_end(args);
1142
1143 exfail = fail;
1144 }
1145
1146 struct symtab *
1147 lookup(namep, enterf)
1148 char *namep;
1149 int enterf;
1150 {
1151 register char *np, *snp;
1152 register int c, i; int around;
1153 register struct symtab *sp;
1154
1155 /* namep had better not be too long (currently, <=symlen chars) */
1156 np=namep; around=0; i=cinit;
1157 while ((c = *np++) != '\0')
1158 i += i+c;
1159 c=i; /* c=i for register usage on pdp11 */
1160 c %= symsiz;
1161 if (c<0)
1162 c += symsiz;
1163 sp = &stab[c];
1164 while ((snp=sp->name) != NULL) {
1165 np = namep;
1166 while (*snp++ == *np)
1167 if (*np++ == '\0') {
1168 if (enterf==DROP) {
1169 sp->name[0]= DROP;
1170 sp->value=0;
1171 }
1172 return(lastsym=sp);
1173 }
1174 if (--sp < &stab[0]) {
1175 if (around) {
1176 pperror("too many defines", 0);
1177 exit(exfail);
1178 } else {
1179 ++around;
1180 sp = &stab[symsiz-1];
1181 }
1182 }
1183 }
1184 if (enterf>0)
1185 sp->name=namep;
1186 return (lastsym=sp);
1187 }
1188
1189 static struct symtab *
1190 slookup(p1,p2,enterf) register char *p1,*p2; int enterf;{
1191 register char *p3; char c2,c3; struct symtab *np;
1192 c2= *p2; *p2='\0'; /* mark end of token */
1193 if ((p2-p1)>symlen)
1194 p3=p1+symlen;
1195 else
1196 p3=p2;
1197 c3= *p3; *p3='\0'; /* truncate to symlen chars or less */
1198 if (enterf==1)
1199 p1=copy(p1);
1200 np=lookup(p1,enterf); *p3=c3; *p2=c2;
1201 if (np->value!=0 && flslvl==0)
1202 newp=subst(p2,np);
1203 else
1204 newp=0;
1205 return(np);
1206 }
1207
1208 static char *
1209 subst(p,sp) register char *p; struct symtab *sp; {
1210 static char match[]="%s: argument mismatch";
1211 register char *ca,*vp; int params;
1212 char *actual[MAXFRM]; /* actual[n] is text of nth actual */
1213 char acttxt[BUFFERSIZ]; /* space for actuals */
1214
1215 if (0==(vp=sp->value)) return(p);
1216 if ((p-macforw)<=macdam) {
1217 if (++maclvl>symsiz && !rflag) {
1218 pperror("%s: macro recursion",sp->name);
1219 return(p);
1220 }
1221 } else {
1222 maclvl=0; /* level decreased */
1223 }
1224 macforw=p; macdam=0; /* new target for decrease in level */
1225 macnam=sp->name;
1226 dump();
1227 if (sp==ulnloc) {
1228 vp=acttxt; *vp++='\0';
1229 sprintf(vp,"%d",lineno[ifno]); while (*vp++);
1230 } else if (sp==uflloc) {
1231 vp=acttxt; *vp++='\0';
1232 sprintf(vp,"\"%s\"",fnames[ifno]); while (*vp++);
1233 }
1234 if (0!=(params= *--vp&0xFF)) {/* definition calls for params */
1235 register char **pa;
1236 ca=acttxt; pa=actual;
1237 if (params==0xFF)
1238 params=1; /* #define foo() ... */
1239 sloscan();
1240 ++flslvl; /* no expansion during search for actuals */
1241 plvl= -1;
1242 do p=skipbl(p); while (*inp=='\n'); /* skip \n too */
1243 if (*inp=='(') {
1244 maclin=lineno[ifno]; macfil=fnames[ifno];
1245 for (plvl=1; plvl!=0; ) {
1246 *ca++='\0';
1247 for (;;) {
1248 outp=inp=p; p=cotoken(p);
1249 if (*inp=='(') ++plvl;
1250 if (*inp==')' && --plvl==0) {
1251 --params;
1252 break;
1253 }
1254 if (plvl==1 && *inp==',') {
1255 --params;
1256 break;
1257 }
1258 while (inp<p) {
1259 /*
1260 * Sun cpp compatibility.
1261 * Needed for kernel assembler
1262 * preprocessing.
1263 * Replace newlines in actual
1264 * macro parameters by spaces.
1265 * Keep escaped newlines, they
1266 * are assumed to be inside a
1267 * string.
1268 */
1269 if (*inp == '\n' &&
1270 inp[-1] != '\\')
1271 *inp = ' ';
1272 *ca++= *inp++;
1273 }
1274 if (ca> &acttxt[BUFFERSIZ])
1275 pperror("%s: actuals too long",
1276 sp->name);
1277 }
1278 if (pa>= &actual[MAXFRM])
1279 ppwarn(match,sp->name);
1280 else
1281 *pa++=ca;
1282 }
1283 }
1284 if (params!=0)
1285 ppwarn(match,sp->name);
1286 while (--params>=0)
1287 *pa++=""+1; /* null string for missing actuals */
1288 --flslvl; fasscan();
1289 }
1290 for (;;) {/* push definition onto front of input stack */
1291 while (!iswarn(*--vp)) {
1292 if (bob(p)) {outp=inp=p; p=unfill(p);}
1293 *--p= *vp;
1294 }
1295 if (*vp==warnc) {/* insert actual param */
1296 ca=actual[*--vp-1];
1297 while (*--ca) {
1298 if (bob(p)) {outp=inp=p; p=unfill(p);}
1299 *--p= *ca;
1300 }
1301 } else break;
1302 }
1303 outp=inp=p;
1304 return(p);
1305 }
1306
1307 static char *
1308 trmdir(s) register char *s; {
1309 register char *p = s;
1310 while (*p++); --p; while (p>s && *--p!='/');
1311 # if unix
1312 if (p==s) *p++='.';
1313 # endif
1314 *p='\0';
1315 return(s);
1316 }
1317
1318 static char *
1319 copy(s) register char *s; {
1320 register char *old;
1321
1322 old = savch; while ((*savch++ = *s++) != '\0');
1323 return(old);
1324 }
1325
1326 static char *
1327 strdex(s,c) char *s,c; {
1328 while (*s) if (*s++==c) return(--s);
1329 return(0);
1330 }
1331
1332 int
1333 yywrap() {
1334 return(1);
1335 }
1336
1337 int
1338 main(argc,argv)
1339 char *argv[];
1340 int argc;
1341 {
1342 register int i,c;
1343 register char *p;
1344 char *tf,**cp2;
1345 char *sysdir = NULL;
1346
1347 fout = stdout; /* Mac OS X is not POSIX compliant (stdout nonconst.) */
1348
1349 p="_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
1350 i=0;
1351 while ((c= *p++) != '\0') {
1352 (fastab+COFF)[c] |= IB|NB|SB;
1353 (toktyp+COFF)[c]=IDENT;
1354 #if scw2
1355 /*
1356 * 53 == 63-10; digits rarely appear in identifiers,
1357 * and can never be the first char of an identifier.
1358 * 11 == 53*53/sizeof(macbit) .
1359 */
1360 ++i; (t21+COFF)[c]=(53*i)/11; (t22+COFF)[c]=i%11;
1361 #endif
1362 }
1363 p="0123456789.";
1364 while ((c = *p++) != '\0') {
1365 (fastab+COFF)[c] |= NB|SB;
1366 (toktyp+COFF)[c]=NUMBR;
1367 }
1368 p="\n\"'/\\";
1369 while ((c = *p++) != '\0')
1370 (fastab+COFF)[c] |= SB;
1371 p="\n\"'\\";
1372 while ((c = *p++) != '\0')
1373 (fastab+COFF)[c] |= QB;
1374 p="*\n";
1375 while ((c = *p++)!= '\0')
1376 (fastab+COFF)[c] |= CB;
1377 (fastab+COFF)[(int)warnc] |= WB;
1378 (fastab+COFF)['\0'] |= CB|QB|SB|WB;
1379 for (i=ALFSIZ; --i>=0; )
1380 slotab[i]=fastab[i]|SB;
1381 p=" \t\013\f\r"; /* note no \n; \v not legal for vertical tab? */
1382 while ((c = *p++) != '\0')
1383 (toktyp+COFF)[c]=BLANK;
1384 #if scw2
1385 for ((t23+COFF)[i=ALFSIZ+7-COFF]=1; --i>=-COFF; )
1386 if (((t23+COFF)[i]=(t23+COFF+1)[i]<<1)==0)
1387 (t23+COFF)[i]=1;
1388 #endif
1389
1390 # if unix
1391 fnames[ifno=0] = "";
1392 dirs[0]=dirnams[0]= ".";
1393 # endif
1394 # if ibm
1395 fnames[ifno=0] = "";
1396 # endif
1397 # if gimpel
1398 fnames[ifno=0] = (char *)inquire(stdin, _FILENAME);
1399 dirnams[0] = dirs[0] = trmdir(copy(fnames[0]));
1400 # endif
1401 for (i=1; i<argc; i++) {
1402 switch(argv[i][0]) {
1403 case '-':
1404 switch(argv[i][1]) {
1405 case 'P':
1406 pflag++;
1407 continue;
1408 case 'E':
1409 continue;
1410 case 'R':
1411 ++rflag;
1412 continue;
1413 case 'C':
1414 passcom++;
1415 continue;
1416 case 'D':
1417 if (predef>prespc+NPREDEF) {
1418 pperror("too many -D options, "
1419 "ignoring %s", argv[i]);
1420 continue;
1421 }
1422 /* ignore plain "-D" (no argument) */
1423 if (*(argv[i]+2))
1424 *predef++ = argv[i]+2;
1425 continue;
1426 case 'U':
1427 if (prund>punspc+NPREDEF) {
1428 pperror("too many -U options, "
1429 "ignoring %s", argv[i]);
1430 continue;
1431 }
1432 *prund++ = argv[i]+2;
1433 continue;
1434 case 'u':
1435 if (strcmp(argv[i], "-undef") == 0)
1436 nopredef = 1;
1437 else
1438 goto unknown;
1439 continue;
1440 case 'I':
1441 if (nd>=MAXIDIRS)
1442 pperror("excessive -I file "
1443 "(%s) ignored", argv[i]);
1444 else
1445 dirs[nd++] = argv[i]+2;
1446 continue;
1447 case 'T':
1448 symlen = 8;
1449 /* Compatibility with V7 */
1450 continue;
1451 case 'H':
1452 /* Print included filenames */
1453 hflag++;
1454 continue;
1455 case 'Y':
1456 /* Replace system include dir */
1457 sysdir = argv[i]+2;
1458 continue;
1459 case '\0': continue;
1460 default:
1461 unknown:
1462 pperror("unknown flag %s", argv[i]);
1463 continue;
1464 }
1465 default:
1466 if (fin == STDIN_FILENO) {
1467 if (0>(fin=open(argv[i], O_RDONLY))) {
1468 pperror("No source file %s",
1469 argv[i]);
1470 exit(8);
1471 }
1472 fnames[ifno]=copy(argv[i]);
1473 dirs[0]=dirnams[ifno]=trmdir(argv[i]);
1474 /* too dangerous to have file name in same syntactic position
1475 be input or output file depending on file redirections,
1476 so force output to stdout, willy-nilly
1477 [i don't see what the problem is. jfr]
1478 */
1479 } else if (fout==stdout) {
1480 static char _sobuff[BUFSIZ];
1481 if (NULL==(fout=fopen(argv[i], "w"))) {
1482 pperror("Can't create %s",
1483 argv[i]);
1484 exit(8);
1485 } else {
1486 fclose(stdout);
1487 setbuf(fout,_sobuff);
1488 }
1489 } else {
1490 pperror("extraneous name %s", argv[i]);
1491 }
1492 }
1493 }
1494
1495 fins[ifno]=fin;
1496 exfail = 0;
1497 /* after user -I files here are the standard include libraries */
1498 if (sysdir != NULL) {
1499 dirs[nd++] = sysdir;
1500 } else {
1501 # if unix
1502 dirs[nd++] = "/usr/include";
1503 # endif
1504 /* dirs[nd++] = "/compool"; */
1505 }
1506 dirs[nd++] = 0;
1507 defloc=ppsym("define");
1508 udfloc=ppsym("undef");
1509 incloc=ppsym("include");
1510 elsloc=ppsym("else");
1511 eifloc=ppsym("endif");
1512 elifloc=ppsym("elif");
1513 ifdloc=ppsym("ifdef");
1514 ifnloc=ppsym("ifndef");
1515 ifloc=ppsym("if");
1516 lneloc=ppsym("line");
1517 idtloc=ppsym("ident");
1518 pragmaloc=ppsym("pragma");
1519 errorloc=ppsym("error");
1520 for (i=sizeof(macbit)/sizeof(macbit[0]); --i>=0; )
1521 macbit[i]=0;
1522
1523 if (! nopredef) {
1524 # if unix
1525 ysysloc=stsym("unix");
1526 # endif
1527 # if __sparc__
1528 varloc=stsym ("sparc");
1529 # endif
1530 # if __i386__
1531 varloc=stsym ("i386");
1532 # endif
1533 }
1534 ulnloc=stsym ("__LINE__");
1535 uflloc=stsym ("__FILE__");
1536 varloc=stsym ("__BUILTIN_VA_ARG_INCR");
1537
1538 tf=fnames[ifno]; fnames[ifno]="command line"; lineno[ifno]=1;
1539 cp2=prespc;
1540 while (cp2<predef) stsym(*cp2++);
1541 cp2=punspc;
1542 while (cp2<prund) {
1543 if ((p=strdex(*cp2, '=')) != NULL) *p++='\0';
1544 if (strlen(*cp2) > symlen)
1545 (*cp2)[symlen] = '\0';
1546 lookup(*cp2++, DROP);
1547 }
1548 fnames[ifno]=tf;
1549 pbeg=buffer+symlen; pbuf=pbeg+BUFFERSIZ; pend=pbuf+BUFFERSIZ;
1550
1551 trulvl = 0; flslvl = 0;
1552 lineno[0] = 1; sayline(NOINCLUDE);
1553 outp=inp=pend;
1554 control(pend);
1555 return (exfail);
1556 }