![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cpp|
Return to cpp.c CVS log | Up to [Research Unix] / researchv10no / cmd / cpp |
1.1 root 1: /*#ident "@(#)cpp:common/cpp.c 1.44" */
2:
3:
4: #ifdef FLEXNAMES
5: # define NCPS 128
6: #else
7: # define NCPS 8
8: #endif
9: int ncps = NCPS; /* default name length */
10:
11: # include <stdio.h>
12: # include <ctype.h>
13: # include <libc.h>
14: # include <sys/types.h> /* needed by stat.h */
15: # include <sys/stat.h> /* needed by option -M */
16: /* C command - C preprocessor */
17:
18: /*
19: * See if necessary defines are given
20: */
21: #if !defined( PD_MACH ) || !defined( PD_SYS )
22: # include "*** Must define PD_MACH and PD_SYS ***"
23: #endif
24: /*
25: * These defines are used to enter new machines and/or systems
26: * to the two lists. To create a new instance of cpp in a cross
27: * compilation environment, set PD_MY_MACH=\"your-new-machine\"
28: * and/or PD_MY_SYS=\"your-new-os\" and set PD_MACH=MAX_PD_MACH
29: * and PD_SYS=MAX_PD_SYS.
30: */
31: #ifndef PD_MY_MACH
32: # define PD_MY_MACH 0
33: #endif
34: #ifndef PD_MY_SYS
35: # define PD_MY_SYS 0
36: #endif
37:
38: #define STATIC
39:
40: #define STDIN 0
41: #define STDOUT 1
42: #define STDERR 2
43:
44: #define CLASSCODE 27 /* exit status if #class seen */
45:
46: #define READ "r"
47: #define WRITE "w"
48: #define SALT '#'
49:
50: #ifndef BUFSIZ
51: # define BUFSIZ 512
52: #endif
53:
54: char *pbeg, *pbuf, *pend;
55: char *outp, *inp;
56: char *newp;
57: char cinit;
58:
59: #ifdef CXREF
60: char *xcopy();
61: FILE *outfp;
62: static int ready = 0;
63: int xline;
64: #endif
65:
66: /* some code depends on whether characters are sign or zero extended */
67: /* #if '\377' < 0 not used here, old cpp doesn't understand */
68: #if pdp11 | vax
69: # define COFF 128
70: #else
71: # define COFF 0
72: #endif
73:
74: # if gcos
75: # define ALFSIZ 512 /* alphabet size */
76: # else
77: # define ALFSIZ 256 /* alphabet size */
78: # endif
79: char macbit[ ALFSIZ + 11 ];
80: char toktyp[ ALFSIZ ];
81: #define BLANK 1
82: #define IDENT 2
83: #define NUMBR 3
84:
85: /* a superimposed code is used to reduce the number of calls to the
86: /* symbol table lookup routine. (if the kth character of an identifier
87: /* is 'a' and there are no macro names whose kth character is 'a'
88: /* then the identifier cannot be a macro name, hence there is no need
89: /* to look in the symbol table.) 'scw1' enables the test based on
90: /* single characters and their position in the identifier. 'scw2'
91: /* enables the test based on adjacent pairs of characters and their
92: /* position in the identifier. scw1 typically costs 1 indexed fetch,
93: /* an AND, and a jump per character of identifier, until the identifier
94: /* is known as a non-macro name or until the end of the identifier.
95: /* scw1 is inexpensive. scw2 typically costs 4 indexed fetches,
96: /* an add, an AND, and a jump per character of identifier, but it is also
97: /* slightly more effective at reducing symbol table searches.
98: /* scw2 usually costs too much because the symbol table search is
99: /* usually short; but if symbol table search should become expensive,
100: /* the code is here.
101: /* using both scw1 and scw2 is of dubious value.
102: */
103: #define scw1 1
104: #define scw2 0
105:
106: #if scw2
107: char t21[ ALFSIZ ], t22[ ALFSIZ ], t23[ ALFSIZ + NCPS ];
108: #endif
109:
110: #if scw1
111: # define b0 1
112: # define b1 2
113: # define b2 4
114: # define b3 8
115: # define b4 16
116: # define b5 32
117: # define b6 64
118: # define b7 128
119: #endif
120:
121: #define IB 1
122: #define SB 2
123: #define NB 4
124: #define CB 8
125: #define QB 16
126: #define WB 32
127: char fastab[ ALFSIZ ];
128: char slotab[ ALFSIZ ];
129: char *ptrtab;
130: #define isslo ( ptrtab == ( slotab + COFF ) )
131: #define isid(a) ( ( fastab + COFF )[a] & IB )
132: #define isspc(a) ( ptrtab[a] & SB )
133: #define isnum(a) ( ( fastab + COFF )[a] & NB )
134: #define iscom(a) ( ( fastab + COFF )[a] & CB )
135: #define isquo(a) ( ( fastab + COFF )[a] & QB )
136: #define iswarn(a) ( ( fastab + COFF )[a] & WB )
137:
138: #define eob(a) ( ( a ) >= pend )
139: #define bob(a) ( pbeg >= ( a ) )
140:
141: char buffer[ NCPS + BUFSIZ + BUFSIZ + NCPS ];
142:
143: # define MAXNEST 12 /* max number of nested #include's */
144: # define MAXFRE 14 /* max buffers of macro pushback */
145:
146: #ifdef pdp11
147: # define SBSIZE 24000
148: #else
149: /* The idea here is to define the buffer to have a certain size
150: ** (the literal number) plus enough room for slop and taking side buffers
151: ** out to hold processing interrupted by #include's. The cost of side
152: ** buffers is particularly noticable on an Amdahl, where BUFSIZ is 4096.
153: */
154: # define SBSIZE (21000 + (MAXFRE+1)*BUFSIZ)
155: #endif
156:
157: char sbf[ SBSIZE ];
158: char *savch = sbf;
159:
160: # define DROP '\376' /* special character not legal ASCII or EBCDIC */
161: # define WARN DROP
162: # define SAME 0
163: # define MAXINC 100 /* max number of directories for -I options */
164: # define MAXFRM 31 /* max number of formals/actuals to a macro */
165:
166: static char warnc = WARN;
167:
168: int mactop, fretop;
169: char *instack[ MAXFRE ], *bufstack[ MAXFRE ], *endbuf[ MAXFRE ];
170:
171: int plvl; /* parenthesis level during scan for macro actuals */
172: int maclin; /* line number of macro call requiring actuals */
173: char *macfil; /* file name of macro call requiring actuals */
174: char *macnam; /* name of macro requiring actuals */
175: int maclvl; /* # calls since last decrease in nesting level */
176: char *macforw; /* pointer which must be exceeded to decrease nesting level */
177: int macdam; /* offset to macforw due to buffer shifting */
178:
179: #if tgp
180: int tgpscan; /* flag for dump(); */
181: #endif
182:
183: STATIC int inctop[ MAXNEST ];
184: STATIC char *fnames[ MAXNEST ];
185: STATIC char *fdates[ MAXNEST ]; /* for -M option */
186: STATIC char *dirnams[ MAXNEST ]; /* actual directory of #include files */
187: STATIC FILE *fins[ MAXNEST ];
188: STATIC int lineno[ MAXNEST ];
189:
190: STATIC char *dirs[ MAXINC ]; /* -I and <> directories */
191: STATIC char *dfltdir = (char *) 0; /* user-supplied default (like /usr/include) */
192: char *copy(), *subst(), *trmdir(), *strchr();
193: char *chkend(), *getfdate(), *findfdate();
194: struct symtab *stsym();
195: STATIC FILE *fin = stdin;
196: STATIC FILE *fout = stdout;
197: STATIC int nd = 1;
198: STATIC int pflag; /* don't put out lines "# 12 foo.c" */
199: STATIC int mflag;
200: STATIC int passcom; /* don't delete comments */
201: STATIC int incomm; /* set while in comment so that EOF can be detected */
202: STATIC int rflag; /* allow macro recursion */
203: STATIC int print_incs; /* set to print out included filenames */
204: STATIC int ifno;
205: # define NPREDEF 20
206: STATIC char *prespc[ NPREDEF ];
207: STATIC char **predef = prespc;
208: STATIC char *punspc[ NPREDEF ];
209: STATIC char **prund = punspc;
210: STATIC int exfail;
211: struct symtab
212: {
213: char *name;
214: char *value;
215: } *lastsym, *lookup(), *slookup();
216:
217: # if gcos
218: # include <setjmp.h>
219: static jmp_buf env;
220: # define main mainpp
221: # undef exit
222: # define exit(S) longjmp(env, 1)
223: # define symsiz 500
224: # define LINEFORM "# %d %s\n"
225: # define ERRFORM "*%c* %s, line "
226: # else
227: # define symsiz 2000
228: # define LINEFORM "# %d \"%s%s\"\n"
229: # define ERRFORM "*%c* \"%s%s\", line "
230: # endif
231: STATIC struct symtab stab[ symsiz ];
232:
233: STATIC struct symtab *defloc;
234: STATIC struct symtab *udfloc;
235: STATIC struct symtab *incloc;
236: STATIC struct symtab *ifloc;
237: STATIC struct symtab *elsloc;
238: STATIC struct symtab *eifloc;
239: STATIC struct symtab *elifloc;
240: STATIC struct symtab *ifdloc;
241: STATIC struct symtab *ifnloc;
242: STATIC struct symtab *ysysloc;
243: STATIC struct symtab *varloc;
244: STATIC struct symtab *lneloc;
245: STATIC struct symtab *ulnloc;
246: STATIC struct symtab *uflloc;
247: STATIC struct symtab *clsloc;
248: STATIC struct symtab *idtloc;
249: STATIC struct symtab *pragmaloc;
250: STATIC int trulvl;
251: STATIC int flslvl;
252: #define MAX_DEPTH 500 /* max of trulvl + flslvl */
253: #define SEEN_ELSE 0x1
254: #define TRUE_ELIF 0x2
255: STATIC char ifelstk[MAX_DEPTH];
256:
257: /*
258: * To facilitate the handling of different cpp's and cross cpp's,
259: * the sets of mutually exclusive predefined are placed into lists.
260: * The value used from these lists are set when building from the
261: * command line.
262: */
263: #define MAX_PD_MACH 13 /* set so it is where PD_MY_MACH is at */
264: #define D_tss 0 /*define table indexes */
265: #define D_os 1
266: #define D_mert 2
267: #define D_RT 3
268: #define D_RES 4
269: #define D_interdata 5
270: #define D_pdp11 6
271: #define D_vax 7
272: #define D_u370 8
273: #define D_u3b 9
274: #define D_u3b5 10
275: #define D_u3b2 11
276: #define D_u3b20d 12
277: #define D_newmach MAX_PD_MACH
278: #define D_nomach MAX_PD_MACH
279:
280: char *pdef_mach[MAX_PD_MACH+2] = /* choose using PD_MACH */
281: {
282: /*
283: * The following are ``machines'' for historical reasons only.
284: */
285: "tss", "os", "mert",
286: "RT", "RES",
287: /* These are the currently supported machines */
288: "interdata", "pdp11", "vax",
289: "u370", "u3b", "u3b5",
290: "u3b2", "u3b20d",
291: PD_MY_MACH, /* for adding "own" machine */
292: 0
293: };
294:
295: #define MAX_PD_SYS 4 /* set so that it is where PD_MY_SYS is at */
296: #define D_unix 0
297: #define D_gcos 1
298: #define D_ibm 2
299: #define D_DMERT 3
300: #define D_newsys MAX_PD_SYS
301: #define D_nosys MAX_PD_SYS
302:
303: char *pdef_sys[MAX_PD_SYS+2] = /* choose using PD_SYS */
304: {
305: "unix",
306: "gcos",
307: "ibm",
308: "DMERT",
309: PD_MY_SYS, /* for adding "own" system */
310: 0
311: };
312: #if PD_MACH < 0 || PD_MACH > MAX_PD_MACH
313: # include "*** PD_MACH set illegally ***"
314: #endif
315: #if PD_SYS < 0 || PD_SYS > MAX_PD_SYS
316: # include "*** PD_SYS set illegally ***"
317: #endif
318:
319:
320:
321: sayline()
322: {
323: if ( pflag == 0 )
324: fprintf( fout, LINEFORM, lineno[ifno], fnames[ifno] ,fdates[ifno] );
325: }
326:
327: /* data structure guide
328: /*
329: /* most of the scanning takes place in the buffer:
330: /*
331: /* (low address) (high address)
332: /* pbeg pbuf pend
333: /* | <-- BUFSIZ chars --> | <-- BUFSIZ chars --> |
334: /* _______________________________________________________________________
335: /* |_______________________________________________________________________|
336: /* | | |
337: /* |<-- waiting -->| |<-- waiting -->
338: /* | to be |<-- current -->| to be
339: /* | written | token | scanned
340: /* | | |
341: /* outp inp p
342: /*
343: /* *outp first char not yet written to output file
344: /* *inp first char of current token
345: /* *p first char not yet scanned
346: /*
347: /* macro expansion: write from *outp to *inp (chars waiting to be written),
348: /* ignore from *inp to *p (chars of the macro call), place generated
349: /* characters in front of *p (in reverse order), update pointers,
350: /* resume scanning.
351: /*
352: /* symbol table pointers point to just beyond the end of macro definitions;
353: /* the first preceding character is the number of formal parameters.
354: /* the appearance of a formal in the body of a definition is marked by
355: /* 2 chars: the char WARN, and a char containing the parameter number.
356: /* the first char of a definition is preceded by a zero character.
357: /*
358: /* when macro expansion attempts to back up over the beginning of the
359: /* buffer, some characters preceding *pend are saved in a side buffer,
360: /* the address of the side buffer is put on 'instack', and the rest
361: /* of the main buffer is moved to the right. the end of the saved buffer
362: /* is kept in 'endbuf' since there may be nulls in the saved buffer.
363: /*
364: /* similar action is taken when an 'include' statement is processed,
365: /* except that the main buffer must be completely emptied. the array
366: /* element 'inctop[ifno]' records the last side buffer saved when
367: /* file 'ifno' was included. these buffers remain dormant while
368: /* the file is being read, and are reactivated at end-of-file.
369: /*
370: /* instack[0 : mactop] holds the addresses of all pending side buffers.
371: /* instack[inctop[ifno]+1 : mactop-1] holds the addresses of the side
372: /* buffers which are "live"; the side buffers instack[0 : inctop[ifno]]
373: /* are dormant, waiting for end-of-file on the current file.
374: /*
375: /* space for side buffers is obtained from 'savch' and is never returned.
376: /* bufstack[0:fretop-1] holds addresses of side buffers which
377: /* are available for use.
378: */
379:
380: dump()
381: {
382: /* write part of buffer which lies between outp and inp .
383: /* this should be a direct call to 'write', but the system slows
384: /* to a crawl if it has to do an unaligned copy. thus we buffer.
385: /*? this silly loop is 15% of the total time, thus even the 'putc'
386: /*? macro is too slow.
387: */
388: register char *p1;
389: register FILE *f;
390: #if tgp
391: register char *p2;
392: #endif
393:
394: if ( ( p1 = outp ) == inp || flslvl != 0 )
395: return;
396: #if tgp
397: # define MAXOUT 80
398: if ( !tgpscan ) /* scan again to insure <= MAXOUT
399: { /* chars between linefeeds */
400: register char c, *pblank;
401: char savc, stopc, brk;
402:
403: tgpscan = 1;
404: brk = stopc = pblank = 0;
405: p2 = inp;
406: savc = *p2;
407: *p2 = '\0';
408: while ( c = *p1++ )
409: {
410: if ( c == '\\' )
411: c = *p1++;
412: if ( stopc == c )
413: stopc = 0;
414: else if ( c == '"' || c == '\'' )
415: stopc = c;
416: if ( p1 - outp > MAXOUT && pblank != 0 )
417: {
418: *pblank++ = '\n';
419: inp = pblank;
420: dump();
421: brk = 1;
422: pblank = 0;
423: }
424: if ( c == ' ' && stopc == 0 )
425: pblank = p1 - 1;
426: }
427: if ( brk )
428: sayline();
429: *p2 = savc;
430: inp = p2;
431: p1 = outp;
432: tgpscan = 0;
433: }
434: #endif
435: f = fout;
436: # if gcos
437: /* filter out "$ program c" card if first line of input */
438: /* gmatch is a simple pattern matcher in the GCOS Standard Library */
439: {
440: static int gmfirst = 0;
441:
442: if ( !gmfirst )
443: {
444: ++gmfirst;
445: if ( gmatch( p1, "^$*program[ \t]*c*") )
446: p1 = strchr( p1, '\n' );
447: }
448: }
449: # endif
450: while (p1 < inp)
451: putc(*p1++, f);
452: outp = p1;
453: }
454:
455: char *
456: refill( p )
457: register char *p;
458: {
459: /* dump buffer. save chars from inp to p. read into buffer at pbuf,
460: /* contiguous with p. update pointers, return new p.
461: */
462: register char *np, *op;
463: register int ninbuf;
464:
465: dump();
466: /* slide current token to left of pbuf */
467: ninbuf = p - inp;
468: np = pbuf - ninbuf;
469: if ( bob( np + 1 ) )
470: {
471: pperror( "token too long" );
472: np = pbeg;
473: p = inp + BUFSIZ;
474: }
475: macdam += np - inp;
476: memcpy(np, inp, ninbuf);
477: p = np + ninbuf; /* usually pbuf - ninbuf */
478: outp = inp = np;
479: for ( ;; )
480: {
481: /* retrieve hunk of pushed-back macro text */
482: if ( mactop > inctop[ifno] )
483: {
484: op = instack[ --mactop ];
485: memcpy(pbuf, op, endbuf[mactop] - op);
486: pend = pbuf + (endbuf[mactop] - op) - 1;
487: /* make buffer space avail for 'include' processing */
488: if ( fretop < MAXFRE )
489: bufstack[fretop++] = instack[mactop];
490: return( p );
491: }
492: else /* get more text from file(s) */
493: {
494: maclvl = 0;
495: #if NOTDEF
496: if ( 0 < ( ninbuf = fread( pbuf, sizeof( char ), BUFSIZ, fin ) ) )
497: {
498: #else
499: /*
500: * very much faster, but don't remove stdio completely for now
501: * in vague search for compatibility
502: */
503: if ((ninbuf = read(fileno(fin), pbuf, BUFSIZ)) > 0) {
504: #endif
505: pend = pbuf + ninbuf;
506: *pend = '\0';
507: return( p );
508: }
509: /* end of #include file */
510: if ( ifno == 0 ) /* end of input */
511: {
512: if ( plvl != 0 )
513: {
514: int n = plvl, tlin = lineno[ifno];
515: char *tfil = fnames[ifno];
516:
517: lineno[ifno] = maclin;
518: fnames[ifno] = macfil;
519: pperror( "%s: unterminated macro call",
520: macnam );
521: lineno[ifno] = tlin;
522: fnames[ifno] = tfil;
523: np = p;
524: /*shut off unterminated quoted string*/
525: *np++ = '\n';
526: /* supply missing parens */
527: while ( --n >= 0 )
528: *np++ = ')';
529: pend = np;
530: *np = '\0';
531: if ( plvl < 0 )
532: plvl = 0;
533: return( p );
534: }
535: if ( incomm ) {
536: pperror( "Unexpected EOF in comment" );
537: /* undo flslvl bump when comment started */
538: if (flslvl) --flslvl;
539: }
540: if ( trulvl +flslvl > 0 )
541: pperror( "Unexpected EOF within #if, #ifdef or #ifndef" );
542: inp = p;
543: dump();
544: if ( fout && ferror( fout ) )
545: pperror( "Problems with writing output file; probably out of temp space" );
546: exit( exfail ? ( exfail ==
547: CLASSCODE ? CLASSCODE : 2 ) : 0 );
548: }
549: fclose( fin );
550: fin = fins[--ifno];
551: dirs[0] = dirnams[ifno];
552: sayline();
553: #ifdef CXREF
554: fprintf(outfp, "\"%s\"\n", fnames[ifno]);
555: #endif
556: }
557: }
558: }
559:
560: #define BEG 0
561: #define LF 1
562:
563: char *
564: cotoken( p )
565: register char *p;
566: {
567: register int c, i;
568: char quoc;
569: static int state = BEG;
570: static int speakup = 0;
571:
572: if ( state != BEG )
573: goto prevlf;
574: for ( ;; )
575: {
576: again:
577: while ( !isspc( c = *p++ ) )
578: ;
579: inp = p - 1;
580: switch ( c )
581: {
582: case 0:
583: if ( eob( --p ) )
584: {
585: p = refill( p );
586: goto again;
587: }
588: else
589: ++p; /* ignore null byte */
590: break;
591: case '|':
592: case '&':
593: for ( ;; ) /* sloscan only */
594: {
595: if ( *p++ == *inp )
596: break;
597: if ( eob( --p ) )
598: p = refill( p );
599: else
600: break;
601: }
602: break;
603: case '=':
604: case '!':
605: for ( ;; ) /* sloscan only */
606: {
607: if ( *p++ == '=' )
608: break;
609: if ( eob( --p ) )
610: p = refill( p );
611: else
612: break;
613: }
614: break;
615: case '<':
616: case '>':
617: for ( ;; ) /* sloscan only */
618: {
619: if ( *p++ == '=' || p[-2] == p[-1] )
620: break;
621: if ( eob( --p ) )
622: p = refill( p );
623: else
624: break;
625: }
626: break;
627: case '\\':
628: for ( ;; )
629: {
630: if ( *p++ == '\n' )
631: {
632: ++lineno[ifno];
633: break;
634: }
635: if ( eob( --p ) )
636: p = refill( p );
637: else
638: {
639: ++p;
640: break;
641: }
642: }
643: break;
644: case '/':
645: for ( ;; )
646: {
647: if ( *p++ == '*' ) /* comment */
648: {
649: incomm = 1;
650: if ( !passcom )
651: {
652: inp = p - 2;
653: dump();
654: ++flslvl;
655: }
656: for ( ;; )
657: {
658: while ( !iscom( *p++ ) )
659: ;
660: if ( p[-1] == '*' )
661: for ( ;; )
662: {
663: if ( *p++ == '/' )
664: goto endcom;
665: if ( eob( --p ) )
666: {
667: if ( !passcom )
668: {
669: inp = p;
670: p = refill( p );
671: }
672: /* split long comment */
673: else if ( ( p - inp ) >= BUFSIZ )
674: {
675: *p++ = '*';
676: *p++ = '/';
677: inp = p;
678: p = refill( p );
679: outp = inp = p -= 2;
680: *p++ = '/';
681: *p++ = '*';
682: }
683: else
684: p = refill( p );
685: }
686: else
687: break;
688: }
689: else if ( p[-1] == '\n' )
690: {
691: ++lineno[ifno];
692: if ( !passcom && flslvl <= 1 )
693: putc( '\n', fout );
694: }
695: else if ( eob( --p ) )
696: {
697: if ( !passcom )
698: {
699: inp = p;
700: p = refill( p );
701: }
702: /* split long comment */
703: else if ( ( p - inp ) >= BUFSIZ )
704: {
705: *p++ = '*';
706: *p++ = '/';
707: inp = p;
708: p = refill( p );
709: outp = inp = p -= 2;
710: *p++ = '/';
711: *p++ = '*';
712: }
713: else
714: p = refill( p );
715: }
716: else
717: ++p; /* ignore null byte */
718: }
719: endcom:
720: incomm = 0;
721: if ( !passcom )
722: {
723: outp = inp = p;
724: --flslvl;
725: goto again;
726: }
727: break;
728: }
729: if ( eob( --p ) )
730: p = refill( p );
731: else
732: break;
733: }
734: break;
735: # if gcos
736: case '`':
737: # endif
738: case '"':
739: case '\'':
740: quoc = p[-1];
741: for ( ;; )
742: {
743: while ( !isquo( *p++ ) )
744: ;
745: if ( p[-1] == quoc )
746: break;
747: if ( p[-1] == '\n' ) /* bare \n terminates quotation */
748: {
749: --p;
750: break;
751: }
752: if ( p[-1] == '\\' )
753: for ( ;; )
754: {
755: if ( *p++ == '\n' ) /* escaped \n ignored */
756: {
757: ++lineno[ifno];
758: break;
759: }
760: if ( eob( --p ) )
761: p = refill( p );
762: else
763: {
764: ++p;
765: break;
766: }
767: }
768: else if ( eob( --p ) )
769: p = refill( p );
770: else
771: ++p; /* it was a different quote character */
772: }
773: break;
774: case WARN:
775: {
776: int ii;
777:
778: dump();
779: speakup = 0;
780: for ( ii = sizeof(int) / sizeof(char); --ii >= 0; )
781: {
782: if ( eob( p ) )
783: p = refill( p );
784: speakup |= ( *p++ & 0xFF ) << ( ii * 8 );
785: }
786: inp = outp = p;
787: break;
788: }
789: case '\n':
790: ++lineno[ifno];
791: if ( isslo )
792: {
793: state=LF;
794: return( p );
795: }
796: prevlf:
797: if ( speakup )
798: {
799: inp = p;
800: dump();
801: lineno[ifno] = speakup + 1;
802: sayline();
803: speakup = 0;
804: }
805: state = BEG;
806: for ( ;; )
807: {
808: /*
809: * ignore formfeeds and vertical tabs
810: * which may be just before the SALT
811: */
812: #if NOTDEF
813: if ( *p == '\f' || *p == '\v' )
814: {
815: register char *s = p;
816:
817: while ( *++s == '\f' || *s == '\v' )
818: ;
819: if ( *s == SALT )
820: {
821: /*
822: * get the SALT to the front!
823: */
824: *s = *p;
825: *p = SALT;
826: }
827: }
828: #endif
829: if ( *p++ == SALT )
830: return( p );
831: if ( eob( inp = --p ) )
832: p = refill( p );
833: else
834: goto again;
835: }
836: case '0': case '1': case '2': case '3': case '4':
837: case '5': case '6': case '7': case '8': case '9':
838: for ( ;; )
839: {
840: while ( isnum( *p++ ) )
841: ;
842: if ( eob( --p ) )
843: p = refill( p );
844: else
845: break;
846: }
847: break;
848: case 'A': case 'B': case 'C': case 'D': case 'E':
849: case 'F': case 'G': case 'H': case 'I': case 'J':
850: case 'K': case 'L': case 'M': case 'N': case 'O':
851: case 'P': case 'Q': case 'R': case 'S': case 'T':
852: case 'U': case 'V': case 'W': case 'X': case 'Y':
853: case 'Z': case '_':
854: case 'a': case 'b': case 'c': case 'd': case 'e':
855: case 'f': case 'g': case 'h': case 'i': case 'j':
856: case 'k': case 'l': case 'm': case 'n': case 'o':
857: case 'p': case 'q': case 'r': case 's': case 't':
858: case 'u': case 'v': case 'w': case 'x': case 'y':
859: case 'z':
860: #if scw1
861: # define tmac1( c, bit ) if ( !xmac1( c, bit, & ) ) \
862: goto nomac
863: # define xmac1( c, bit, op ) ( ( macbit + COFF )[c] op ( bit ) )
864: #else
865: # define tmac1( c, bit )
866: # define xmac1( c, bit, op )
867: #endif
868:
869: #if scw2
870: # define tmac2( c0, c1, cpos ) if ( !xmac2( c0, c1, cpos, & ) ) \
871: goto nomac
872: # define xmac2( c0, c1, cpos, op ) \
873: ( ( macbit + COFF )[ ( t21 + COFF )[c0] + \
874: ( t22 + COFF )[c1]] op ( t23 + COFF + cpos )[c0] )
875: #else
876: # define tmac2( c0, c1, cpos )
877: # define xmac2( c0, c1, cpos, op )
878: #endif
879:
880: if ( flslvl )
881: goto nomac;
882: for ( ;; )
883: {
884: c = p[-1];
885: tmac1( c, b0 );
886: i = *p++;
887: if ( !isid( i ) )
888: goto endid;
889: tmac1( i, b1 );
890: tmac2( c, i, 0 );
891: c = *p++;
892: if ( !isid( c ) )
893: goto endid;
894: tmac1( c, b2 );
895: tmac2( i, c, 1 );
896: i = *p++;
897: if ( !isid( i ) )
898: goto endid;
899: tmac1( i, b3 );
900: tmac2( c, i, 2 );
901: c = *p++;
902: if ( !isid( c ) )
903: goto endid;
904: tmac1( c, b4 );
905: tmac2( i, c, 3 );
906: i = *p++;
907: if ( !isid( i ) )
908: goto endid;
909: tmac1( i, b5 );
910: tmac2( c, i, 4 );
911: c = *p++;
912: if ( !isid( c ) )
913: goto endid;
914: tmac1( c, b6 );
915: tmac2( i, c, 5 );
916: i = *p++;
917: if ( !isid( i ) )
918: goto endid;
919: tmac1( i, b7 );
920: tmac2( c, i, 6 );
921: tmac2( i, 0, 7 );
922: while ( isid( *p++ ) )
923: ;
924: if ( eob( --p ) )
925: {
926: refill( p );
927: p = inp + 1;
928: continue;
929: }
930: goto lokid;
931: endid:
932: if ( eob( --p ) )
933: {
934: refill( p );
935: p = inp + 1;
936: continue;
937: }
938: tmac2( p[-1], 0, -1 + ( p - inp ) );
939: lokid:
940: slookup( inp, p, 0 );
941: if ( newp )
942: {
943: p = newp;
944: goto again;
945: }
946: else
947: break;
948: nomac:
949: while ( isid( *p++ ) )
950: ;
951: if ( eob( --p ) )
952: {
953: p = refill( p );
954: goto nomac;
955: }
956: else
957: break;
958: }
959: break;
960: } /* end of switch */
961:
962: if ( isslo )
963: return( p );
964: } /* end of infinite loop */
965: }
966:
967: char *
968: skipbl( p ) /* get next non-blank token */
969: register char *p;
970: {
971: do
972: {
973: outp = inp = p;
974: p = cotoken( p );
975: }
976: while ( ( toktyp + COFF )[*inp] == BLANK );
977: return( p );
978: }
979:
980: char *
981: unfill( p )
982: register char *p;
983: {
984: /* take <= BUFSIZ chars from right end of buffer and put
985: /* them on instack. slide rest of buffer to the right,
986: /* update pointers, return new p.
987: */
988: register char *np, *op;
989: register int d;
990:
991: if ( mactop >= MAXFRE )
992: {
993: pperror( "%s: too much pushback", macnam );
994: p = inp = pend; /* begin flushing pushback */
995: dump();
996: while ( mactop > inctop[ifno] )
997: {
998: (void) refill( p );
999: p = inp = pend;
1000: dump();
1001: }
1002: }
1003: if ( fretop > 0 )
1004: np = bufstack[--fretop];
1005: else
1006: {
1007: np = savch;
1008: savch += BUFSIZ;
1009: if ( savch >= sbf + SBSIZE )
1010: {
1011: pperror( "no space" );
1012: exit( exfail ? ( exfail == CLASSCODE ? CLASSCODE : 2 )
1013: : 0 );
1014: }
1015: *savch++ = '\0';
1016: }
1017: instack[mactop] = np;
1018: op = pend - BUFSIZ;
1019: if ( op < p )
1020: op = p;
1021: memcpy(np, op, pend - op);
1022: np += pend - op;
1023: *np++ = 0;
1024: endbuf[mactop++] = np; /* mark end of saved text */
1025: np = pbuf + BUFSIZ;
1026: op = pend - BUFSIZ;
1027: pend = np;
1028: if ( op < p )
1029: op = p;
1030: while ( outp < op ) /* slide over new */
1031: *--np = *--op;
1032: if ( bob( np ) )
1033: pperror( "token too long" );
1034: d = np - outp;
1035: outp += d;
1036: inp += d;
1037: macdam += d;
1038: return( p + d );
1039: }
1040:
1041: char *
1042: doincl( p )
1043: register char *p;
1044: {
1045: int filok, inctype;
1046: register char *cp;
1047: char **dirp, *nfil;
1048: char filname[BUFSIZ];
1049:
1050: p = skipbl( p );
1051: cp = filname;
1052: if ( *inp++ == '<' ) /* special <> syntax */
1053: {
1054: inctype = 1;
1055: ++flslvl; /* prevent macro expansion */
1056: for ( ;; )
1057: {
1058: outp = inp = p;
1059: p = cotoken( p );
1060: if ( *inp == '\n' )
1061: {
1062: --p;
1063: *cp = '\0';
1064: break;
1065: }
1066: if ( *inp == '>' )
1067: {
1068: *cp = '\0';
1069: break;
1070: }
1071: # ifdef gimpel
1072: if ( *inp == '.' && !intss() )
1073: *inp = '#';
1074: # endif
1075: while ( inp < p )
1076: *cp++ = *inp++;
1077: }
1078: --flslvl; /* reenable macro expansion */
1079: }
1080: else if ( inp[-1] == '"' ) /* regular "" syntax */
1081: {
1082: inctype = 0;
1083: # ifdef gimpel
1084: while ( inp < p )
1085: {
1086: if ( *inp == '.' && !intss() )
1087: *inp = '#';
1088: *cp++ = *inp++;
1089: }
1090: # else
1091: while ( inp < p )
1092: *cp++ = *inp++;
1093: # endif
1094: if ( *--cp == '"' )
1095: *cp = '\0';
1096: }
1097: else
1098: {
1099: int ppwarn(), pperror();
1100: /* This is a warning if we're skipping, error if not. */
1101: (*(flslvl ? ppwarn : pperror))( "bad include syntax", 0 );
1102: inctype = 2;
1103: }
1104: /* flush current file to \n , then write \n */
1105:
1106: p = chkend( p, 1 );
1107:
1108: outp = inp = p;
1109:
1110: dump();
1111: if ( inctype == 2 || flslvl != 0 )
1112: return( p );
1113: /* look for included file */
1114: if ( ifno + 1 >= MAXNEST )
1115: {
1116: pperror( "Unreasonable include nesting", 0 );
1117: return( p );
1118: }
1119: if ( ( nfil = savch ) > sbf + SBSIZE - BUFSIZ )
1120: {
1121: pperror( "no space" );
1122: exit( exfail ? ( exfail == CLASSCODE ? CLASSCODE : 2 ) : 0 );
1123: }
1124:
1125: /* check for #include "/usr/include/..." */
1126: if (strncmp(filname, "/usr/include/", 13) == 0)
1127: ppwarn("#include of /usr/include/... may be non-portable");
1128:
1129: filok = 0;
1130: for ( dirp = dirs + inctype; *dirp; ++dirp )
1131: {
1132: if (
1133: # if gcos
1134: strchr( filname, '/' )
1135: # else
1136: filname[0] == '/'
1137: # endif
1138: || **dirp == '\0' )
1139: {
1140: strcpy( nfil, filname );
1141: }
1142: else
1143: {
1144: strcpy( nfil, *dirp );
1145: # if unix || gcos || DMERT
1146: strcat( nfil, "/" );
1147: # endif
1148: #ifdef ibm
1149: # ifndef gimpel
1150: strcat( nfil, "." );
1151: # endif
1152: #endif
1153: strcat( nfil, filname );
1154: }
1155: if ( NULL != ( fins[ifno + 1] = fopen( nfil, READ ) ) )
1156: {
1157: filok = 1;
1158: fin = fins[++ifno];
1159: if ( print_incs )
1160: fprintf( stderr, "%s\n", nfil );
1161: break;
1162: }
1163: }
1164: if ( filok == 0 )
1165: pperror( "Can't find include file %s", filname );
1166: else
1167: {
1168: lineno[ifno] = 1;
1169: fnames[ifno] = cp = nfil;
1170: while ( *cp++)
1171: ;
1172: savch = cp;
1173: fdates[ifno] = getfdate( fin );
1174: dirnams[ifno] = dirs[0] = trmdir( copy( nfil ) );
1175: sayline();
1176: #ifdef CXREF
1177: fprintf(outfp, "\"%s\"\n", fnames[ifno]);
1178: #endif
1179: /* save current contents of buffer */
1180: while ( !eob( p ) )
1181: p = unfill( p );
1182: inctop[ifno] = mactop;
1183: }
1184: return( p );
1185: }
1186:
1187: equfrm( a, p1, p2 )
1188: register char *a, *p1, *p2;
1189: {
1190: register char c;
1191: int flag;
1192:
1193: c = *p2;
1194: *p2 = '\0';
1195: flag = strcmp( a, p1 );
1196: *p2 = c;
1197: return( flag == SAME );
1198: }
1199:
1200: char *
1201: dodef( p ) /* process '#define' */
1202: char *p;
1203: {
1204: register char *pin, *psav, *cf;
1205: char **pf, **qf;
1206: int b, c, params;
1207: int ex_blank; /* used to ignore extra blanks in token-string */
1208: int sav_passcom = passcom; /* saved passcom, used to reset it */
1209: struct symtab *np;
1210: char *oldval, *oldsavch;
1211: char *formal[MAXFRM]; /* formal[n] is name of nth formal */
1212: char formtxt[BUFSIZ]; /* space for formal names */
1213:
1214: if ( savch > sbf + SBSIZE - BUFSIZ )
1215: {
1216: pperror( "too much defining" );
1217: return( p );
1218: }
1219: oldsavch = savch; /* to reclaim space if redefinition */
1220: ++flslvl; /* prevent macro expansion during 'define' */
1221: p = skipbl( p );
1222: pin = inp;
1223: if ( ( toktyp + COFF )[*pin] != IDENT )
1224: {
1225: if (*pin == '\n') --lineno[ifno];
1226: ppwarn( "illegal/missing macro name" );
1227: if (*pin == '\n') ++lineno[ifno];
1228: while ( *inp != '\n' )
1229: p = skipbl( p );
1230: --flslvl; /* restore expansion */
1231: return( p );
1232: }
1233: np = slookup( pin, p, 1 );
1234: if ( oldval = np->value ) /* was previously defined */
1235: savch = oldsavch;
1236: #ifdef CXREF
1237: def(np->name, lineno[ifno]);
1238: #endif
1239: b = 1;
1240: cf = pin;
1241: while ( cf < p ) /* update macbit */
1242: {
1243: c = *cf++;
1244: xmac1( c, b, |= );
1245: b = ( b + b ) & 0xFF;
1246: if ( cf != p )
1247: xmac2( c, *cf, -1 + ( cf - pin ), |= );
1248: else
1249: xmac2( c, 0, -1 + ( cf - pin ), |= );
1250: }
1251: params = 0;
1252: outp = inp = p;
1253: p = cotoken( p );
1254: pin = inp;
1255: if ( *pin == '(' ) /* with parameters; identify the formals */
1256: {
1257: #ifdef CXREF
1258: newf(np->name, lineno[ifno]);
1259: #endif
1260: cf = formtxt;
1261: pf = formal;
1262: for ( ;; )
1263: {
1264: p = skipbl( p );
1265: pin = inp;
1266: if ( *pin == '\n' )
1267: {
1268: --lineno[ifno];
1269: --p;
1270: pperror( "%s: missing )", np->name );
1271: break;
1272: }
1273: if ( *pin == ')' )
1274: break;
1275: if ( *pin == ',' )
1276: continue;
1277: if ( ( toktyp + COFF )[*pin] != IDENT )
1278: {
1279: c = *p;
1280: *p = '\0';
1281: pperror( "bad formal: %s", pin );
1282: *p = c;
1283: }
1284: else if ( pf >= &formal[MAXFRM] )
1285: {
1286: c = *p;
1287: *p = '\0';
1288: pperror( "too many formals: %s", pin );
1289: *p = c;
1290: }
1291: else
1292: {
1293: *pf++ = cf;
1294: while ( pin < p )
1295: *cf++ = *pin++;
1296: *cf++ = '\0';
1297: ++params;
1298: #ifdef CXREF
1299: def(*(pf-1), lineno[ifno]);
1300: #endif
1301: }
1302: }
1303: if ( params == 0 ) /* #define foo() ... */
1304: --params;
1305: }
1306: else if ( *pin == '\n' )
1307: {
1308: --lineno[ifno];
1309: --p;
1310: }
1311: else
1312: p = inp; /* back up to scan non-blank next token */
1313: /*
1314: * remember beginning of macro body, so that we can
1315: * warn if a redefinition is different from old value.
1316: */
1317: oldsavch = psav = savch;
1318: passcom = 1; /* make cotoken() return comments as tokens */
1319: ex_blank = 1; /* must have some delimiter - might as well be blank */
1320: for ( ;; ) /* accumulate definition until linefeed */
1321: {
1322: outp = inp = p;
1323: p = cotoken( p );
1324: pin = inp;
1325: if ( *pin == '\\' && pin[1] == '\n' ) /* ignore escaped lf */
1326: {
1327: if ( !ex_blank ) /* replace it with a blank */
1328: {
1329: *psav++ = ' ';
1330: ex_blank = 1;
1331: }
1332: putc( '\n', fout );
1333: continue;
1334: }
1335: if ( *pin == '\n' )
1336: break;
1337: if ( ( toktyp + COFF )[*pin] == BLANK ) /* skip extra blanks */
1338: {
1339: if ( ex_blank )
1340: continue;
1341: *pin = ' '; /* force it to be a "real" blank */
1342: ex_blank = 1;
1343: }
1344: else
1345: ex_blank = 0;
1346: if ( *pin == '/' && pin[1] == '*' ) /* skip comment */
1347: { /* except for \n's */
1348: while ( pin < p )
1349: if ( *pin++ == '\n' )
1350: putc( '\n', fout );
1351: continue;
1352: }
1353: if ( params ) /* mark the appearance of formals in the definiton */
1354: {
1355: if ( ( toktyp + COFF )[*pin] == IDENT )
1356: {
1357: for ( qf = pf; --qf >= formal; )
1358: {
1359: if ( equfrm( *qf, pin, p ) )
1360: {
1361: #ifdef CXREF
1362: #ifndef NO_MACRO_FORMAL
1363: ref(*qf, lineno[ifno]);
1364: #endif
1365: #endif
1366: *psav++ = qf - formal + 1;
1367: *psav++ = WARN;
1368: pin = p;
1369: break;
1370: }
1371: }
1372: }
1373: /* inside quotation marks, too */
1374: else if ( *pin == '"' || *pin == '\''
1375: # if gcos
1376: || *pin == '`'
1377: # endif
1378: )
1379: {
1380: char quoc = *pin;
1381:
1382: for ( *psav++ = *pin++; pin < p && *pin != quoc; )
1383: {
1384: while ( pin < p && !isid( *pin ) )
1385: {
1386: if ( *pin == '\n'
1387: && pin[-1] == '\\' )
1388: {
1389: putc( '\n', fout );
1390: psav--; /* no \ */
1391: pin++; /* no \n */
1392: }
1393: else
1394: *psav++ = *pin++;
1395: }
1396: cf = pin;
1397: while ( cf < p && isid( *cf ) )
1398: ++cf;
1399: for ( qf = pf; --qf >= formal; )
1400: {
1401: if ( equfrm( *qf, pin, cf ) )
1402: {
1403: *psav++ = qf - formal + 1;
1404: *psav++ = WARN;
1405: pin = cf;
1406: break;
1407: }
1408: }
1409: while ( pin < cf )
1410: *psav++ = *pin++;
1411: }
1412: }
1413: }
1414: while ( pin < p )
1415: if ( *pin == '\n' && pin[-1] == '\\' )
1416: {
1417: putc( '\n', fout );
1418: psav--; /* no \ */
1419: pin++; /* no \n */
1420: }
1421: else
1422: *psav++ = *pin++;
1423: }
1424: passcom = sav_passcom; /* restore to "real" value */
1425: if ( psav[-1] == ' ' ) /* if token-string ended with a blank */
1426: psav--; /* then it is unnecessary - throw away */
1427: *psav++ = params;
1428: *psav++ = '\0';
1429: if ( ( cf = oldval ) != NULL ) /* redefinition */
1430: {
1431: --cf; /* skip no. of params, which may be zero */
1432: while ( *--cf ) /* go back to the beginning */
1433: ;
1434: if ( 0 != strcmp( ++cf, oldsavch ) ) /* redefinition different from old */
1435: {
1436: --lineno[ifno];
1437: ppwarn( "%s redefined", np->name );
1438: ++lineno[ifno];
1439: np->value = psav - 1;
1440: }
1441: else
1442: psav = oldsavch; /* identical redef.; reclaim space */
1443: }
1444: else
1445: np->value = psav - 1;
1446: --flslvl;
1447: inp = pin;
1448: savch = psav;
1449: return( p );
1450: }
1451:
1452: #define fasscan() ptrtab = fastab + COFF
1453: #define sloscan() ptrtab = slotab + COFF
1454: /* this macro manages the lookup of a macro name and produces
1455: ** a warning if the name is missing
1456: */
1457: #define LOOKUP(skipblank, flag) \
1458: ++flslvl; if (skipblank) p = skipbl(p); \
1459: if ( ( toktyp + COFF )[*inp] != IDENT ) \
1460: { \
1461: if (*inp == '\n') --lineno[ifno];\
1462: ppwarn( "illegal/missing macro name" ); \
1463: if (*inp == '\n') ++lineno[ifno];\
1464: while ( *inp != '\n' ) \
1465: p = skipbl( p ); \
1466: --flslvl; \
1467: continue; \
1468: } \
1469: np = slookup(inp,p,flag); --flslvl
1470:
1471: control( p ) /* find and handle preprocessor control lines */
1472: register char *p;
1473: {
1474: register struct symtab *np;
1475:
1476: for ( ;; )
1477: {
1478: fasscan();
1479: p = cotoken( p );
1480: if ( *inp == '\n' )
1481: ++inp;
1482: dump();
1483: sloscan();
1484: p = skipbl( p );
1485: *--inp = SALT;
1486: outp = inp;
1487: ++flslvl;
1488: np = slookup( inp, p, 0 );
1489: --flslvl;
1490: if ( np == defloc ) /* define */
1491: {
1492: if ( flslvl == 0 )
1493: {
1494: p = dodef( p );
1495: continue;
1496: }
1497: }
1498: else if ( np == incloc ) /* include */
1499: {
1500: p = doincl( p );
1501: continue;
1502: }
1503: else if ( np == ifnloc ) /* ifndef */
1504: {
1505: LOOKUP(1/*skipbl*/, 0/*flag*/); /* sets "np" */
1506: if ( flslvl == 0 && np->value == 0 )
1507: ++trulvl;
1508: else
1509: ++flslvl;
1510: if ( trulvl + flslvl >= MAX_DEPTH )
1511: pperror( "#if,ifdef,ifndef nesting too deep" );
1512: else
1513: ifelstk[trulvl + flslvl] =
1514: flslvl ? 0 : TRUE_ELIF;
1515: #ifdef CXREF
1516: ref(xcopy(inp, p), lineno[ifno]);
1517: #endif
1518: p = chkend( p, 1 );
1519: }
1520: else if ( np == ifdloc ) /* ifdef */
1521: {
1522: LOOKUP(1/*skipbl*/, 0/*flag*/); /* sets "np" */
1523: if ( flslvl == 0 && np->value != 0 )
1524: ++trulvl;
1525: else
1526: ++flslvl;
1527: if ( trulvl + flslvl >= MAX_DEPTH )
1528: pperror( "#if,ifdef,ifndef nesting too deep" );
1529: else
1530: ifelstk[trulvl + flslvl] =
1531: flslvl ? 0 : TRUE_ELIF;
1532: #ifdef CXREF
1533: ref(xcopy(inp, p), lineno[ifno]);
1534: #endif
1535: p = chkend( p, 1 );
1536: }
1537: else if ( np == eifloc ) /* endif */
1538: {
1539: if ( flslvl )
1540: {
1541: if ( --flslvl == 0 )
1542: sayline();
1543: }
1544: else if ( trulvl )
1545: --trulvl;
1546: else
1547: pperror( "If-less endif", 0 );
1548: p = chkend( p, 2 ); /* research mod; summit uses 1 */
1549: }
1550: else if ( np == elifloc ) /* elif */
1551: {
1552: if ( ifelstk[trulvl + flslvl] & SEEN_ELSE )
1553: pperror( "#elif following #else", 0 );
1554: if ( flslvl )
1555: {
1556: if ( --flslvl != 0 )
1557: ++flslvl;
1558: else
1559: {
1560: newp = p;
1561: #ifdef CXREF
1562: xline = lineno[ifno];
1563: #endif
1564: if ( ifelstk[trulvl + flslvl + 1] == 0
1565: && yyparse() )
1566: {
1567: ++trulvl;
1568: ifelstk[trulvl + flslvl] =
1569: TRUE_ELIF;
1570: sayline();
1571: }
1572: else
1573: ++flslvl;
1574: p = newp;
1575: }
1576: }
1577: else if ( trulvl )
1578: {
1579: ++flslvl;
1580: --trulvl;
1581: }
1582: else
1583: pperror( "If-less elif", 0 );
1584: }
1585: else if ( np == elsloc ) /* else */
1586: {
1587: if ( ifelstk[trulvl + flslvl] & SEEN_ELSE )
1588: pperror( "too many #else's", 0 );
1589: if ( flslvl )
1590: {
1591: if ( --flslvl != 0 )
1592: ++flslvl;
1593: else if ( ifelstk[trulvl + flslvl + 1] == 0 )
1594: {
1595: ++trulvl;
1596: sayline();
1597: }
1598: else
1599: ++flslvl;
1600: }
1601: else if ( trulvl )
1602: {
1603: ++flslvl;
1604: --trulvl;
1605: }
1606: else
1607: pperror( "If-less else", 0 );
1608: ifelstk[trulvl + flslvl] |= SEEN_ELSE;
1609: p = chkend( p, 1 );
1610: }
1611: else if ( np == udfloc ) /* undefine */
1612: {
1613: if ( flslvl == 0 )
1614: {
1615: LOOKUP(1/*skipbl*/, DROP); /* sets "np" */
1616: p = chkend( p, 1 );
1617: }
1618: else
1619: p = chkend( p, 2 );
1620: #ifdef CXREF
1621: ref(xcopy(inp, p), lineno[ifno]);
1622: #endif
1623: }
1624: else if ( np == ifloc ) /* if */
1625: {
1626: #if tgp
1627: pperror( " IF not implemented, true assumed", 0 );
1628: if ( flslvl == 0 )
1629: ++trulvl;
1630: else
1631: ++flslvl;
1632: #else
1633: newp = p;
1634: #ifdef CXREF
1635: xline = lineno[ifno];
1636: #endif
1637: if ( flslvl == 0 && yyparse() )
1638: ++trulvl;
1639: else
1640: ++flslvl;
1641: p = newp;
1642: if ( trulvl + flslvl >= MAX_DEPTH )
1643: pperror( "#if,ifdef,ifndef nesting too deep" );
1644: else
1645: ifelstk[trulvl + flslvl] =
1646: flslvl ? 0 : TRUE_ELIF;
1647: #endif
1648: }
1649: else if ( np == lneloc ) /* line */
1650: {
1651: if ( flslvl == 0 && pflag == 0 )
1652: {
1653: register char *s;
1654: register int ln;
1655:
1656: outp = inp = p;
1657: do_line:
1658: *--outp = '#';
1659: /*
1660: * make sure that the whole
1661: * directive has been read
1662: */
1663: s = p;
1664: while ( *s && *s != '\n' )
1665: s++;
1666: if ( eob( s ) )
1667: p = refill( s );
1668: /*
1669: * eat the line number
1670: */
1671: s = inp;
1672: while ( ( toktyp + COFF )[*s] == BLANK )
1673: s++;
1674: ln = 0;
1675: while ( isdigit( *s ) )
1676: ln = ln * 10 + *s++ - '0';
1677: if ( ln )
1678: lineno[ifno] = ln - 1;
1679: else
1680: pperror( "bad number for #line" );
1681: /*
1682: * eat the optional "filename"
1683: */
1684: while ( ( toktyp + COFF )[*s] == BLANK )
1685: s++;
1686: if ( *s != '\n' )
1687: {
1688: if ( *s != '"' )
1689: pperror( "bad file for #line" );
1690: else
1691: {
1692: register char *t = savch;
1693:
1694: for ( ;; )
1695: {
1696: if ( *++s == '"' )
1697: break;
1698: else if ( *s == '\n' ||
1699: *s == '\0' )
1700: {
1701: pperror( "bad file for #line" );
1702: break;
1703: }
1704: *t++ = *s;
1705: }
1706: *t++ = '\0';
1707: if ( strcmp( savch, fnames[ifno] ) )
1708: {
1709: fnames[ifno] = savch;
1710: fdates[ifno] = findfdate( &fnames[ifno] );
1711: savch = t;
1712: }
1713: }
1714: }
1715: /*
1716: * push it all along to be eventually printed
1717: */
1718: while ( *inp != '\n' )
1719: p = cotoken( p );
1720: continue;
1721: }
1722: }
1723: else if ( np == clsloc ) /* class */
1724: exfail = CLASSCODE; /* return value */
1725: else if ( np == idtloc ) /* ident */
1726: {
1727: if ( pflag == 0 )
1728: while ( *inp != '\n' ) /* just pass it along */
1729: p = cotoken( p );
1730: }
1731: #ifdef PRAGMA
1732: else if ( np == pragmaloc ) { /* pragma */
1733: while ( *inp != '\n' ) /* pass it all along */
1734: p = cotoken( p );
1735: }
1736: #endif
1737: else if ( *++inp == '\n' ) /* allows blank line after # */
1738: outp = inp;
1739: else if ( isdigit( *inp ) ) /* pass thru line directives */
1740: {
1741: outp = p = inp;
1742: goto do_line;
1743: }
1744: else
1745: pperror( "undefined control", 0 );
1746: /* flush to lf */
1747: ++flslvl;
1748: while ( *inp != '\n' )
1749: {
1750: outp = inp = p;
1751: p = cotoken( p );
1752: }
1753: --flslvl;
1754: }
1755: }
1756:
1757: struct symtab *
1758: stsym( s )
1759: register char *s;
1760: {
1761: char buf[BUFSIZ];
1762: register char *p;
1763:
1764: /* make definition look exactly like end of #define line */
1765: /* copy to avoid running off end of world when param list is at end */
1766: p = buf;
1767: while ( *p++ = *s++ )
1768: ;
1769: p = buf;
1770: while ( isid( *p++ ) ) /* skip first identifier */
1771: ;
1772: if ( *--p == '=' )
1773: {
1774: *p++ = ' ';
1775: while ( *p++ )
1776: ;
1777: }
1778: else
1779: {
1780: s = " 1";
1781: while ( *p++ = *s++ )
1782: ;
1783: }
1784: pend = p;
1785: *--p = '\n';
1786: sloscan();
1787: dodef( buf );
1788: return( lastsym );
1789: }
1790:
1791: struct symtab *
1792: ppsym( s ) /* kludge */
1793: char *s;
1794: {
1795: register struct symtab *sp;
1796:
1797: cinit = SALT;
1798: *savch++ = SALT;
1799: sp = stsym( s );
1800: --sp->name;
1801: cinit = 0;
1802: return( sp );
1803: }
1804:
1805:
1806: int yy_errflag; /* TRUE when pperror called by yyerror() */
1807:
1808: /* VARARGS1 */
1809: pperror( s, x, y )
1810: char *s;
1811: {
1812: if ( fnames[ifno][0] )
1813: # if gcos
1814: fprintf( stderr, ERRFORM, exfail >= 0 ? 'F' : 'W',fnames[ifno]);
1815: # else
1816: fprintf( stderr, "%s: ", fnames[ifno] );
1817: # endif
1818: fprintf( stderr, "%d: ", lineno[ifno] );
1819: fprintf( stderr, s, x, y );
1820: if ( yy_errflag )
1821: fprintf( stderr, " (in preprocessor if)\n" );
1822: else
1823: fprintf( stderr, "\n" );
1824: if ( exfail < CLASSCODE - 1 )
1825: ++exfail;
1826: }
1827:
1828: yyerror( s, a, b )
1829: char *s;
1830: {
1831: yy_errflag = 1;
1832: pperror( s, a, b );
1833: yy_errflag = 0;
1834: }
1835:
1836: ppwarn( s, x )
1837: char *s;
1838: {
1839: int fail = exfail;
1840:
1841: exfail = -1;
1842: pperror( s, x );
1843: exfail = fail;
1844: }
1845:
1846: struct symtab *
1847: lookup( namep, enterf )
1848: char *namep;
1849: {
1850: register char *np, *snp;
1851: register int c, i;
1852: int around;
1853: register struct symtab *sp;
1854:
1855: /* namep had better not be too long (currently, <=ncps chars) */
1856: np = namep;
1857: around = 0;
1858: i = cinit;
1859: while ( c = *np++ )
1860: i += i + c;
1861: c = i; /* c=i for register usage on pdp11 */
1862: c %= symsiz;
1863: if ( c < 0 )
1864: c += symsiz;
1865: sp = &stab[c];
1866: while ( snp = sp->name )
1867: {
1868: np = namep;
1869: while ( *snp++ == *np )
1870: if ( *np++ == '\0' )
1871: {
1872: if ( enterf == DROP )
1873: {
1874: sp->name[0] = DROP;
1875: sp->value = 0;
1876: }
1877: return( lastsym = sp );
1878: }
1879: if ( --sp < &stab[0] )
1880: if ( around )
1881: {
1882: pperror( "too many defines", 0 );
1883: exit( exfail ? ( exfail ==
1884: CLASSCODE ? CLASSCODE : 2 ) : 0 );
1885: }
1886: else
1887: {
1888: ++around;
1889: sp = &stab[symsiz - 1];
1890: }
1891: }
1892: if ( enterf == 1 )
1893: sp->name = namep;
1894: return( lastsym = sp );
1895: }
1896:
1897: struct symtab *
1898: slookup( p1, p2, enterf )
1899: register char *p1, *p2;
1900: int enterf;
1901: {
1902: register char *p3;
1903: char c2, c3;
1904: struct symtab *np;
1905:
1906: c2 = *p2; /* mark end of token */
1907: *p2 ='\0';
1908: if ( ( p2 - p1 ) > ncps )
1909: p3 = p1 + ncps;
1910: else
1911: p3 = p2;
1912: c3 = *p3; /* truncate to ncps chars or less */
1913: *p3 ='\0';
1914: if ( enterf == 1 )
1915: p1 = copy( p1 );
1916: np = lookup( p1, enterf );
1917: *p3 = c3;
1918: *p2 = c2;
1919: if ( np->value != 0 && flslvl == 0 )
1920: newp = subst( p2, np );
1921: else
1922: newp = 0;
1923: return( np );
1924: }
1925:
1926: char *
1927: subst( p, sp )
1928: register char *p;
1929: struct symtab *sp;
1930: {
1931: static char match[] = "%s: argument mismatch";
1932: register char *ca, *vp;
1933: int params;
1934: char *actual[MAXFRM]; /* actual[n] is text of nth actual */
1935: char acttxt[BUFSIZ]; /* space for actuals */
1936:
1937: if ( 0 == ( vp = sp->value ) )
1938: return( p );
1939: if ( ( p - macforw ) <= macdam )
1940: {
1941: if ( ++maclvl > symsiz && !rflag )
1942: {
1943: pperror( "%s: macro recursion", sp->name );
1944: return( p );
1945: }
1946: }
1947: else
1948: maclvl = 0; /* level decreased */
1949: macforw = p; /* new target for decrease in level */
1950: macdam = 0;
1951: macnam = sp->name;
1952: #ifdef CXREF
1953: ref(macnam, lineno[ifno]);
1954: #endif
1955: dump();
1956: if ( sp == ulnloc )
1957: {
1958: vp = acttxt;
1959: *vp++ = '\0';
1960: sprintf( vp, "%d", lineno[ifno] );
1961: while ( *vp++ )
1962: ;
1963: }
1964: else if ( sp == uflloc )
1965: {
1966: vp = acttxt;
1967: *vp++ = '\0';
1968: sprintf( vp, "\"%s\"", fnames[ifno] );
1969: while ( *vp++ )
1970: ;
1971: }
1972: if ( 0 != ( params = *--vp & 0xFF ) ) /*definition calls for params */
1973: {
1974: register char **pa;
1975: int dparams; /* parameters in definition */
1976:
1977: ca = acttxt;
1978: pa = actual;
1979: if ( params == 0xFF ) /* #define foo() ... */
1980: params = 0;
1981: dparams = params;
1982: sloscan();
1983: ++flslvl; /* no expansion during search for actuals */
1984: plvl = -1;
1985: maclin = lineno[ifno];
1986: macfil = fnames[ifno];
1987: do
1988: {
1989: p = skipbl( p );
1990: }
1991: while ( *inp == '\n' ); /* skip \n too */
1992: if ( *inp == '(' )
1993: {
1994: for ( plvl = 1; plvl != 0; )
1995: {
1996: *ca++ = '\0';
1997: for ( ;; )
1998: {
1999: outp = inp = p;
2000: p = cotoken( p );
2001: if ( *inp == '(' )
2002: ++plvl;
2003: if ( *inp == ')' && --plvl == 0 )
2004: {
2005: if ( ca > acttxt+1 )
2006: --params;
2007: break;
2008: }
2009: if ( plvl == 1 && *inp == ',' )
2010: {
2011: --params;
2012: break;
2013: }
2014: while ( inp < p )
2015: {
2016: /*
2017: * toss newlines in arguments
2018: * to macros - keep problems
2019: * to a minimum.
2020: * if a backslash is just
2021: * before the newline, assume
2022: * it is in a string and
2023: * leave it in.
2024: */
2025: if ( *inp == '\n'
2026: && inp[-1] != '\\' )
2027: {
2028: *inp = ' ';
2029: }
2030: *ca++ = *inp++;
2031: }
2032: if ( ca > &acttxt[BUFSIZ] )
2033: pperror( "%s: actuals too long", sp->name );
2034: }
2035: if ( pa >= &actual[MAXFRM] )
2036: ppwarn( match, sp->name );
2037: else
2038: *pa++ = ca;
2039: }
2040: }
2041: else { /* should have seen (, because def
2042: ** had args
2043: */
2044: ppwarn( match, sp->name );
2045: p = inp; /* back up to current token */
2046: }
2047: if ( maclin != lineno[ifno] ) /* embedded linefeeds in macro call */
2048: {
2049: int i, j = lineno[ifno];
2050:
2051: for ( i = sizeof( int ) / sizeof( char ); --i >= 0; )
2052: {
2053: if ( bob( p ) )
2054: {
2055: outp = inp = p;
2056: p = unfill( p );
2057: }
2058: *--p = j;
2059: j >>= 8;
2060: }
2061: if ( bob( p ) )
2062: {
2063: outp = inp = p;
2064: p = unfill( p );
2065: }
2066: *--p = warnc;
2067: }
2068: /* def with one arg and use with zero args is special ok case */
2069: if ( params < 0 || (params > 0 && dparams != 1) )
2070: ppwarn( match, sp->name );
2071: while ( --params >= 0 )
2072: *pa++ = "" + 1; /* null string for missing actuals */
2073: --flslvl;
2074: fasscan();
2075: }
2076: for ( ;; ) /* push definition onto front of input stack */
2077: {
2078: while ( !iswarn( *--vp ) )
2079: {
2080: if ( bob( p ) )
2081: {
2082: outp = inp = p;
2083: p = unfill( p );
2084: }
2085: *--p = *vp;
2086: }
2087: if ( *vp == warnc ) /* insert actual param */
2088: {
2089: ca = actual[*--vp - 1];
2090: while ( *--ca )
2091: {
2092: if ( bob( p ) )
2093: {
2094: outp = inp = p;
2095: p = unfill( p );
2096: }
2097: *--p = *ca;
2098: }
2099: }
2100: else
2101: break;
2102: }
2103: outp = inp = p;
2104: return( p );
2105: }
2106:
2107:
2108:
2109:
2110: char *
2111: trmdir( s )
2112: register char *s;
2113: {
2114: register char *p = s;
2115:
2116: while ( *p++ )
2117: ;
2118: --p;
2119: while ( p > s && *--p != '/' )
2120: ;
2121: # if unix || DMERT
2122: if ( p == s )
2123: *p++ = '.';
2124: # endif
2125: *p = '\0';
2126: return( s );
2127: }
2128:
2129: STATIC char *
2130: copy( s )
2131: register char *s;
2132: {
2133: register char *old;
2134:
2135: old = savch;
2136: while ( *savch++ = *s++ )
2137: ;
2138: return( old );
2139: }
2140:
2141: yywrap()
2142: {
2143: return( 1 );
2144: }
2145:
2146: main( argc, argv )
2147: char *argv[];
2148: {
2149: register int i, c;
2150: register char *p;
2151: char *tf, **cp2;
2152: int forclass = 0; /* 1 if C-with-classes selected */
2153:
2154: # if gcos
2155: if ( setjmp( env ) )
2156: return( exfail ? ( exfail == CLASSCODE ? CLASSCODE : 2 ) : 0 );
2157: # endif
2158: p = "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
2159: i = 0;
2160: while ( c = *p++ )
2161: {
2162: ( fastab + COFF )[c] |= IB | NB | SB;
2163: ( toktyp + COFF )[c] = IDENT;
2164: #if scw2
2165: /* 53 == 63-10; digits rarely appear in identifiers,
2166: /* and can never be the first char of an identifier.
2167: /* 11 == 53*53/sizeof(macbit) .
2168: */
2169: ++i;
2170: ( t21 + COFF )[c] = ( 53 * i ) / 11;
2171: ( t22 + COFF )[c] = i % 11;
2172: #endif
2173: }
2174: p = "0123456789.";
2175: while ( c = *p++ )
2176: {
2177: ( fastab + COFF )[c] |= NB | SB;
2178: ( toktyp + COFF )[c] = NUMBR;
2179: }
2180: # if gcos
2181: p = "\n\"'`/\\";
2182: # else
2183: p = "\n\"'/\\";
2184: # endif
2185: while ( c = *p++ )
2186: ( fastab + COFF )[c] |= SB;
2187: # if gcos
2188: p = "\n\"'`\\";
2189: # else
2190: p = "\n\"'\\";
2191: # endif
2192: while ( c = *p++ )
2193: ( fastab + COFF )[c] |= QB;
2194: p = "*\n";
2195: while ( c = *p++ )
2196: ( fastab + COFF)[c] |= CB;
2197: ( fastab + COFF )[warnc] |= WB | SB;
2198: ( fastab + COFF )['\0'] |= CB | QB | SB | WB;
2199: for ( i = ALFSIZ; --i >= 0; )
2200: slotab[i] = fastab[i] | SB;
2201: p = " \t\v\f\r"; /* note no \n; */
2202: while ( c = *p++ )
2203: ( toktyp + COFF )[c] = BLANK;
2204: #if scw2
2205: for ( ( t23 + COFF )[i = ALFSIZ + 7 - COFF] = 1; --i >= -COFF; )
2206: if ( ( ( t23 + COFF )[i] = ( t23 + COFF + 1 )[i] << 1 ) == 0 )
2207: ( t23 + COFF )[i] = 1;
2208: #endif
2209:
2210: # if unix || DMERT
2211: fnames[ifno = 0] = "";
2212: fdates[ifno = 0] = "";
2213: dirnams[0] = dirs[0] = ".";
2214: # endif
2215: # if ibm
2216: fnames[ifno = 0] = "";
2217: fdates[ifno = 0] = "";
2218: # endif
2219: # if gcos
2220: if ( inquire( stdin, _TTY ) )
2221: freopen( "*src", "rt", stdin );
2222: # endif
2223: # if gimpel || gcos
2224: fnames[ifno = 0] = (char *) inquire( stdin, _FILENAME );
2225: dirnams[0] = dirs[0] = trmdir( copy( fnames[0] ) );
2226: # endif
2227: for ( i = 1; i < argc; i++ )
2228: {
2229: switch ( argv[i][0] )
2230: {
2231: case '-':
2232: # if gcos
2233: /* case-independent on GCOS */
2234: switch ( toupper( argv[i][1] ) )
2235: # else
2236: switch( argv[i][1] )
2237: # endif
2238: {
2239: case 'M': /* research: filename+moddate*/
2240: mflag++;
2241: continue;
2242: case 'P':
2243: pflag++;
2244: case 'E':
2245: continue;
2246: case 'R':
2247: ++rflag;
2248: continue;
2249: case 'C':
2250: passcom++;
2251: continue;
2252: #ifdef CXREF
2253: case 'F':
2254: if ((outfp = fopen(argv[++i],"w")) == NULL)
2255: {
2256: fprintf(stderr, "Can't open %s\n",
2257: argv[i]);
2258: exit(1);
2259: }
2260: continue;
2261: #endif
2262: case 'D':
2263: if ( predef > prespc + NPREDEF )
2264: {
2265: pperror( "too many -D options, ignoring %s", argv[i] );
2266: continue;
2267: }
2268: /* ignore plain "-D" (no argument) */
2269: if ( *( argv[i] + 2 ) )
2270: *predef++ = argv[i] + 2;
2271: continue;
2272: case 'U':
2273: if ( prund > punspc + NPREDEF )
2274: {
2275: pperror( "too many -U options, ignoring %s", argv[i] );
2276: continue;
2277: }
2278: *prund++ = argv[i] + 2;
2279: continue;
2280: case 'I':
2281: if ( nd > MAXINC - 4 )
2282: pperror( "excessive -I file (%s) ignored", argv[i] );
2283: else
2284: dirs[nd++] = argv[i] + 2;
2285: continue;
2286: case 'Y':
2287: dfltdir = argv[i] + 2;
2288: continue;
2289: case '\0':
2290: continue;
2291: case 'T':
2292: ncps = 8; /* backward name compatabilty */
2293: continue;
2294: case 'H': /* print included filenames */
2295: print_incs++;
2296: continue;
2297: case 'W': /* enable C with classes */
2298: forclass = 1;
2299: continue;
2300: default:
2301: pperror( "unknown flag %s", argv[i] );
2302: continue;
2303: }
2304: default:
2305: if ( fin == stdin )
2306: {
2307: if ( NULL == ( fin = fopen( argv[i], READ ) ) )
2308: {
2309: pperror( "No source file %s", argv[i] );
2310: exit(2);
2311: }
2312: fnames[ifno] = copy( argv[i] );
2313: fdates[ifno] = getfdate( fin );
2314: #ifdef CXREF
2315: fprintf(outfp,"\"%s\"\n", fnames[ifno]);
2316: #endif
2317: dirs[0] = dirnams[ifno] = trmdir( argv[i] );
2318: # ifndef gcos
2319: /* too dangerous to have file name in same syntactic position
2320: be input or output file depending on file redirections,
2321: so force output to stdout, willy-nilly
2322: [i don't see what the problem is. jfr]
2323: */
2324: }
2325: else if ( fout == stdout )
2326: {
2327: static char _sobuf[BUFSIZ];
2328:
2329: if ( NULL == ( fout = fopen( argv[i], WRITE ) ) )
2330: {
2331: pperror( "Can't create %s", argv[i] );
2332: exit(2);
2333: }
2334: else
2335: {
2336: fclose( stdout );
2337: setbuf( fout, _sobuf );
2338: }
2339: # endif
2340: }
2341: else
2342: pperror( "extraneous name %s", argv[i] );
2343: }
2344: }
2345:
2346: fins[ifno] = fin;
2347: exfail = 0;
2348: /* after user -I files here are the standard include libraries */
2349: /* use user-supplied default first */
2350: if (dfltdir != (char *) 0)
2351: dirs[nd++] = dfltdir;
2352: else {
2353: # if unix || DMERT
2354: # if defined(SGSINC) || defined(DMERT)
2355: if ( strlen( SGSINC ) != 0 )
2356: dirs[nd++] = SGSINC; /* For cross cpp's */
2357: # endif
2358: # ifdef USRINC
2359: if ( strlen( USRINC ) != 0 )
2360: dirs[nd++] = USRINC; /* usually /usr/include */
2361: # endif
2362: # if !defined( SGSINC ) && !defined( USRINC )
2363: dirs[nd++] = "/usr/include";
2364: # endif
2365: # endif
2366: # if gcos
2367: dirs[nd++] = "cc/include";
2368: # endif
2369: # if ibm
2370: # ifndef gimpel
2371: dirs[nd++] = "BTL$CLIB";
2372: # endif
2373: # endif
2374: # ifdef gimpel
2375: dirs[nd++] = intss() ? "SYS3.C." : "";
2376: # endif
2377: # ifdef compool
2378: dirs[nd++] = "/compool";
2379: # endif
2380: }
2381: dirs[nd++] = 0;
2382: defloc = ppsym( "define" );
2383: udfloc = ppsym( "undef" );
2384: incloc = ppsym( "include" );
2385: elsloc = ppsym( "else" );
2386: eifloc = ppsym( "endif" );
2387: elifloc = ppsym( "elif" );
2388: ifdloc = ppsym( "ifdef" );
2389: ifnloc = ppsym( "ifndef" );
2390: ifloc = ppsym( "if" );
2391: lneloc = ppsym( "line" );
2392: if (forclass) /* only when C with classes enabled */
2393: clsloc = ppsym( "class" );
2394: idtloc = ppsym( "ident" );
2395: #ifdef PRAGMA
2396: pragmaloc = ppsym( "pragma" );
2397: #endif
2398: for ( i = sizeof( macbit ) / sizeof( macbit[0] ); --i >= 0; )
2399: macbit[i] = 0;
2400:
2401: if ( pdef_mach[PD_MACH] )
2402: ysysloc = stsym( pdef_mach[PD_MACH] );
2403: if ( pdef_sys[PD_SYS] )
2404: varloc = stsym( pdef_sys[PD_SYS] );
2405:
2406: tf = fnames[ifno]; /* do the -D and -U options now */
2407: fnames[ifno] = "command line";
2408: lineno[ifno] = 1;
2409: cp2 = prespc;
2410: while ( cp2 < predef )
2411: stsym( *cp2++ );
2412: cp2 = punspc;
2413: while ( cp2 < prund )
2414: {
2415: if ( p = strchr( *cp2, '=' ) )
2416: *p = '\0';
2417: /*
2418: * Truncate to ncps characters if needed.
2419: */
2420: if ( strlen( *cp2 ) > ncps )
2421: (*cp2)[ncps] = '\0';
2422: lookup( *cp2++, DROP );
2423: }
2424:
2425: ulnloc = stsym( "__LINE__" );
2426: uflloc = stsym( "__FILE__" );
2427: fnames[ifno] = tf;
2428: pbeg = buffer + ncps;
2429: pbuf = pbeg + BUFSIZ;
2430: pend = pbuf + BUFSIZ;
2431:
2432: trulvl = 0;
2433: flslvl = 0;
2434: lineno[0] = 1;
2435: sayline();
2436: outp = inp = pend;
2437: #ifdef CXREF
2438: ready = 1;
2439: #endif
2440: control( pend );
2441: if ( fout && ferror( fout ) )
2442: pperror( "Problems with output file; probably out of temp space" );
2443: exit( exfail ? ( exfail == CLASSCODE ? CLASSCODE : 2 ) : 0 );
2444: }
2445:
2446: #ifdef CXREF
2447: ref( name, line )
2448: char *name;
2449: int line;
2450: {
2451: #ifdef FLEXNAMES
2452: fprintf(outfp, "R%s\t%05d\n", name, line);
2453: #else
2454: fprintf(outfp, "R%.8s\t%05d\n", name, line);
2455: #endif
2456: }
2457:
2458: def( name, line )
2459: char *name;
2460: int line;
2461: {
2462: if (ready)
2463: #ifdef FLEXNAMES
2464: fprintf(outfp, "D%s\t%05d\n", name, line);
2465: #else
2466: fprintf(outfp, "D%.8s\t%05d\n", name, line);
2467: #endif
2468: }
2469:
2470: newf( name, line )
2471: char *name;
2472: int line;
2473: {
2474: #ifdef FLEXNAMES
2475: fprintf(outfp, "F%s\t%05d\n", name, line);
2476: #else
2477: fprintf(outfp, "F%.8s\t%05d\n", name, line);
2478: #endif
2479: }
2480:
2481: char *
2482: xcopy( ptr1, ptr2 )
2483: register char *ptr1, *ptr2;
2484: {
2485: static char name[NCPS];
2486: char *saveptr, ch;
2487: register char *ptr3 = name;
2488:
2489: /* locate end of name; save character there */
2490: if ((ptr2 - ptr1) > ncps)
2491: {
2492: saveptr = ptr1 + ncps;
2493: ch = *saveptr;
2494: *saveptr = '\0';
2495: }
2496: else {
2497: ch = *ptr2;
2498: *ptr2 = '\0';
2499: saveptr = ptr2;
2500: }
2501: while (*ptr3++ = *ptr1++) ; /* copy name */
2502: *saveptr = ch; /* replace character */
2503: return( name );
2504: }
2505: #endif
2506:
2507: /* Scan over the end of a directive, making sure there's no
2508: ** residual junk.
2509: **
2510: ** This code is a little messier than you might expect. To avoid bumping
2511: ** the line number when we hit the newline, print the message the first time
2512: ** we find we've got too many tokens.
2513: */
2514:
2515: char *
2516: chkend( p, ntoken )
2517: char * p;
2518: int ntoken; /* number of tokens at which to warn */
2519: {
2520: int extratokens = 0;
2521: int save_passcom = passcom;
2522:
2523: passcom = 0; /* ignore comments in this context */
2524: ++flslvl; /* don't expand anything */
2525:
2526: /* if at newline, force rescan to do end-of-line stuff */
2527: if (*inp == '\n')
2528: p = inp;
2529:
2530: for (;;) {
2531: p = skipbl(p); /* get next token */
2532: if (*inp == '\n')
2533: break; /* reached end */
2534: if(++extratokens == ntoken) /* hit number of extras; flag here */
2535: ppwarn("extra tokens (ignored) after directive");
2536: }
2537:
2538: /* restore comment flag */
2539: passcom = save_passcom;
2540: --flslvl; /* back to previous expansion level */
2541:
2542: return( p );
2543: }
2544:
2545: char *
2546: getfdate( fin )
2547: FILE *fin;
2548: {
2549: char date[ 10 ];
2550: struct stat sb;
2551: if ( !mflag )
2552: return "";
2553: fstat( fileno( fin ), &sb );
2554: sprintf( date, "@%ld", sb.st_mtime );
2555: return copy( date );
2556: }
2557:
2558: char *
2559: findfdate( fname )
2560: char *fname;
2561: {
2562: register char *s;
2563: for ( s = fname; *s; s++ )
2564: if ( *s == '@' ) {
2565: *s++ = 0;
2566: break;
2567: }
2568: return s;
2569: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.