![[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 [MW Coherent from dump] / coherent / d / bin / cc / c / n0|
Return to cpp.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n0 |
1.1 root 1: /*
2: * C preprocessor.
3: * This version of cpp runs as a module of cc0.
4: */
5: #ifdef vax
6: #include "INC$LIB:cc0.h"
7: #else
8: #include "cc0.h"
9: #endif
10:
11: /*
12: * Low-level functions and macros.
13: *
14: * Stash characters into the 'dbuf'
15: * where most things are being accumulated.
16: */
17:
18: dputc(c) int c;
19: {
20: if (dputp < dpshp)
21: *dputp++ = c;
22: else
23: dfull("dput");
24: }
25: dpshc(c) int c;
26: {
27: if (--dpshp > dputp)
28: *dpshp = c;
29: else
30: dfull("dpsh");
31: }
32: dspush(t, p) int t; char *p;
33: {
34: if (--dstackp > dlistp) {
35: dstackp->ds_type = t;
36: dstackp->ds_char = 0;
37: dstackp->ds_ptr = p;
38: } else
39: dfull("dspush");
40: }
41: dspushc(t, c) int t, c;
42: {
43: if (--dstackp > dlistp) {
44: dstackp->ds_type = t;
45: dstackp->ds_char = c;
46: dstackp->ds_ptr = 0;
47: } else
48: dfull("dspushc");
49: }
50: dslist(t, p) int t; char *p;
51: {
52: if (dlistp < dstackp) {
53: dlistp->ds_type = t;
54: dlistp->ds_char = 0;
55: (dlistp++)->ds_ptr = p;
56: } else
57: dfull("dslist");
58: }
59: dslistc(t, c) int t, c;
60: {
61: if (dlistp < dstackp) {
62: dlistp->ds_type = t;
63: dlistp->ds_char = c;
64: (dlistp++)->ds_ptr = 0;
65: } else
66: dfull("dslistc");
67: }
68:
69: dfull(where) char *where;
70: {
71: cfatal("macro expansion buffer overflow in %s", where);
72: }
73:
74: dputs(p) register char *p;
75: {
76: register int c;
77:
78: while (c = *p++) dputc(c);
79: }
80:
81: dpshs(p) register char *p;
82: {
83: register int c;
84:
85: while (c = *p++) dpshc(c);
86: }
87:
88: dputstr(d) register int d;
89: {
90: register int c;
91: instring = c = d;
92: for (;;) {
93: dputc(c);
94: if ((c = get()) < 0 || c == '\n' || c == d)
95: break;
96: if (c == '\\') {
97: dputc(c);
98: if ((c = get()) < 0 || c == '\n') {
99: dputc(' ');
100: break;
101: }
102: }
103: }
104: dputc(d);
105: instring = 0;
106: return c;
107: }
108:
109: dpshstr(d) register int d;
110: {
111: register int c;
112: instring = c = d;
113: for (;;) {
114: dpshc(c);
115: if ((c = get()) < 0 || c == '\n' || c == d)
116: break;
117: if (c == '\\') {
118: dpshc(c);
119: if ((c = get()) < 0 || c == '\n') {
120: dpshc(' ');
121: break;
122: }
123: }
124: }
125: dpshc(d);
126: instring = 0;
127: return c;
128: }
129:
130: dputnum(c) register int c;
131: {
132: ++incpp;
133: if (c == '.') {
134: unget(c = get());
135: if (c < 0 || ct[c] != CON) {
136: dputc('.');
137: --incpp;
138: return;
139: }
140: getnum(get(), 1);
141: } else
142: getnum(c, 0);
143: dputs(id);
144: --incpp;
145: }
146:
147: dpshnum(c) register int c;
148: {
149: ++incpp;
150: if (c == '.') {
151: unget(c = get());
152: if (c < 0 || ct[c] != CON) {
153: dpshc('.');
154: --incpp;
155: return;
156: }
157: getnum(get(), 1);
158: } else
159: getnum(c, 0);
160: dpshs(id);
161: --incpp;
162: }
163:
164: /* Allocate a new hide set element */
165: HIDESET *newhide()
166: {
167: register HIDESET *hp;
168: register HIDEMEM *mp;
169: register int n;
170: if ((hp = hidefree) == NULL) {
171: n = 8;
172: hidefree = hp = new(n*sizeof(HIDESET));
173: while (--n > 0) {
174: hp->h_next_set = hp+1;
175: hp->h_this_set = NULL;
176: hp += 1;
177: }
178: hp->h_next_set = NULL;
179: hp->h_this_set = NULL;
180: hp = hidefree;
181: }
182: if ((mp = hp->h_this_set) == NULL) {
183: hidefree = hp->h_next_set;
184: hp->h_next_set = NULL;
185: return hp;
186: }
187: hp->h_this_set = mp->h_next_mem;
188: mp->h_this_mem = NULL;
189: mp->h_next_mem = NULL;
190: return mp;
191: }
192:
193: /* return the HIDESET corresponding to index x */
194: HIDEMEM *hideget(x) register int x;
195: {
196: register HIDESET *hp;
197: if ((x -= SET0) == 0)
198: return NULL;
199: for (hp = hidesets; --x > 0; hp = hp->h_next_set)
200: if (hp == NULL)
201: cbotch("impossible hide set");
202: return hp->h_this_set;
203: }
204:
205: /* Compare hidesets for equality */
206: hideeq(mp1, mp2) register HIDEMEM *mp1, *mp2;
207: {
208: for (;;) {
209: if (mp1 == NULL)
210: if (mp2 == NULL)
211: return 1;
212: else
213: return 0;
214: else if (mp2 == NULL)
215: return 0;
216: else if (mp1->h_this_mem != mp2->h_this_mem)
217: return 0;
218: mp1 = mp1->h_next_mem;
219: mp2 = mp2->h_next_mem;
220: }
221: }
222:
223: /* Enter a hideset into the universe and return its index */
224: hideent(mp) HIDEMEM *mp;
225: {
226: register HIDESET **hpp, *hp;
227: register int x;
228: HIDESET *tp;
229: tp = hp = newhide();
230: hp->h_this_set = mp;
231: x = SET0;
232: hpp = &hidesets;
233: while ((hp = *hpp) != NULL) {
234: ++x;
235: if (hideeq(hp->h_this_set, mp)) {
236: hp = tp;
237: hp->h_next_set = hidefree;
238: hidefree = hp;
239: return x;
240: }
241: hpp = &hp->h_next_set;
242: }
243: ++x;
244: *hpp = tp;
245: return x;
246: }
247:
248: HIDEMEM *hideapp(mp1, tp) HIDEMEM *mp1; TOK *tp;
249: {
250: register HIDEMEM **mp;
251: for (mp = &mp1; *mp != NULL; mp = &((*mp)->h_next_mem))
252: ;
253: *mp = newhide();
254: (*mp)->h_this_mem = tp;
255: return mp1;
256: }
257:
258: /* Return true if the current id[] is hidden */
259: hidden()
260: {
261: register HIDEMEM *mp;
262:
263: for (mp = hideget(idhide); mp != NULL; mp = mp->h_next_mem)
264: if (idp == mp->h_this_mem)
265: return 1;
266: return 0;
267: }
268:
269: /* Return the intersection of s1 and s2 */
270: hideint(s1, s2) int s1, s2;
271: {
272: register HIDEMEM *mp1, *mp2, *mp3;
273: if (s1 == SET0)
274: return s1;
275: if (s2 == SET0)
276: return s2;
277: if (s1 == -1) {
278: return s2;
279: }
280: if (s2 == -1)
281: return s1;
282: if (s1 == s2)
283: return s1;
284: mp1 = hideget(s1);
285: mp2 = hideget(s2);
286: mp3 = NULL;
287: while (mp1 != NULL && mp2 != NULL) {
288: if (mp1->h_this_mem == mp2->h_this_mem) {
289: mp3 = hideapp(mp3, mp1->h_this_mem);
290: mp1 = mp1->h_next_mem;
291: mp2 = mp2->h_next_mem;
292: continue;
293: }
294: if (mp1->h_this_mem < mp2->h_this_mem) {
295: mp1 = mp1->h_next_mem;
296: continue;
297: }
298: if (mp2->h_this_mem < mp1->h_this_mem) {
299: mp2 = mp2->h_next_mem;
300: continue;
301: }
302: }
303: return hideent(mp3);
304: }
305:
306: /* Return the union of s1 and s2 */
307: hideaug(s1, s2) int s1, s2;
308: {
309: register HIDEMEM *mp1, *mp2, *mp3;
310: if (s1 == SET0)
311: return s2;
312: if (s2 == SET0)
313: return s1;
314: mp1 = hideget(s1);
315: mp2 = hideget(s2);
316: mp3 = NULL;
317: while (mp1 != NULL || mp2 != NULL) {
318: if (mp1 == NULL) {
319: mp3 = hideapp(mp3, mp2->h_this_mem);
320: mp2 = mp2->h_next_mem;
321: continue;
322: }
323: if (mp2 == NULL) {
324: mp3 = hideapp(mp3, mp1->h_this_mem);
325: mp1 = mp1->h_next_mem;
326: continue;
327: }
328: if (mp1->h_this_mem == mp2->h_this_mem) {
329: mp3 = hideapp(mp3, mp1->h_this_mem);
330: mp1 = mp1->h_next_mem;
331: mp2 = mp2->h_next_mem;
332: continue;
333: }
334: if (mp1->h_this_mem < mp2->h_this_mem) {
335: mp3 = hideapp(mp3, mp1->h_this_mem);
336: mp1 = mp1->h_next_mem;
337: continue;
338: }
339: if (mp2->h_this_mem < mp1->h_this_mem) {
340: mp3 = hideapp(mp3, mp2->h_this_mem);
341: mp2 = mp2->h_next_mem;
342: continue;
343: }
344: }
345: return hideent(mp3);
346: }
347:
348: /* Return the hide set for tp */
349: hideset(tp) register TOK *tp;
350: {
351: /* Determine if we are at source file level */
352: {
353: register DSTACK *dsp;
354: for (dsp = dstackp; dsp < dstack+NDLEV; dsp += 1)
355: if (dsp->ds_type == DS_NAME)
356: goto part2;
357: }
358: /* Release the previous hide set universe */
359: if (hidesets != NULL) {
360: register HIDESET **pp, *hp;
361: for (pp = &hidesets; (hp = *pp) != NULL; pp = &hp->h_next_set)
362: ;
363: *pp = hidefree;
364: hidefree = hidesets;
365: hidesets = NULL;
366: }
367: part2: return hideent(hideapp(NULL, tp));
368: }
369:
370: /*
371: * The following four functions
372: * are called from cc0 main().
373: * Install a new symbol with given value.
374: * -Dname=value
375: */
376: cppd(name, value) char *name, *value;
377: {
378: register CPPSYM *sp;
379:
380: setid(name);
381: sp = newcpp(-1, value, strlen(value)+1);
382: sp->s_sp = idp->t_sym;
383: idp->t_sym = sp;
384: }
385:
386: /*
387: * Undefine a cpp symbol.
388: * -Uname
389: */
390: cppu(name) char *name;
391: {
392: setid(name);
393: undefine();
394: }
395:
396: /*
397: * Add a directory to the list to be searched for include files.
398: * -Ipath
399: */
400: cppi(path) char *path;
401: {
402: if (ndirs >= NDIRS)
403: cfatal("too many directories in include list");
404: incdirs[ndirs++] = path;
405: }
406:
407: /*
408: * cpp loop for generating
409: * preprocessed text files.
410: * isvariant(VCPP) != 0
411: */
412: cppwork()
413: {
414: register int c, d;
415: register char *p;
416: register int myline;
417: register char *myfile;
418: myfile = file;
419: myline = line;
420: while ((c = get()) >= 0) {
421: switch (ct[c]) {
422: case ID:
423: if (expand(c))
424: continue;
425: for (p = id; c = *p++; putc(c, ofp));
426: continue;
427: case QUOTE:
428: case STRING:
429: putc(c, ofp);
430: instring = c;
431: while ((d = get()) >= 0 && d != c) {
432: putc(d, ofp);
433: if (d == '\\')
434: putc(get(), ofp);
435: }
436: instring = 0;
437: if (d < 0)
438: cerror("EOF in string");
439: else
440: putc(d, ofp);
441: continue;
442: default:
443: putc(c, ofp);
444: if (c != '\n')
445: continue;
446: if (myfile != file) {
447: myfile = file;
448: myline = line;
449: continue;
450: }
451: if (++myline == line)
452: continue;
453: myline = line;
454: if (notvariant(VCPPE))
455: fprintf(ofp, "#line %d\n", line);
456: continue;
457: }
458: }
459: }
460:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.