![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / bin|
Return to cc.c CVS log | Up to [CSRG BSD Unix] / 42BSD / bin |
1.1 root 1: static char sccsid[] = "@(#)cc.c 4.7 7/1/83";
2: /*
3: * cc - front end for C compiler
4: */
5: #include <sys/param.h>
6: #include <stdio.h>
7: #include <ctype.h>
8: #include <signal.h>
9: #include <sys/dir.h>
10:
11: char *cpp = "/lib/cpp";
12: char *ccom = "/lib/ccom";
13: char *c2 = "/lib/c2";
14: char *as = "/bin/as";
15: char *ld = "/bin/ld";
16: char *crt0 = "/lib/crt0.o";
17:
18: char tmp0[30]; /* big enough for /tmp/ctm%05.5d */
19: char *tmp1, *tmp2, *tmp3, *tmp4, *tmp5;
20: char *outfile;
21: char *savestr(), *strspl(), *setsuf();
22: int idexit();
23: char **av, **clist, **llist, **plist;
24: int cflag, eflag, oflag, pflag, sflag, wflag, Rflag, exflag, proflag;
25: int gflag, Gflag;
26: char *dflag;
27: int exfail;
28: char *chpass;
29: char *npassname;
30:
31: int nc, nl, np, nxo, na;
32:
33: #define cunlink(s) if (s) unlink(s)
34:
35: main(argc, argv)
36: char **argv;
37: {
38: char *t;
39: char *assource;
40: int i, j, c;
41:
42: /* ld currently adds upto 5 args; 10 is room to spare */
43: av = (char **)calloc(argc+10, sizeof (char **));
44: clist = (char **)calloc(argc, sizeof (char **));
45: llist = (char **)calloc(argc, sizeof (char **));
46: plist = (char **)calloc(argc, sizeof (char **));
47: for (i = 1; i < argc; i++) {
48: if (*argv[i] == '-') switch (argv[i][1]) {
49:
50: case 'S':
51: sflag++;
52: cflag++;
53: continue;
54: case 'o':
55: if (++i < argc) {
56: outfile = argv[i];
57: switch (getsuf(outfile)) {
58:
59: case 'c':
60: case 'o':
61: error("-o would overwrite %s",
62: outfile);
63: exit(8);
64: }
65: }
66: continue;
67: case 'R':
68: Rflag++;
69: continue;
70: case 'O':
71: oflag++;
72: continue;
73: case 'p':
74: proflag++;
75: crt0 = "/lib/mcrt0.o";
76: if (argv[i][2] == 'g')
77: crt0 = "/usr/lib/gcrt0.o";
78: continue;
79: case 'g':
80: if (argv[i][2] == 'o') {
81: Gflag++; /* old format for -go */
82: } else {
83: gflag++; /* new format for -g */
84: }
85: continue;
86: case 'w':
87: wflag++;
88: continue;
89: case 'E':
90: exflag++;
91: case 'P':
92: pflag++;
93: if (argv[i][1]=='P')
94: fprintf(stderr,
95: "cc: warning: -P option obsolete; you should use -E instead\n");
96: plist[np++] = argv[i];
97: case 'c':
98: cflag++;
99: continue;
100: case 'D':
101: case 'I':
102: case 'U':
103: case 'C':
104: plist[np++] = argv[i];
105: continue;
106: case 't':
107: if (chpass)
108: error("-t overwrites earlier option", 0);
109: chpass = argv[i]+2;
110: if (chpass[0]==0)
111: chpass = "012p";
112: continue;
113: case 'B':
114: if (npassname)
115: error("-B overwrites earlier option", 0);
116: npassname = argv[i]+2;
117: if (npassname[0]==0)
118: npassname = "/usr/c/o";
119: continue;
120: case 'd':
121: dflag = argv[i];
122: continue;
123: }
124: t = argv[i];
125: c = getsuf(t);
126: if (c=='c' || c=='s' || exflag) {
127: clist[nc++] = t;
128: t = setsuf(t, 'o');
129: }
130: if (nodup(llist, t)) {
131: llist[nl++] = t;
132: if (getsuf(t)=='o')
133: nxo++;
134: }
135: }
136: if (gflag || Gflag) {
137: if (oflag)
138: fprintf(stderr, "cc: warning: -g disables -O\n");
139: oflag = 0;
140: }
141: if (npassname && chpass ==0)
142: chpass = "012p";
143: if (chpass && npassname==0)
144: npassname = "/usr/new";
145: if (chpass)
146: for (t=chpass; *t; t++) {
147: switch (*t) {
148:
149: case '0':
150: ccom = strspl(npassname, "ccom");
151: continue;
152: case '2':
153: c2 = strspl(npassname, "c2");
154: continue;
155: case 'p':
156: cpp = strspl(npassname, "cpp");
157: continue;
158: }
159: }
160: if (nc==0)
161: goto nocom;
162: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
163: signal(SIGINT, idexit);
164: if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
165: signal(SIGTERM, idexit);
166: if (pflag==0)
167: sprintf(tmp0, "/tmp/ctm%05.5d", getpid());
168: tmp1 = strspl(tmp0, "1");
169: tmp2 = strspl(tmp0, "2");
170: tmp3 = strspl(tmp0, "3");
171: if (pflag==0)
172: tmp4 = strspl(tmp0, "4");
173: if (oflag)
174: tmp5 = strspl(tmp0, "5");
175: for (i=0; i<nc; i++) {
176: if (nc > 1) {
177: printf("%s:\n", clist[i]);
178: fflush(stdout);
179: }
180: if (getsuf(clist[i]) == 's') {
181: assource = clist[i];
182: goto assemble;
183: } else
184: assource = tmp3;
185: if (pflag)
186: tmp4 = setsuf(clist[i], 'i');
187: av[0] = "cpp"; av[1] = clist[i]; av[2] = exflag ? "-" : tmp4;
188: na = 3;
189: for (j = 0; j < np; j++)
190: av[na++] = plist[j];
191: av[na++] = 0;
192: if (callsys(cpp, av)) {
193: exfail++;
194: eflag++;
195: }
196: if (pflag || exfail) {
197: cflag++;
198: continue;
199: }
200: if (sflag)
201: assource = tmp3 = setsuf(clist[i], 's');
202: av[0] = "ccom"; av[1] = tmp4; av[2] = oflag?tmp5:tmp3; na = 3;
203: if (proflag)
204: av[na++] = "-XP";
205: if (gflag) {
206: av[na++] = "-Xg";
207: } else if (Gflag) {
208: av[na++] = "-XG";
209: }
210: if (wflag)
211: av[na++] = "-w";
212: av[na] = 0;
213: if (callsys(ccom, av)) {
214: cflag++;
215: eflag++;
216: continue;
217: }
218: if (oflag) {
219: av[0] = "c2"; av[1] = tmp5; av[2] = tmp3; av[3] = 0;
220: if (callsys(c2, av)) {
221: unlink(tmp3);
222: tmp3 = assource = tmp5;
223: } else
224: unlink(tmp5);
225: }
226: if (sflag)
227: continue;
228: assemble:
229: cunlink(tmp1); cunlink(tmp2); cunlink(tmp4);
230: av[0] = "as"; av[1] = "-o"; av[2] = setsuf(clist[i], 'o');
231: na = 3;
232: if (Rflag)
233: av[na++] = "-R";
234: if (dflag)
235: av[na++] = dflag;
236: av[na++] = assource;
237: av[na] = 0;
238: if (callsys(as, av) > 1) {
239: cflag++;
240: eflag++;
241: continue;
242: }
243: }
244: nocom:
245: if (cflag==0 && nl!=0) {
246: i = 0;
247: av[0] = "ld"; av[1] = "-X"; av[2] = crt0; na = 3;
248: if (outfile) {
249: av[na++] = "-o";
250: av[na++] = outfile;
251: }
252: while (i < nl)
253: av[na++] = llist[i++];
254: if (gflag || Gflag)
255: av[na++] = "-lg";
256: if (proflag)
257: av[na++] = "-lc_p";
258: else
259: av[na++] = "-lc";
260: av[na++] = 0;
261: eflag |= callsys(ld, av);
262: if (nc==1 && nxo==1 && eflag==0)
263: unlink(setsuf(clist[0], 'o'));
264: }
265: dexit();
266: }
267:
268: idexit()
269: {
270:
271: eflag = 100;
272: dexit();
273: }
274:
275: dexit()
276: {
277:
278: if (!pflag) {
279: cunlink(tmp1);
280: cunlink(tmp2);
281: if (sflag==0)
282: cunlink(tmp3);
283: cunlink(tmp4);
284: cunlink(tmp5);
285: }
286: exit(eflag);
287: }
288:
289: error(s, x)
290: char *s, *x;
291: {
292: FILE *diag = exflag ? stderr : stdout;
293:
294: fprintf(diag, "cc: ");
295: fprintf(diag, s, x);
296: putc('\n', diag);
297: exfail++;
298: cflag++;
299: eflag++;
300: }
301:
302: getsuf(as)
303: char as[];
304: {
305: register int c;
306: register char *s;
307: register int t;
308:
309: s = as;
310: c = 0;
311: while (t = *s++)
312: if (t=='/')
313: c = 0;
314: else
315: c++;
316: s -= 3;
317: if (c <= MAXNAMLEN && c > 2 && *s++ == '.')
318: return (*s);
319: return (0);
320: }
321:
322: char *
323: setsuf(as, ch)
324: char *as;
325: {
326: register char *s, *s1;
327:
328: s = s1 = savestr(as);
329: while (*s)
330: if (*s++ == '/')
331: s1 = s;
332: s[-1] = ch;
333: return (s1);
334: }
335:
336: callsys(f, v)
337: char *f, **v;
338: {
339: int t, status;
340:
341: t = vfork();
342: if (t == -1) {
343: printf("No more processes\n");
344: return (100);
345: }
346: if (t == 0) {
347: execv(f, v);
348: printf("Can't find %s\n", f);
349: fflush(stdout);
350: _exit(100);
351: }
352: while (t != wait(&status))
353: ;
354: if ((t=(status&0377)) != 0 && t!=14) {
355: if (t!=2) {
356: printf("Fatal error in %s\n", f);
357: eflag = 8;
358: }
359: dexit();
360: }
361: return ((status>>8) & 0377);
362: }
363:
364: nodup(l, os)
365: char **l, *os;
366: {
367: register char *t, *s;
368: register int c;
369:
370: s = os;
371: if (getsuf(s) != 'o')
372: return (1);
373: while (t = *l++) {
374: while (c = *s++)
375: if (c != *t++)
376: break;
377: if (*t==0 && c==0)
378: return (0);
379: s = os;
380: }
381: return (1);
382: }
383:
384: #define NSAVETAB 1024
385: char *savetab;
386: int saveleft;
387:
388: char *
389: savestr(cp)
390: register char *cp;
391: {
392: register int len;
393:
394: len = strlen(cp) + 1;
395: if (len > saveleft) {
396: saveleft = NSAVETAB;
397: if (len > saveleft)
398: saveleft = len;
399: savetab = (char *)malloc(saveleft);
400: if (savetab == 0) {
401: fprintf(stderr, "ran out of memory (savestr)\n");
402: exit(1);
403: }
404: }
405: strncpy(savetab, cp, len);
406: cp = savetab;
407: savetab += len;
408: saveleft -= len;
409: return (cp);
410: }
411:
412: char *
413: strspl(left, right)
414: char *left, *right;
415: {
416: char buf[BUFSIZ];
417:
418: strcpy(buf, left);
419: strcat(buf, right);
420: return (savestr(buf));
421: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.