![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 3cc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs|
Return to 3cc.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs |
1.1 root 1: /*
2: * cc - front end for C compiler
3: */
4: #include <sys/types.h>
5: #include <stdio.h>
6: #include <ctype.h>
7: #include <signal.h>
8: #include <dir.h>
9:
10: char *cpp = "/lib/cpp";
11: char *ccom = "/usr/jerq/lib/m32/comp";
12: char *as = "/usr/jerq/bin/3as";
13: char *c2 = "/usr/jerq/lib/m32/optim";
14: char *ld = "/usr/jerq/bin/3ld";
15: char *ifile = "/usr/jerq/lib/muxmap";
16:
17: char tmp0[30]; /* big enough for /tmp/ctm%05.5d */
18: char *tmp1, *tmp2, *tmp3, *tmp4, *tmp5;
19: char *outfile;
20: char *savestr(), *strspl(), *setsuf();
21: int idexit();
22: char **av, **clist, **llist, **plist;
23: int cflag, eflag, gflag, pflag, sflag, Rflag, exflag, proflag, oflag;
24: int dont, jflag, mflag=1; /* default is to compile for mux(9) */
25: int exfail;
26: char *chpass;
27: char *npassname;
28: extern int optind;
29: extern int opterr;
30: extern char *optarg;
31: extern int optopt;
32:
33: int nc, nl, np, nxo, na;
34:
35: #define cunlink(x) if (x) unlink(x)
36:
37: main(argc, argv)
38: char **argv;
39: {
40: char *t;
41: char *assource;
42: int i, j, c;
43:
44: /* ld currently adds upto 5 args; 10 is room to spare */
45: /* I upped it anyway -- rob */
46: av = (char **)calloc(argc+20, sizeof (char **));
47: clist = (char **)calloc(argc+20, sizeof (char **));
48: llist = (char **)calloc(argc+20, sizeof (char **));
49: plist = (char **)calloc(argc+20, sizeof (char **));
50: opterr = 0;
51: while (optind<argc) switch (c = getopt(argc, argv, "dJmSo:ROPgEPcD:I:U:C:t:B:l:")) {
52: case 'd':
53: dont++;
54: continue;
55: case 'S':
56: sflag++;
57: cflag++;
58: continue;
59: case 'J':
60: jflag++;
61: case 'm':
62: mflag=0;
63: ifile = "/usr/jerq/lib/jxmap";
64: continue;
65: case 'l':
66: llist[nl++] = strspl("-l", optarg);
67: continue;
68: case 'o':
69: outfile = optarg;
70: switch (getsuf(outfile)) {
71:
72: case 'c':
73: case 'o':
74: error("-o would overwrite %s", outfile);
75: exit(8);
76: }
77: continue;
78: case 'R':
79: Rflag++;
80: continue;
81: case 'O':
82: oflag++;
83: continue;
84: case 'p':
85: proflag++;
86: continue;
87: case 'g':
88: gflag++;
89: continue;
90: case 'E':
91: exflag++;
92: cflag++;
93: continue;
94: case 'P':
95: pflag++;
96: case 'c':
97: cflag++;
98: continue;
99: case 'D':
100: case 'I':
101: case 'U':
102: case 'C':
103: plist[np] = strspl("-X", optarg);
104: plist[np++][1] = c;
105: continue;
106: case 't':
107: if (chpass)
108: error("-t overwrites earlier option", 0);
109: chpass = optarg;
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 = optarg;
117: if (npassname[0]==0)
118: npassname = "/usr/scj/mcc";
119: continue;
120: case '?':
121: t = strspl("-", "x");
122: t[1] = optopt;
123: llist[nl++] = t;
124: continue;
125:
126: case EOF:
127: t = argv[optind];
128: optind++;
129: c = getsuf(t);
130: if (c=='c' || c=='s' || c=='i' || exflag) {
131: clist[nc++] = t;
132: t = setsuf(t, 'o');
133: }
134: if (nodup(llist, t)) {
135: llist[nl++] = t;
136: if (getsuf(t)=='o')
137: nxo++;
138: }
139: }
140: if (npassname && chpass ==0)
141: chpass = "012p";
142: if (chpass && npassname==0)
143: npassname = "/usr/new";
144: if (chpass)
145: for (t=chpass; *t; t++) {
146: switch (*t) {
147:
148: case '0':
149: ccom = strspl(npassname, "comp");
150: continue;
151: case '2':
152: c2 = strspl(npassname, "optim");
153: continue;
154: case 'p':
155: cpp = strspl(npassname, "cpp");
156: continue;
157: }
158: }
159: if (proflag)
160: printf("3cc: no profiling option\n");
161: if (nc==0)
162: goto nocom;
163: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
164: signal(SIGINT, idexit);
165: if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
166: signal(SIGTERM, idexit);
167: if (pflag==0)
168: sprintf(tmp0, "/tmp/ctm%05.5d", getpid());
169: tmp1 = strspl(tmp0, "1");
170: tmp2 = strspl(tmp0, "2");
171: tmp3 = strspl(tmp0, "3");
172: if (pflag==0)
173: tmp4 = strspl(tmp0, "4");
174: if (oflag)
175: tmp5 = strspl(tmp0, "5");
176: for (i=0; i<nc; i++) {
177: int suffix = getsuf(clist[i]);
178: if (nc > 1) {
179: printf("%s:\n", clist[i]);
180: fflush(stdout);
181: }
182: if (suffix == 's') {
183: assource = clist[i];
184: goto assemble;
185: } else
186: assource = tmp3;
187: if (suffix == 'i')
188: goto compile;
189: if (pflag)
190: tmp4 = setsuf(clist[i], 'i');
191: na=0;
192: av[na++] = "cpp";
193: av[na++] = "-Uvax";
194: av[na++] = "-Usun";
195: av[na++] = "-Usun2";
196: av[na++] = "-Usun3";
197: av[na++] = "-Umc68000";
198: av[na++] = "-Umc68010";
199: av[na++] = "-Umc68020";
200: av[na++] = "-Dm32";
201: if(mflag)
202: av[na++] = "-DMUX";
203: for (j = 0; j < np; j++)
204: av[na++] = plist[j];
205: av[na++] = "-I/usr/jerq/include";
206: av[na++] = clist[i];
207: av[na++] = exflag ? "-" : tmp4;
208: av[na++] = 0;
209: switch(callsys(cpp, av)){
210: case 0:
211: break;
212: #define CLASS 27
213: case CLASS:
214: if(callsys("/lib/cpre", av)==0)
215: break;
216: /* fall through */
217: default:
218: exfail++;
219: eflag++;
220: }
221: if (pflag || exfail) {
222: cflag++;
223: continue;
224: }
225: compile:
226: if (sflag)
227: assource = tmp3 = setsuf(clist[i], 's');
228: av[0] = "3comp";
229: av[1] = "-i";
230: av[2] = suffix=='i'? clist[i]: tmp4;
231: av[3] = "-o";
232: av[4] = oflag? tmp5 : tmp3;
233: av[5] = "-f";
234: av[6] = clist[i];
235: if(gflag)
236: na = 7;
237: else{
238: av[7] = "-ds";
239: av[8] = "-dl";
240: na = 9;
241: }
242: av[na] = 0;
243: if (callsys(ccom, av)) {
244: cflag++;
245: eflag++;
246: continue;
247: }
248: if (oflag) {
249: av[0] = "3optim";
250: av[1] = "-I";
251: av[2] = tmp5;
252: av[3] = "-O";
253: av[4] = tmp3;
254: av[5] = 0;
255: if (callsys(c2, av)) {
256: unlink(tmp3);
257: tmp3 = assource = tmp5;
258: } else
259: unlink(tmp5);
260: }
261: if (sflag)
262: continue;
263: assemble:
264: cunlink(tmp1); cunlink(tmp2); cunlink(tmp4);
265: av[0] = "3as";
266: na = 1;
267: if(!gflag)
268: av[na++] = "-dl";
269: av[na++] = "-o"; av[na++] = setsuf(clist[i], 'o');
270: if (Rflag)
271: av[na++] = "-R";
272: av[na++] = assource;
273: av[na] = 0;
274: if (callsys(as, av) > 1) {
275: cflag++;
276: eflag++;
277: continue;
278: }
279: }
280: nocom:
281: if (cflag==0 && nl!=0) {
282: i = 0;
283: av[0] = "3ld"; na=1;
284: av[na++] = "-o";
285: av[na++] = outfile? outfile : "a.out";
286: av[na++] = "-L/usr/jerq/lib";
287: if (jflag)
288: av[na++] = "/usr/jerq/lib/rom.o";
289: av[na++] = ifile;
290: while (i < nl)
291: av[na++] = llist[i++];
292: if(mflag){
293: av[na++] = "-r";
294: av[na++] = "-a";
295: }
296: if(mflag)
297: av[na++] = "-lmj";
298: if(jflag){
299: av[na++] = "-lj";
300: av[na++] = "-lsys";
301: }
302: av[na++] = "-lj";
303: av[na++] = "-lc";
304: av[na++] = 0;
305: eflag |= callsys(ld, av);
306: if (nc==1 && nxo==1 && eflag==0)
307: unlink(setsuf(clist[0], 'o'));
308: if(!eflag && mflag){
309: int f=open(outfile? outfile : "a.out", 1);
310: short m=0x5620;
311: if(f==-1 || lseek(f, 22, 0)==-1 || write(f, &m, 2)!=2)
312: error("can't write magic number in %s",
313: outfile? outfile : "a.out");
314: else
315: close(f);
316: }
317: }
318: dexit();
319: }
320:
321: idexit()
322: {
323:
324: eflag = 100;
325: dexit();
326: }
327:
328: dexit()
329: {
330:
331: if (!pflag) {
332: cunlink(tmp1);
333: cunlink(tmp2);
334: if (sflag==0)
335: cunlink(tmp3);
336: cunlink(tmp4);
337: cunlink(tmp5);
338: }
339: exit(eflag);
340: }
341:
342: error(s, x)
343: char *s, *x;
344: {
345: FILE *diag = exflag ? stderr : stdout;
346:
347: fprintf(diag, "3cc: ");
348: fprintf(diag, s, x);
349: putc('\n', diag);
350: exfail++;
351: cflag++;
352: eflag++;
353: }
354:
355: getsuf(as)
356: char as[];
357: {
358: register int c;
359: register char *s;
360: register int t;
361:
362: s = as;
363: c = 0;
364: while (t = *s++)
365: if (t=='/')
366: c = 0;
367: else
368: c++;
369: s -= 3;
370: if (c <= DIRSIZ && c > 2 && *s++ == '.')
371: return (*s);
372: return (0);
373: }
374:
375: char *
376: setsuf(as, ch)
377: char *as;
378: {
379: register char *s, *s1;
380:
381: s = s1 = savestr(as);
382: while (*s)
383: if (*s++ == '/')
384: s1 = s;
385: s[-1] = ch;
386: return (s1);
387: }
388:
389: callsys(f, v)
390: char *f, **v;
391: {
392: int t, status;
393:
394: if(dont){
395: printf("3cc: (%s)", f);
396: while(*v)
397: printf(" %s", *v++);
398: printf("\n");
399: return 0;
400: }
401: t = fork();
402: if (t == -1) {
403: printf("No more processes\n");
404: return (100);
405: }
406: if (t == 0) {
407: execv(f, v);
408: printf("Can't find %s\n", f);
409: fflush(stdout);
410: _exit(100);
411: }
412: while (t != wait(&status))
413: ;
414: if ((t=(status&0377)) != 0 && t!=14) {
415: if (t!=2) {
416: printf("Fatal error in %s\n", f);
417: eflag = 8;
418: }
419: dexit();
420: }
421: return ((status>>8) & 0377);
422: }
423:
424: nodup(l, os)
425: char **l, *os;
426: {
427: register char *t, *s;
428: register int c;
429:
430: s = os;
431: if (getsuf(s) != 'o')
432: return (1);
433: while (t = *l++) {
434: while (c = *s++)
435: if (c != *t++)
436: break;
437: if (*t==0 && c==0)
438: return (0);
439: s = os;
440: }
441: return (1);
442: }
443:
444: #define NSAVETAB 1024
445: char *savetab;
446: int saveleft;
447:
448: char *
449: savestr(cp)
450: register char *cp;
451: {
452: register int len;
453:
454: len = strlen(cp) + 1;
455: if (len > saveleft) {
456: saveleft = NSAVETAB;
457: if (len > saveleft)
458: saveleft = len;
459: savetab = (char *)malloc(saveleft);
460: if (savetab == 0) {
461: fprintf(stderr, "ran out of memory (savestr)\n");
462: exit(1);
463: }
464: }
465: strncpy(savetab, cp, len);
466: cp = savetab;
467: savetab += len;
468: saveleft -= len;
469: return (cp);
470: }
471:
472: char *
473: strspl(left, right)
474: char *left, *right;
475: {
476: char buf[BUFSIZ];
477:
478: strcpy(buf, left);
479: strcat(buf, right);
480: return (savestr(buf));
481: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.