![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lcc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / etc|
Return to lcc.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / etc |
1.1 root 1: /*
2: * lcc [ option ]... [ file | -llib ]...
3: * front end for the ANSI C compiler
4: */
5: /* Fri Feb 5 07:56:38 EST 1993 */
6: #define VERSION ((2<<8)|0)
7:
8: #include <stdio.h>
9: #include <ctype.h>
10: #include <signal.h>
11:
12: #ifndef TEMPDIR
13: #define TEMPDIR "/tmp"
14: #endif
15:
16: typedef struct list *List;
17: struct list { /* circular list nodes: */
18: char *str; /* option or file name */
19: List link; /* next list element */
20: };
21:
22: #if __LCC__ || __STDC__
23: #include <stdlib.h>
24: #include <string.h>
25: #include <assert.h>
26: #define dclproto(func,args) func args
27: dclproto(static void interrupt,(int));
28: #else
29: #define assert(e) ((void)((e)||(fprintf(stderr, "assertion failed: file %s, line %d\n", \
30: __FILE__, __LINE__), abort(), 0)))
31: #define dclproto(func,args) func()
32: dclproto(static void interrupt,());
33: #endif
34:
35: dclproto(static char *alloc,(int));
36: dclproto(static List append,(char *,List));
37: dclproto(extern char *basename,(char *));
38: dclproto(static int callsys,(char *[]));
39: dclproto(extern char *concat,(char *, char *));
40: dclproto(static int compile,(char *, char *));
41: dclproto(static void compose,(char *[], List, List, List));
42: dclproto(static void cprint,(char *[], char *));
43: dclproto(static void error,(char *, char *));
44: dclproto(static void execute,(char *[]));
45: dclproto(static int exists,(char *));
46: dclproto(static int filename,(char *, char *));
47: dclproto(static List find,(char *, List));
48: dclproto(static void opt,(char *));
49: dclproto(static void rm,(List));
50: dclproto(extern char *strsave,(char *));
51: dclproto(extern int suffix,(char *));
52:
53: dclproto(extern int execv,(char *, char *[]));
54: dclproto(extern int fork,(void));
55: dclproto(extern int close,(int));
56: dclproto(extern int dup,(int));
57: dclproto(extern int fork,(void));
58: dclproto(extern int getpid,(void));
59: dclproto(extern int open,(char *, int));
60: dclproto(extern int pipe,(int[]));
61: dclproto(extern int read,(int, char *, int));
62: dclproto(extern int unlink,(char *));
63: dclproto(extern int wait,(int*));
64:
65: extern char *cpp[], *include[], *com[], *as[],*ld[];
66: dclproto(extern int option,(char *));
67:
68: static int errcnt; /* number of errors */
69: static int Eflag; /* -E specified */
70: static int Sflag; /* -S specified */
71: static int cflag; /* -c specified */
72: static int verbose; /* incremented for each -v */
73: static List llist[2]; /* loader files, flags */
74: static List alist; /* assembler flags */
75: static List clist; /* compiler flags */
76: static List plist; /* preprocessor flags */
77: static List rmlist; /* list of files to remove */
78: static char *outfile; /* ld output file or -[cS] object file */
79: static int ac; /* argument count */
80: static char **av; /* argument vector */
81: static char tempname[sizeof TEMPDIR + 15]; /* temporary .s file */
82: static char *progname;
83:
84: main(argc, argv) char *argv[]; {
85: int i, j, nf;
86:
87: progname = argv[0];
88: ac = argc + 50;
89: av = (char **)alloc(ac*sizeof(char *));
90: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
91: signal(SIGINT, interrupt);
92: if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
93: signal(SIGTERM, interrupt);
94: #ifdef SIGHUP
95: if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
96: signal(SIGHUP, interrupt);
97: #endif
98: sprintf(tempname, "%s/lcc%05d.s", TEMPDIR, getpid());
99: rmlist = append(tempname, rmlist);
100: plist = append("-D__LCC__", append("-Dunix", 0));
101: for (nf = 0, i = j = 1; i < argc; i++) {
102: if (strcmp(argv[i], "-o") == 0) {
103: if (++i < argc) {
104: if (strchr("ci", suffix(argv[i]))) {
105: error("-o would overwrite %s", argv[i]);
106: exit(8);
107: }
108: outfile = argv[i];
109: continue;
110: } else {
111: error("unrecognized option `%s'", argv[i]);
112: exit(8);
113: }
114: #ifdef sun
115: } else if (strcmp(argv[i], "-target") == 0) {
116: if (argv[i+1] && *argv[i+1] != '-')
117: i++;
118: continue;
119: #endif
120: } else if (*argv[i] == '-' && argv[i][1] != 'l') {
121: opt(argv[i]);
122: continue;
123: } else if (*argv[i] != '-' && strchr("csi", suffix(argv[i])))
124: nf++;
125: argv[j++] = argv[i];
126: }
127: if ((cflag || Sflag) && outfile && nf != 1) {
128: fprintf(stderr, "%s: -o %s ignored\n", progname, outfile);
129: outfile = 0;
130: }
131: argv[j] = 0;
132: for (i = 0; include[i]; i++)
133: plist = append(include[i], plist);
134: for (i = 1; argv[i]; i++)
135: if (*argv[i] == '-')
136: opt(argv[i]);
137: else {
138: if (nf > 1 && strchr("csi", suffix(argv[i]))) {
139: fprintf(stderr, "%s:\n", argv[i]);
140: fflush(stdout);
141: }
142: filename(argv[i], 0);
143: }
144: if (errcnt == 0 && !Eflag && !Sflag && !cflag && llist[1]) {
145: if (i == 2 && strchr("csi", suffix(argv[1])))
146: rmlist = append(concat(basename(argv[1]), ".o"), rmlist);
147: compose(ld, llist[0], llist[1], append(outfile ? outfile : "a.out", 0));
148: if (callsys(av))
149: errcnt++;
150: }
151: rm(rmlist);
152: exit(errcnt > 0);
153: }
154:
155: /* alloc - allocate n bytes or die */
156: static char *alloc(n) {
157: static char *avail, *limit;
158:
159: n = (n + sizeof(char *) - 1)&~(sizeof(char *) - 1);
160: if (avail + n >= limit) {
161: avail = (char *)malloc(n + 4*1024);
162: assert(avail);
163: limit = avail + n + 4*1024;
164: }
165: avail += n;
166: return avail - n;
167: }
168:
169: /* append - append a node with string str onto list, return new list */
170: static List append(str, list) char *str; List list; {
171: List p = (List) alloc(sizeof *p);
172:
173: p->str = str;
174: if (list) {
175: p->link = list->link;
176: list->link = p;
177: } else
178: p->link = p;
179: return p;
180: }
181:
182: /* basename - return base name for name, e.g. /usr/drh/foo.c => foo */
183: char *basename(name) char *name; {
184: char *s, *b, *t = 0;
185:
186: for (b = s = name; *s; s++)
187: if (*s == '/') {
188: b = s + 1;
189: t = 0;
190: } else if (*s == '.')
191: t = s;
192: s = strsave(b);
193: if (t)
194: s[t-b] = 0;
195: return s;
196: }
197:
198: /* callsys - fork and execute the command described by argv[0...], return status */
199: static int callsys(argv) char **argv; {
200: int n, m = 0, status = 0, pid;
201:
202: cprint(argv, 0);
203: if (verbose >= 2)
204: return 0;
205: switch (pid = fork()) {
206: case -1:
207: fprintf(stderr, "%s: no more processes\n", progname);
208: return 100;
209: case 0:
210: execute(argv);
211: }
212: while ((n = wait(&m)) != pid && n != -1)
213: status |= m;
214: status |= m;
215: if (status&0377) {
216: fprintf(stderr, "%s: fatal error in %s\n", progname, argv[0]);
217: status |= 0400;
218: }
219: return (status>>8)&0377;
220: }
221:
222: /* concat - return concatenation of strings s1 and s2 */
223: char *concat(s1, s2) char *s1, *s2; {
224: int n = strlen(s1);
225: char *s = alloc(n + strlen(s2) + 1);
226:
227: strcpy(s, s1);
228: strcpy(s + n, s2);
229: return s;
230: }
231:
232: /* compile - compile src into dst, return status */
233: static int compile(src, dst) char *src, *dst; {
234: int n, status;
235:
236: compose(com, clist, append(src, 0), append(dst, 0));
237: status = callsys(av);
238: if (status && *src == '-') {
239: char buf[1024];
240: while ((n = read(0, buf, sizeof buf)) > 0)
241: ;
242: }
243: return status;
244: }
245:
246: /* compose - compose cmd into av substituting a, b, c for $1, $2, $3, resp. */
247: static void compose(cmd, a, b, c) char *cmd[]; List a, b, c; {
248: int i, j;
249: List lists[3];
250:
251: lists[0] = a;
252: lists[1] = b;
253: lists[2] = c;
254: for (i = j = 0; cmd[i]; i++)
255: if (cmd[i][0] == '$' && isdigit(cmd[i][1])) {
256: int k = cmd[i][1] - '0';
257: assert(k >= 1 && k <= 3);
258: if (b = lists[k-1])
259: do {
260: b = b->link;
261: assert(j < ac);
262: av[j++] = b->str;
263: } while (b != lists[k-1]);
264: } else if (*cmd[i]) {
265: assert(j < ac);
266: av[j++] = cmd[i];
267: }
268: av[j] = 0;
269: }
270:
271: /* cprint - print the command described by argv[0...] followed by str or \n */
272: static void cprint(argv, str) char *argv[], *str; {
273: if (verbose) {
274: fprintf(stderr, "%s", *argv++);
275: while (*argv)
276: fprintf(stderr, " %s", *argv++);
277: if (str == 0)
278: str = "\n";
279: fprintf(stderr, str);
280: }
281: }
282:
283: /* error - issue error msg according to fmt, bump error count */
284: static void error(fmt, msg) char *fmt, *msg; {
285: fprintf(stderr, "%s: ", progname);
286: fprintf(stderr, fmt, msg);
287: fprintf(stderr, "\n");
288: errcnt++;
289: }
290:
291: /* execute - replace this process by the command described by argv[0...] */
292: static void execute(argv) char *argv[]; {
293: if (verbose >= 2)
294: return;
295: execv(argv[0], argv);
296: fprintf(stderr, "%s: can't execute `%s'\n", progname, argv[0]);
297: fflush(stdout);
298: exit(100);
299: }
300:
301: /* exists - is `name' readable? issue message if not */
302: static int exists(name) char *name; {
303: if (verbose > 1 || access(name, 4) == 0)
304: return 1;
305: error("can't read `%s'", name);
306: return 0;
307: }
308:
309: /* filename - process file name argument `name', return status */
310: static int filename(name, base) char *name, *base; {
311: int status = 0;
312:
313: if (base == 0)
314: base = basename(name);
315: switch (suffix(name)) {
316: case 'c':
317: if (!exists(name))
318: break;
319: compose(cpp, plist, append(name, 0), 0);
320: if (Eflag) {
321: status = callsys(av);
322: break;
323: }
324: cprint(av, " | ");
325: if (verbose <= 1) {
326: int fd[2], pid;
327: if (pipe(fd) < 0) {
328: error("can't create preprocessor-compiler pipe\n", 0);
329: exit(1);
330: }
331: switch (pid = fork()) {
332: case -1:
333: fprintf(stderr, "%s: no more processes\n", progname);
334: return 100;
335: case 0:
336: close(1);
337: dup(fd[1]);
338: close(fd[0]);
339: close(fd[1]);
340: execute(av);
341: assert(0); /* no return from execute */
342: }
343: close(0);
344: dup(fd[0]);
345: close(fd[0]);
346: close(fd[1]);
347: }
348: if (Sflag)
349: status = compile("-", outfile ? outfile : concat(base, ".s"));
350: else if ((status = compile("-", tempname)) == 0)
351: return filename(tempname, base);
352: break;
353: case 'i':
354: if (!exists(name) || Eflag)
355: break;
356: if (Sflag)
357: status = compile(name, outfile ? outfile : concat(base, ".s"));
358: else if ((status = compile(name, tempname)) == 0)
359: return filename(tempname, base);
360: break;
361: case 's':
362: if (Eflag)
363: break;
364: if (!Sflag) {
365: char *ofile = cflag && outfile ? outfile : concat(base, ".o");
366: compose(as, alist, append(name, 0), append(ofile, 0));
367: status = callsys(av);
368: if (!find(ofile, llist[1]))
369: llist[1] = append(ofile, llist[1]);
370: }
371: break;
372: case 'o':
373: if (!find(name, llist[1]))
374: llist[1] = append(name, llist[1]);
375: break;
376: case -1:
377: if (Eflag) {
378: compose(cpp, plist, append(name, 0), 0);
379: status = callsys(av);
380: } /* else fall thru */
381: default:
382: llist[1] = append(name, llist[1]);
383: break;
384: }
385: if (status)
386: errcnt++;
387: return status;
388: }
389:
390: /* find - find 1st occurrence of str in list, return list node or 0 */
391: static List find(str, list) char *str; List list; {
392: List b;
393:
394: if (b = list)
395: do {
396: if (strcmp(str, b->str) == 0)
397: return b;
398: } while ((b = b->link) != list);
399: return 0;
400: }
401:
402: static
403: void
404: interrupt(n) {
405: rm(rmlist);
406: exit(n = 100);
407: }
408:
409: /* opt - process option in arg */
410: static void opt(arg) char *arg; {
411: switch (arg[1]) { /* multi-character options */
412: case 'W': /* -Wxarg */
413: if (arg[2] && arg[3])
414: switch (arg[2]) {
415: case 'o':
416: if (option(&arg[3]))
417: return;
418: break;
419: case 'p':
420: plist = append(&arg[3], plist);
421: return;
422: case 'f':
423: if (strcmp(&arg[3], "-C") || option("-b")) {
424: clist = append(&arg[3], clist);
425: return;
426: }
427: break; /* and fall thru */
428: case 'a':
429: alist = append(&arg[3], alist);
430: return;
431: case 'l':
432: llist[0] = append(&arg[3], llist[0]);
433: return;
434: }
435: fprintf(stderr, "%s: %s ignored\n", progname, arg);
436: return;
437: case 'd': /* -dn */
438: arg[1] = 's';
439: /* fall thru */
440: case 't': /* -t -tname */
441: clist = append(arg, clist);
442: return;
443: #ifdef sun
444: case 'f': /* -f68881 */
445: if (!option(arg))
446: fprintf(stderr, "%s: %s ignored\n", progname, arg);
447: return;
448: #endif
449: case 'p': /* -p -pg */
450: if (option(arg))
451: clist = append(arg, clist);
452: else
453: fprintf(stderr, "%s: %s ignored\n", progname, arg);
454: return;
455: case 'D': /* -Dname -Dname=def */
456: case 'U': /* -Uname */
457: case 'I': /* -Idir */
458: plist = append(arg, plist);
459: return;
460: case 'B': /* -Bdir/ -Bstatic -Bdynamic */
461: #ifdef sun
462: if (strcmp(arg, "-Bstatic") == 0 || strcmp(arg, "-Bdynamic") == 0)
463: llist[1] = append(arg, llist[1]);
464: else
465: #endif
466: {
467: static char *path;
468: if (path)
469: error("-B overwrites earlier option", 0);
470: path = arg + 2;
471: com[0] = concat(path, "rcc");
472: if (path[0] == 0)
473: error("missing directory in -B option", 0);
474: }
475: return;
476: }
477: if (arg[2] == 0)
478: switch (arg[1]) { /* single-character options */
479: case 'S':
480: Sflag++;
481: return;
482: case 'O':
483: fprintf(stderr, "%s: %s ignored\n", progname, arg);
484: return;
485: case 'A': case 'n': case 'w': case 'P':
486: clist = append(arg, clist);
487: return;
488: case 'g': case 'b':
489: if (option(arg))
490: clist = append(arg[1] == 'g' ? "-g2" : arg, clist);
491: else
492: fprintf(stderr, "%s: %s ignored\n", progname, arg);
493: return;
494: case 'G':
495: if (option(arg)) {
496: clist = append("-g3", clist);
497: llist[0] = append("-N", llist[0]);
498: } else
499: fprintf(stderr, "%s: %s ignored\n", progname, arg);
500: return;
501: case 'E':
502: Eflag++;
503: return;
504: case 'c':
505: cflag++;
506: return;
507: case 'C':
508: plist = append(arg, plist);
509: return;
510: case 'N':
511: if (strcmp(basename(cpp[0]), "gcc-cpp") == 0)
512: plist = append("-nostdinc", plist);
513: include[0] = 0;
514: return;
515: case 'v':
516: if (verbose++ == 0) {
517: if (strcmp(basename(cpp[0]), "gcc-cpp") == 0)
518: plist = append(arg, plist);
519: clist = append(arg, clist);
520: fprintf(stderr, "%s version %d.%d\n", progname, VERSION>>8, VERSION&0xff);
521: }
522: return;
523: }
524: if (cflag || Sflag || Eflag)
525: fprintf(stderr, "%s: %s ignored\n", progname, arg);
526: else
527: llist[1] = append(arg, llist[1]);
528: }
529:
530: /* rm - remove files in list */
531: static void rm(list) List list; {
532: if (list) {
533: List b = list;
534: if (verbose)
535: fprintf(stderr, "rm");
536: do {
537: if (verbose)
538: fprintf(stderr, " %s", b->str);
539: unlink(b->str);
540: } while ((b = b->link) != list);
541: if (verbose)
542: fprintf(stderr, "\n");
543: }
544: }
545:
546: /* strsave - return a saved copy of string str */
547: char *strsave(str) char *str; {
548: return (char *)strcpy(alloc(strlen(str)+1), str);
549: }
550:
551: /* suffix - return the 1-character suffix of name, e.g. /usr/drh/foo.c => 'c' */
552: int suffix(name) char *name; {
553: char *t = 0, *s;
554:
555: for (s = name; *s; s++)
556: if (*s == '/')
557: t = 0;
558: else if (*s == '.')
559: t = s + 1;
560: if (t && t[1] == 0)
561: return t[0];
562: return -1;
563: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.