![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cc.c.sav CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / c / coh|
Return to cc.c.sav CVS log | Up to [MW Coherent from dump] / coherent / b / bin / c / coh |
1.1 root 1: /*
2: * coh/cc.c
3: * CC command.
4: * Compile, assemble and link edit C programs.
5: * A lot of grunge.
6: * Revised by rec may1987 to incorporate all
7: * coherent and gemdos revisions to date.
8: * Revised by steve 3/92 to produce monolithic COHERENT compiler.
9: *
10: * Defining VeryVflag will produce very verbose output under -VSTAT
11: * option
12: *
13: * C compiler/loader switch map.
14: * *7 marks a version seven documented option.
15: * *7d marks a defunct version seven option.
16: * *7c marks a changed version seven option.
17: * *u marks an option unrecognized by cc, ie passed to linker
18: * with no interpretation or processing.
19: *
20: * Still up for grabs:
21: * [ C FGH J R W Y ]
22: * [ b gh j m v yz]
23: *
24: * A run in auto edit mode
25: *7c Bstring use string to find compiler passes
26: *7 Dname[=value] preprocessor: #define
27: *7 E run preprocessor to stdout
28: *7 Ipathname preprocessor: #include search directory
29: * K keep intermediate files in name.[P012so]
30: * Lpathname loader: library directory specification
31: * Mstring use string as cross-compiler prefix
32: * N[01ab2sdlrt]string rename pass with string
33: *7 O run object code optimiser
34: *7d P put preprocessor output into name.i; use -Kqp
35: * Q be quiet, make no messages
36: *7 S make assembly language output in name.s
37: * T[value] use in-memory tempfiles of size value (default: 64K)
38: *7 Uname preprocessor: #undef
39: * V be verbose, report everything
40: * Vvariant enable variant
41: * X loader: remove c generated local symbols
42: * Z (GEMDOS) floppy change prompts for phases
43: * a do not implicit output file name to loader
44: *7 c compile but do not load
45: * d loader: define common space
46: *7 e name loader: entry point specification
47: *7c f fake floating point operations
48: *7u i loader: separate i and d spaces
49: * k[system] loader: bind as kernel process
50: *7c lname loader: library specification
51: *7u n loader: shared instruction space
52: *7 o name loader: output file name
53: *7 p generate code to profile function calls
54: * q[p012s] quit after specified pass
55: * r loader: retain relocation in output
56: * s loader: strip symbol table
57: *7c t[p012adlrt] take specified passes from -Bdirectory
58: *7 u name loader: enter name into symbol table
59: * w loader: watch
60: * x loader: remove local symbols from symbol table
61: */
62:
63: #if GEMDOS
64: #ifndef VERS
65: #define VERS "2.1"
66: #endif
67: #endif
68:
69: #include <stdio.h>
70: #include <setjmp.h>
71: #include <string.h>
72: #include <ctype.h>
73: #include <signal.h>
74: #include <path.h>
75: #include <errno.h>
76: #include "mch.h"
77: #include "host.h"
78: #include "ops.h"
79: #include "stream.h"
80: #undef NONE
81: #include "var.h"
82: #include "varmch.h"
83:
84: #ifndef VeryVflag
85: #define VeryVflag 0
86: #endif
87:
88: #ifndef PREFIX
89: #define PREFIX ""
90: #endif
91:
92: #if _I386
93: #define DTEFG "_dtefg"
94: #else
95: #define DTEFG "_dtefg_"
96: #endif
97:
98: /*
99: ** Pass information.
100: */
101: #define NONE -1
102: #define CPP 0 /* Pass index numbers */
103: #define CC0 1
104: #define CC1 2
105: #define CC2 3
106: #define CC3 4
107: #define CC4 5 /* Output writer postprocessor */
108: #define AS 6
109: #define LD 7
110: #define LD2 8 /* Loader postprocessor */
111: #define ED 9
112: #define LIB 10
113: #define CRT 11
114: #define TMP 12
115: #define ALL 13
116: #define CC2B 14 /* for monolithic compiler */
117:
118: #define P_TAKE 1 /* Take pass from backup directory */
119: #define P_BACK 2 /* Backup directory specified */
120: #define P_LIB 4 /* Take pass from LIBPATH */
121: #define P_BIN 8 /* Take pass from BIN */
122:
123: #define PTMP 16 /* Pass name buffer size */
124:
125: char dnul[] = ""; /* Global null string */
126: char dmch[PTMP] = PREFIX; /* Cross compiler prefix */
127:
128: struct pass {
129: char p_flag; /* Flags */
130: char p_psn; /* Pass short name */
131: char p_pln[PTMP]; /* Pass long name */
132: char p_pfs[4]; /* Pass output file suffix */
133: char *p_ifn; /* Input file name */
134: char *p_ofn; /* Output file name */
135: char *p_sfn; /* Scratch file name */
136: char *p_dir; /* Path lookup or backup string */
137: char *p_mch; /* Machine prefix name */
138: } pass[] = {
139: { P_LIB, 'p', "cpp", "i", NULL, NULL, NULL, NULL, dmch },
140: { P_LIB, '0', "cc0", "0", NULL, NULL, NULL, NULL, dmch },
141: { P_LIB, '1', "cc1", "1", NULL, NULL, NULL, NULL, dmch },
142: { P_LIB, '2', "cc2", "o", NULL, NULL, NULL, NULL, dmch },
143: { P_LIB, '3', "cc3", "s", NULL, NULL, NULL, NULL, dmch },
144: { P_LIB, '4', "cc4", "o", NULL, NULL, NULL, NULL, dmch },
145: { P_BIN, 's', "as", "o", NULL, NULL, NULL, NULL, dmch },
146: { P_BIN, 'd', "ld", "", NULL, NULL, NULL, NULL, dnul },
147: { P_BIN, 'x', "ld2", "", NULL, NULL, NULL, NULL, dnul },
148: { P_BIN, 'e', "me", "", NULL, NULL, NULL, NULL, dnul },
149: { P_LIB, 'l', "lib", "a", NULL, NULL, NULL, NULL, dmch },
150: { P_LIB, 'r', "crts0.o", "", NULL, NULL, NULL, NULL, dmch },
151: { 0, 't', "cc", "", NULL, NULL, NULL, NULL, dnul }
152: };
153:
154: /*
155: ** Option and argument information.
156: */
157: #define CCOPT 0x001 /* Argument flags in argf[] */
158: #define PPOPT 0x002 /* Also in option table, at least */
159: #define LDOPT 0x004 /* those that fit in a byte */
160: #define LD2OPT 0x008
161: #define CCLIB 0x010
162: #define LDLIB 0x020
163: #define CCARG 0x040
164: #define ASARG 0x080
165: #define MARG 0x100
166: #define LDARG 0x200
167:
168: /* Flag bits for ccvariant. */
169: #define FLAG_c 0x001 /* -c flag */
170: #define FLAG_O 0x002 /* -O flag */
171: #define FLAG_f 0x004 /* -f flag */
172: #define FLAG_K 0x008 /* -K or -VKEEP flag */
173: #define VS 0x010 /* Turn on strict messages */
174: #define VDB 0x020 /* Turn on debugging */
175: #define FLAG_A 0x040 /* Auto edit mode */
176: #define FLAG_Z 0x080 /* Floppy change prompts */
177: #define FLAG_V 0x100 /* Verbose flag */
178: #define FLAG_GEMAPP 0x200 /* Gem application compile */
179: #define FLAG_GEMACC 0x400 /* Gem accessory compile */
180: #define FLAG_a 0x800 /* Suppress output file name to ld */
181:
182: struct option { /* option table */
183: char o_kind;
184: char o_flag;
185: char *o_name;
186: int o_bits;
187: } option[] = {
188: /* Strict */
189: { 0, CCOPT, "VSUREG", VSUREG },
190: { 0, CCOPT, "VSUVAR", VSUVAR },
191: { 0, CCOPT, "VSNREG", VSNREG },
192: { 0, CCOPT, "VSRTVC", VSRTVC },
193: { 0, CCOPT, "VSMEMB", VSMEMB },
194: { 0, CCOPT, "VSBOOK", VSBOOK },
195: { 0, CCOPT, "VSLCON", VSLCON },
196: { 0, CCOPT, "VSPVAL", VSPVAL },
197: { 0, CCOPT, "VSCCON", VSCCON },
198: /* Debug */
199: { 0, CCOPT, "VDEBUG", VDEBUG },
200: { 0, CCOPT, "VDLINE", VLINES },
201: { 0, CCOPT, "VDTYPE", VTYPES },
202: { 0, CCOPT, "VDSYMB", VDSYMB },
203: { 0, CCOPT, "VDCALL", VCALLS },
204: /* Miscellaneous */
205: { 0, CCOPT, "VSTAT", VSTAT },
206: { 0, CCOPT, "VSINU", VSINU },
207: { 0, CCOPT, "VPEEP", VPEEP },
208: { 0, CCOPT, "VCOMM", VCOMM },
209: { 0, CCOPT, "VQUIET", VQUIET },
210: { 0, CCOPT, "VPSTR", VPSTR },
211: { 0, CCOPT, "VROM", VROM },
212: { 0, CCOPT, "VASM", VASM },
213: { 0, CCOPT, "VPROF", VPROF },
214: { 0, CCOPT, "VALIEN", VALIEN },
215: { 0, CCOPT, "VNOOPT", VNOOPT },
216: { 0, CCOPT, "VCHASM", VCHASM },
217: { 0, CCOPT, "VCPPC", VCPPC },
218: { 0, CCOPT, "VCPPE", VCPPE },
219: { 0, CCOPT, "VCPP", VCPP },
220: { 0, CCOPT, "VTPROF", VTPROF },
221: { 0, CCOPT, "V3GRAPH", V3GRAPH },
222: #if 1
223: /* Intel flags */
224: { 0, CCOPT, "VSMALL", VSMALL },
225: { 0, CCOPT, "VLARGE", VLARGE },
226: { 0, CCOPT, "V8087", V8087 },
227: { 0, CCOPT, "VRAM", VRAM },
228: { 0, CCOPT, "VOMF", VOMF },
229: { 0, CCOPT, "V80186", V80186 },
230: { 0, CCOPT, "V80287", V80287 },
231: { 0, CCOPT, "VALIGN", VALIGN },
232: { 0, CCOPT, "VEMU87", VEMU87 },
233: #endif
234: /* Motorola and Gemdos flags */
235: { 12, CCOPT, "VGEMACC", FLAG_GEMACC },
236: { 12, CCOPT, "VGEMAPP", FLAG_GEMAPP },
237: { 12, CCOPT, "VGEM", FLAG_GEMAPP },
238: { 10, CCOPT, "VSPLIM", VSPLIM },
239: { 10, CCOPT, "VNOTRAPS", VNOTRAPS },
240: /* More miscellaneous flags */
241: { 2, CCOPT, "VDB", VDB },
242: { 2, CCOPT, "VS", VS },
243: { 12, CCOPT, "A", FLAG_A },
244: { 12, CCOPT, "a", FLAG_a },
245: { 12, CCOPT, "Z", FLAG_Z },
246: { 12, CCOPT, "c", FLAG_c },
247: { 10, CCOPT, "S", VASM },
248: { 2, CCOPT, "O", FLAG_O },
249: { 0, CCOPT, "E", VCPPE },
250: { 12, CCOPT, "f", FLAG_f },
251: { 12, CCOPT, "VFLOAT", FLAG_f },
252: { 0, CCOPT, "p", VPROF },
253: { 12, CCOPT, "VKEEP", FLAG_K },
254: { 12, CCOPT, "K", FLAG_K },
255: { 0, CCOPT, "Q", VQUIET },
256: { 12, CCOPT, "V", FLAG_V },
257: { 12, CCOPT, "v", FLAG_V },
258: /* Preprocessor options */
259: { 3, PPOPT, "D" },
260: { 3, PPOPT, "I" },
261: { 3, PPOPT, "U" },
262: /* Loader options */
263: { 4, LDOPT, "d" },
264: { 4, LDOPT, "i" },
265: { 4, LDOPT, "n" },
266: { 5, LDOPT, "o" },
267: { 4, LDOPT, "r" },
268: { 4, LDOPT, "s" },
269: { 4, LDOPT, "w" },
270: { 4, LDOPT, "x" },
271: { 4, LDOPT, "X" },
272: #if 1
273: { 8, LDOPT, "L" },
274: #endif
275: { 5, LDOPT, "e" },
276: { 5, LDOPT, "k" },
277: { 5, LDOPT, "u" },
278: /* C dispatcher options */
279: { 6, CCOPT, "q" },
280: { 7, CCOPT, "t" },
281: { 7, CCOPT, "B" },
282: { 7, CCOPT, "M" },
283: { 7, CCOPT, "N" },
284: #if TEMPBUF
285: { 9, CCOPT, "T" },
286: #endif
287: { 8, CCLIB, "l" },
288:
289: { -1, -1, "" }
290: };
291:
292: int ccvariant = 0; /* Variant template */
293: VARIANT variant; /* Binary variant template */
294: char vstr[2*VMAXIM/VGRANU + 1]; /* Ascii variant string */
295: char vstr2[2*VMAXIM/VGRANU + 1]; /* Ascii variant string for .m */
296:
297: /*
298: ** Compiler parameters and flags
299: */
300: #define NCMDA 128 /* Size of argument pointer buffer */
301: #define NCMDB 1024 /* Size of argument buffer */
302: #define NTMP L_tmpnam /* Temp file buffer size, from stdio.h */
303: #define MAGIC 127 /* Exit status mask */
304: #define NSLEEP 10 /* # of sleeps */
305: #define DELAY 5 /* Sleep delay, seconds */
306:
307: int nldob; /* Number of objects created */
308: int nfile; /* Number of files to compile or assemble */
309: int nname; /* Number of file name arguments */
310: int ndota;
311: int ndotc;
312: int ndotm;
313: int ndoto;
314: int ndots;
315: int partial; /* Partial link specified */
316:
317: #define aflag ((ccvariant&FLAG_a)!=0)
318: #define cflag ((ccvariant&FLAG_c)!=0)
319: #define pflag isvariant(VPROF)
320: #define fflag ((ccvariant&FLAG_f)!=0)
321: #define Kflag ((ccvariant&FLAG_K)!=0)
322: #define Oflag ((ccvariant&FLAG_O)!=0)
323: #define Sflag isvariant(VASM)
324: #define Eflag isvariant(VCPPE)
325: #define Vflag ((ccvariant&FLAG_V)!=0)
326: #define Qflag isvariant(VQUIET)
327: #define Aflag ((ccvariant&FLAG_A)!=0)
328: #define Zflag ((ccvariant&FLAG_Z)!=0)
329: #define GEMAPPflag ((ccvariant&FLAG_GEMAPP)!=0)
330: #define GEMACCflag ((ccvariant&FLAG_GEMACC)!=0)
331:
332: int qpass = NONE; /* Quit after this pass */
333: int nload; /* No load phase */
334: char *outf; /* Output file */
335: char *doutf; /* Default output file stem */
336: char *dpath = DEFPATH;
337: char *dlibpath = DEFLIBPATH;
338: int xstat; /* Exit status */
339:
340: char *cmda[NCMDA]; /* Argument pointer buffer */
341: char cmdb[NCMDB]; /* Argument buffer */
342: char newo[NTMP]; /* New object to be removed */
343: char tmp[7][NTMP]; /* Intermediate filenames */
344: char istmp[7]; /* Truth about their temporariness */
345: int argf[NCMDA]; /* Argument flags */
346: char optb[NCMDB]; /* Option rewrite buffer */
347: char *optp = &optb[0]; /* Option rewrite position */
348:
349: #if TEMPBUF
350: unsigned char *inbuf; /* memory input buffer */
351: unsigned char *inbufp; /* input buffer pointer */
352: unsigned char *inbufmax; /* input buffer end */
353: unsigned char *outbuf; /* memory output buffer */
354: unsigned char *outbufp; /* output buffer pointer */
355: unsigned char *outbufmax; /* output buffer end */
356: unsigned int tempsize = 65536; /* memory buffer size */
357: #endif
358:
359: #if MONOLITHIC
360: /* Information passed to phases through globals in monolithic compiler */
361: jmp_buf death; /* for fatal error handling */
362: int dotseg; /* current segment */
363: char file[NFNAME]; /* input file name buffer */
364: char id[NCSYMB]; /* global identifier buffer */
365: FILE *ifp; /* input FILE */
366: int line; /* line number */
367: int mflag; /* debug flag */
368: char module[NMNAME]; /* module name buffer */
369: int oflag; /* debug flag */
370: FILE *ofp; /* output FILE */
371: int sflag; /* debug flag */
372: #endif
373:
374: /* Forward. */
375: FILE *ccopen();
376: char *makepass();
377: char *makelib();
378: int cleanup();
379:
380: /* External. */
381: char *getenv();
382: char *malloc();
383: char *tempnam();
384: char *path();
385:
386: main(argc, argv) int argc; char *argv[];
387: {
388: register char *p;
389: register struct option *op;
390: int i, narg, c;
391:
392: #if COHERENT
393: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
394: signal(SIGINT, cleanup);
395: #endif
396: #if _I386
397: /* Conditionalized only because _addargs() not in COH286 libc.a yet. */
398: _addargs("CC", &argc, &argv);
399: #endif
400: setbuf(stdout, NULL);
401: setbuf(stderr, NULL);
402: setvariant(VSUVAR);
403: setvariant(VSMEMB);
404: setvariant(VSLCON);
405: setvariant(VSPVAL);
406: setvariant(VPEEP);
407: setvariant(VCOMM);
408: setvariant(VPSTR);
409: setvariant(V80186);
410:
411: #if 0
412: printmem("initially");
413: #endif
414: if (p = getenv("PATH")) dpath = p;
415: if (p = getenv("LIBPATH")) dlibpath = p;
416: if (p = getenv("EDITOR")) strcpy(pass[ED].p_pln, p);
417:
418: for (i=1; i<argc; i+=narg) {
419: narg = 1;
420: p = argv[i];
421: if (*p++ == '-') {
422: static char tppopt[64] = "-";
423: static char tldopt[64] = "-";
424: char *tpp = &tppopt[1];
425: char *tlp = &tldopt[1];
426:
427: if (*p == '\0') {
428: badopt:
429: whatopt(argv[i]);
430: continue;
431: }
432: while (*p != '\0') {
433: for (op = &option[0]; ; op += 1)
434: if (op->o_name[0] == '\0')
435: goto badopt;
436: else if (opeq(op->o_name, p))
437: break;
438: if (VeryVflag && Vflag)
439: printf("Option: -%s\n", op->o_name);
440: argf[i] |= op->o_flag;
441: switch (op->o_kind) {
442: case 0:
443: chgvariant(op->o_bits);
444: p += strlen(op->o_name);
445: continue;
446: case 10:
447: setvariant(op->o_bits);
448: p += strlen(op->o_name);
449: continue;
450: case 2:
451: ccvariant ^= op->o_bits;
452: p += strlen(op->o_name);
453: /* Set strict */
454: if ((ccvariant&VS) != 0) {
455: for (op = &option[0];; op += 1)
456: if (op->o_name[1]=='S')
457: break;
458: while (op->o_name[1]=='S') {
459: setvariant(op->o_bits);
460: op += 1;
461: }
462: }
463: /* Set debug */
464: if ((ccvariant&VDB) != 0) {
465: for (op = &option[0];; op += 1)
466: if (op->o_name[1]=='D')
467: break;
468: while (op->o_name[1]=='D') {
469: setvariant(op->o_bits);
470: op += 1;
471: }
472: }
473: continue;
474: case 12:
475: ccvariant |= op->o_bits;
476: p += strlen(op->o_name);
477: continue;
478: case 3:
479: while (*tpp++ = *p)
480: p++;
481: continue;
482: case 5:
483: if (*p == 'o') {
484: outf = argv[i+narg];
485: }
486: if (*p == 'u')
487: ndoto += 1;
488: if (i+narg >= argc)
489: missingname();
490: argf[i+narg++] = LDOPT;
491: /* Fall through */
492: case 4:
493: if (*p == 'r')
494: ++partial;
495: strcpy(tlp, op->o_name);
496: tlp += strlen(op->o_name);
497: p += strlen(op->o_name);
498: continue;
499: case 6:
500: if ((c = p[1]) == '\0'
501: || (c = getpsn(c)) < CPP)
502: goto badopt;
503: qpass = c;
504: p += 2;
505: continue;
506: case 7:
507: c = p[0];
508: getpass(c, p+1);
509: p = dnul;
510: continue;
511: case 8:
512: p = dnul;
513: continue;
514: #if TEMPBUF
515: case 9:
516: tempsize = atoi(++p);
517: tempsize = (tempsize + 3) & ~3;
518: p = dnul;
519: continue;
520: #endif
521: default:
522: cquit("options");
523: }
524: }
525: if (((unsigned)argf[i]-1)&((unsigned)argf[i])) {
526: strcpy(optp, argv[i]);
527: argv[i] = optp;
528: optp += strlen(optp)+1;
529: strcpy(optp, tppopt);
530: optp += strlen(optp)+1;
531: strcpy(optp, tldopt);
532: optp += strlen(optp)+1;
533: }
534: } else {
535: while (*p) p+=1;
536: c = *--p;
537: if (*--p != '.') c = 0;
538: if (c >= 'A' && c <= 'Z')
539: c |= 'a'-'A';
540: switch (c) {
541: case 'h':
542: case 'c':
543: if (doutf == NULL) doutf = argv[i];
544: ndotc += 1;
545: argf[i] = CCARG;
546: if (VeryVflag && Vflag)
547: printf("cc file: %s\n", argv[i]);
548: break;
549: case 's':
550: if (doutf == NULL) doutf = argv[i];
551: ndots += 1;
552: argf[i] = ASARG;
553: if (VeryVflag && Vflag)
554: printf("as file: %s\n", argv[i]);
555: break;
556: case 'm':
557: if (doutf == NULL) doutf = argv[i];
558: ndotm += 1;
559: argf[i] = MARG;
560: if (VeryVflag && Vflag)
561: printf("m file: %s\n", argv[i]);
562: break;
563: case 'o':
564: if (doutf == NULL) doutf = argv[i];
565: ndoto += 1;
566: argf[i] = LDARG;
567: if (VeryVflag && Vflag)
568: printf("ld file: %s\n", argv[i]);
569: break;
570: case 'a':
571: default:
572: ndota += 1;
573: argf[i] = LDLIB;
574: if (VeryVflag && Vflag)
575: printf("library: %s\n", argv[i]);
576: break;
577: }
578: }
579: }
580: #if GEMDOS
581: if (Vflag) {
582: fprintf(stderr, "Mark Williams C for the Atari ST, %s\n", VERS);
583: fprintf(stderr, "Copyright 1984-1987, Mark Williams Co., Chicago\n");
584: }
585: #endif
586: resolve();
587: compile(argc, argv);
588: if (nload==0 && runld(argc, argv)==0) {
589: if (Kflag==0 && nldob==1 && newo[0]!=0)
590: rm(newo);
591: }
592: #if TEMPBUF
593: if (inbuf != NULL)
594: free(inbuf);
595: if (outbuf != NULL)
596: free(outbuf);
597: #if 0
598: printmem("before exit");
599: #endif
600: #endif
601: exit(xstat);
602: }
603:
604: /*
605: * Resolve remaining ambiguities.
606: * Initialize variant arguments and files.
607: */
608: resolve()
609: {
610: register int i;
611:
612: #if TEMPBUF
613: register char *p;
614:
615: /*
616: * The following malloc is a temporary hack for COH386 efficiency.
617: * The rationale is:
618: * (1) reduce the number of required sbrk() calls, and
619: * (2) reduce the risk of running out of memory,
620: * because COH386 without paging requires old+new bytes free
621: * to grow from old to new.
622: * This will doubtless be changed in the future.
623: */
624: #define NARENA 131072
625: if ((p = malloc(tempsize + tempsize + NARENA)) != NULL)
626: free(p);
627: if (tempsize != 0 && Eflag == 0 && Kflag == 0) {
628: inbuf = malloc(tempsize);
629: outbuf = malloc(tempsize);
630: outbufp = outbuf;
631: outbufmax = outbuf + tempsize;
632: if (inbuf == NULL || outbuf == NULL) {
633: fprintf(stderr, "cc: in-memory tempfile buffer allocation failed\n");
634: if (inbuf != NULL)
635: free(inbuf);
636: inbuf = outbuf = NULL;
637: }
638: }
639: #if 0
640: printmem("after buffer allocation");
641: #endif
642: #endif
643: for (i = CPP; i < ALL; i += 1) {
644: if (pass[i].p_flag & P_BACK)
645: ;
646: else if (pass[i].p_flag & P_LIB)
647: pass[i].p_dir = dlibpath;
648: else if (pass[i].p_flag & P_BIN)
649: pass[i].p_dir = dpath;
650: strcpy(cmdb, pass[i].p_mch);
651: strcat(cmdb, pass[i].p_pln);
652: #if GEMDOS
653: if (i <= ED && strchr(pass[i].p_pln, '.') == NULL)
654: strcat(cmdb, i==ED ? ".tos" : ".prg");
655: #endif
656: if (strlen(cmdb) > PTMP-1)
657: cquit("pass name \"%s\" is too long", cmdb);
658: strcpy(pass[i].p_pln, cmdb);
659: }
660: #if 1
661: if (isvariant(VOMF)) {
662: clrvariant(VCOMM);
663: if (isvariant(VLARGE) && isvariant(VSMALL))
664: cquit("invalid model specification");
665: if (notvariant(VLARGE) && notvariant(VSMALL))
666: setvariant(VSMALL);
667: } else {
668: clrvariant(VLARGE);
669: setvariant(VSMALL);
670: }
671: #endif
672: if (GEMAPPflag && GEMACCflag)
673: cquit("specify VGEMAPP or VGEMACC, not both");
674: if (GEMAPPflag) getpass('N', "rcrtsg.o");
675: if (GEMACCflag) getpass('N', "rcrtsd.o");
676: if (pflag) getpass('N', "rmcrts0.o");
677: if (Eflag) setvariant(VCPP);
678: if (qpass == NONE) {
679: if (isvariant(VCPP))
680: qpass = CPP;
681: else if (Sflag)
682: qpass = CC3;
683: else if (cflag)
684: qpass = AS;
685: else
686: qpass = LD;
687: } else if (qpass == CPP)
688: setvariant(VCPP);
689: if (VeryVflag && Vflag)
690: printf("quit pass is %s\n", pass[qpass].p_pln);
691: makvariant(vstr);
692: if (ndotm != 0 && notvariant(VCPP) && notvariant(VCPPE)) {
693: setvariant(VCPP);
694: setvariant(VCPPE);
695: makvariant(vstr2);
696: clrvariant(VCPP);
697: clrvariant(VCPPE);
698: }
699: nfile = ndotc + ndots + ndotm;
700: nname = nfile + ndoto + ndota;
701: if (nname == 0) {
702: fprintf(stderr,
703: "Usage: cc [ -o output ] [ options ] file [ ... ]\n");
704: exit(1);
705: }
706: if (qpass < LD)
707: ++nload;
708: if (Aflag)
709: maketempfile(6);
710: if ( ! Eflag) {
711: chkofile();
712: if (Kflag) {
713: pass[CPP].p_ofn = pass[CC0].p_ifn = tmp[0];
714: pass[CC0].p_ofn = pass[CC1].p_ifn = tmp[1];
715: pass[CC1].p_ofn = pass[CC2].p_ifn = tmp[2];
716: if ( ! Sflag) {
717: pass[CC2].p_sfn = tmp[3];
718: pass[CC2].p_ofn = tmp[5];
719: } else {
720: pass[CC3].p_ifn = pass[CC2].p_ofn = tmp[3];
721: pass[CC3].p_ofn = tmp[5];
722: }
723: } else {
724: pass[CPP].p_ofn = pass[CC0].p_ifn = tmp[0];
725: pass[CC0].p_ofn = pass[CC1].p_ifn = tmp[1];
726: pass[CC1].p_ofn = pass[CC2].p_ifn = tmp[0];
727: if ( ! Sflag) {
728: pass[CC2].p_sfn = tmp[1];
729: pass[CC2].p_ofn = tmp[5];
730: } else {
731: pass[CC3].p_ifn = pass[CC2].p_ofn = tmp[1];
732: pass[CC3].p_ofn = tmp[5];
733: }
734: #if TEMPBUF
735: if (inbuf != NULL && outbuf != NULL)
736: tmp[0][0] = tmp[1][0] = '\0';
737: else
738: #endif
739: {
740: maketempfile(0);
741: maketempfile(1);
742: }
743: }
744: pass[AS].p_ofn = tmp[5];
745: }
746: }
747:
748: maketempfile(i) register int i;
749: {
750: register char *p;
751:
752: strcpy(tmp[i], p = tempnam(pass[TMP].p_dir, pass[TMP].p_pln));
753: free(p);
754: ++istmp[i];
755: }
756:
757: /*
758: ** Compilation.
759: */
760: compile(argc, argv) int argc; char *argv[];
761: {
762: register char *p1;
763: register c, i, err;
764:
765: err = 0;
766: for (i=1; i<argc; ++i) {
767: if ((c = (argf[i] & (CCARG | ASARG | MARG))) == 0)
768: continue;
769: p1 = argv[i];
770: if (err) {
771: err = 0;
772: if (runme(p1)) {
773: ++nload;
774: } else {
775: --i;
776: xstat = 0;
777: }
778: continue;
779: }
780: if (nfile > 1 && Qflag == 0)
781: printf("%s:\n", p1);
782: setfiles(c, p1);
783: if (c == CCARG) {
784: if (runpp(argc, argv, vstr)) {
785: if (Aflag) {
786: ++err; --i;
787: } else
788: ++nload;
789: continue;
790: }
791: if (qpass <= CC0)
792: continue;
793: if (runcc(CC1)) {
794: ++nload;
795: continue;
796: }
797: if (qpass <= CC1)
798: continue;
799: if (runcc(CC2)) {
800: ++nload;
801: continue;
802: }
803: if (qpass <= CC2)
804: continue;
805: if (Sflag) {
806: if (runcc(CC3)) {
807: ++nload;
808: continue;
809: }
810: if (qpass <= CC3)
811: continue;
812: }
813: } else if (c == ASARG && qpass>=AS) {
814: if (runas()) {
815: if (Aflag) {
816: ++err; --i;
817: } else
818: ++nload;
819: continue;
820: }
821: if (qpass <= AS)
822: continue;
823: } else if (c == MARG) {
824: if (runpp(argc, argv, vstr2)) {
825: if (Aflag) {
826: ++err; --i;
827: } else
828: ++nload;
829: continue;
830: }
831: if (qpass < AS)
832: continue;
833: if (runas()) {
834: if (Aflag) {
835: ++err; --i;
836: } else
837: ++nload;
838: continue;
839: }
840: if (qpass == AS)
841: continue;
842: }
843: makeft(p1, p1, "o");
844: }
845: cleanup(0);
846: }
847:
848: runpp(argc, argv, var) int argc; register char *argv[]; char var[];
849: {
850: register char **cp;
851: register int i;
852: char *p1;
853: #if MONOLITHIC
854: int status;
855: extern int nerr; /* in common/diag.c */
856: #endif
857:
858: cp = cmda;
859: #if MONOLITHIC
860: nerr = 0;
861: *cp++ = "cc0";
862: #else
863: p1 = cmdb;
864: p1 = makepass(CC0, *cp++ = p1, AEXEC);
865: #endif
866: *cp++ = var;
867: *cp++ = pass[CPP].p_ifn;
868: if (qpass < CC0)
869: p1 = *cp++ = Kflag ? pass[CPP].p_ofn : "-";
870: else
871: p1 = *cp++ = pass[CC0].p_ofn;
872: for (i=1; i<argc; ++i) {
873: if ((argf[i]&PPOPT) != 0) {
874: *cp++ = argv[i];
875: if ((argf[i]&~PPOPT) != 0)
876: cp[-1] += strlen(cp[-1])+1;
877: }
878: }
879: *cp = 0;
880: #if MONOLITHIC
881: if ((ifp = fopen(pass[CPP].p_ifn, "r")) == NULL) {
882: fprintf(stderr, "cc: cannot open %s\n", pass[CPP].p_ifn);
883: return 1;
884: }
885: if (Eflag)
886: ofp = (strcmp(p1, "-") == 0) ? stdout : ccopen(p1, "w");
887: else
888: ofp = (*p1 == '\0') ? NULL : ccopen(p1, SWMODE);
889: argc = cp - cmda;
890: if (Vflag) {
891: for (i = 0; i < argc; i++)
892: printf("%s ", cmda[i]);
893: if (ofp == NULL)
894: printf("0x%x", outbuf);
895: printf("\n");
896: }
897: if (Aflag)
898: err_open();
899: status = cc0(argc, cmda);
900: if (Aflag)
901: err_close(status);
902: closeinout();
903: #if 0
904: printmem("after cc0");
905: #endif
906: if (status)
907: xstat = 1;
908: return status;
909: #else
910: return run(Aflag, 0);
911: #endif
912: }
913:
914: #if MONOLITHIC
915:
916: #if 0
917: /* This is temporary stuff, here for malloc arena debugging. */
918: /* Knows format of malloc arena. */
919: #include <sys/malloc.h>
920: printmem(s) char *s;
921: {
922: register int i, j;
923: unsigned int u;
924: register MBLOCK *p;
925: register unsigned char *cp;
926: int nfree, nused, bfree, bused, freef;
927:
928: printf("%s:\n", s);
929: printf("__a_count=%d\n", __a_count);
930: printf("__a_scanp=%x\n", __a_scanp);
931: printf("__a_first=%x\n", __a_first);
932: nfree = nused = bfree = bused = 0;
933: for (p = __a_first, i = 0; i < __a_count; i++) {
934: u = p->blksize;
935: freef = isfree(u);
936: u = realsize(u);
937: printf("%x: size %d ", p, u-4);
938: if (freef) {
939: printf("free\n");
940: ++nfree;
941: bfree += u - sizeof(unsigned);
942: } else {
943: ++nused;
944: if (u != 0) {
945: printf("%x: size %d ", p, u-4);
946: printf("used\n");
947: bused += u - sizeof(unsigned);
948: }
949: if (u != tempsize + 4) {
950: for (j = 4, cp = (char *)p + 4; j < u; j++)
951: printf("%02x ", *cp++);
952: printf("\n");
953: }
954: }
955: p = bumpp(p, u);
956: }
957: printf("nfree=%d nused=%d\n", nfree, nused-1);
958: printf("bfree=%d bused=%d overhead=%d total=%d\n",
959: bfree, bused, 4*(nfree+nused+1), bfree+bused+4*(nfree+nused+1));
960: }
961: #endif
962:
963: /*
964: * Close input and output files as appropriate.
965: */
966: closeinout()
967: {
968: if (ifp != NULL) {
969: fclose(ifp);
970: ifp = NULL;
971: }
972: if (ofp != NULL) {
973: fclose(ofp);
974: ofp = NULL;
975: }
976: }
977:
978: /*
979: * Set input and output file pointers for monolithic compiler.
980: * Print verbose phase message if Vflag.
981: */
982: setinout(pn) register int pn;
983: {
984: register char *p, *in, *out, *ln;
985:
986: if (pn == CC2B) {
987: ln = "cc2b";
988: in = pass[CC2].p_sfn;
989: out = pass[CC2].p_ofn;
990: } else {
991: in = pass[pn].p_ifn;
992: if (pn == CC2) {
993: ln = "cc2a";
994: out = (Sflag) ? pass[pn].p_ofn : pass[pn].p_sfn;
995: } else {
996: ln = pass[pn].p_pln;
997: out = pass[pn].p_ofn;
998: }
999: }
1000: if (Vflag)
1001: printf("%s %s ", ln, vstr);
1002: if (*in == '\0') {
1003: ifp = NULL;
1004: p = inbuf;
1005: inbuf = inbufp = outbuf;
1006: inbufmax = outbufp;
1007: outbuf = outbufp = p;
1008: outbufmax = outbuf + tempsize;
1009: if (Vflag)
1010: printf("0x%x ", inbuf);
1011: } else {
1012: ifp = ccopen(in, SRMODE);
1013: if (Vflag)
1014: printf("%s ", in);
1015: }
1016: if (*out == '\0') {
1017: ofp = NULL;
1018: if (Vflag)
1019: printf("0x%x\n", outbuf);
1020: } else {
1021: ofp = ccopen(out, SWMODE);
1022: if (Vflag)
1023: printf("%s\n", out);
1024: }
1025: }
1026: #endif
1027:
1028: runcc(pn) register int pn;
1029: {
1030: #if MONOLITHIC
1031: register int status;
1032:
1033: setinout(pn);
1034: switch(pn) {
1035: case CC1:
1036: status = cc1();
1037: break;
1038: case CC2:
1039: if (status = cc2a())
1040: break;
1041: if (!Sflag) {
1042: closeinout();
1043: setinout(CC2B);
1044: status = cc2b();
1045: }
1046: break;
1047: case CC3:
1048: status = cc3();
1049: break;
1050: default:
1051: cquit("bad pass number %d", pn);
1052: break;
1053: }
1054: closeinout();
1055: #if 0
1056: printmem((pn == CC1) ? "after cc1": (pn == CC2) ? "after cc2" : "after cc3");
1057: #endif
1058: return status;
1059: #else
1060: register char **cp;
1061:
1062: cp = cmda;
1063: makepass(pn, *cp++ = cmdb, AEXEC);
1064: *cp++ = vstr;
1065: *cp++ = pass[pn].p_ifn;
1066: *cp++ = pass[pn].p_ofn;
1067: if (pn == CC2)
1068: *cp++ = pass[CC2].p_sfn;
1069: *cp = 0;
1070: return run(0, 0);
1071: #endif
1072: }
1073:
1074: runas()
1075: {
1076: register char **cp;
1077:
1078: cp = cmda;
1079: makepass(AS, *cp++ = cmdb, AEXEC);
1080: #if _I386
1081: *cp++ = "-fgx";
1082: if (Qflag)
1083: *cp++ = "-w";
1084: #else
1085: *cp++ = "-gx";
1086: #endif
1087: *cp++ = "-o";
1088: *cp++ = pass[AS].p_ofn;
1089: *cp++ = pass[AS].p_ifn;
1090: *cp = 0;
1091: return run(Aflag, 0);
1092: }
1093:
1094: runme(fn)
1095: char *fn;
1096: {
1097: register char **cp;
1098:
1099: cp = cmda;
1100: makepass(ED, *cp++ = cmdb, AEXEC);
1101: *cp++ = fn;
1102: *cp++ = "-e";
1103: *cp++ = tmp[6];
1104: *cp = 0;
1105: return run(0, 0);
1106: }
1107: runld(argc, argv)
1108: char *argv[];
1109: {
1110: char *p1;
1111: register char *p2;
1112: register char **cp;
1113: char **cp1;
1114: register char **cp2;
1115: int i;
1116: static char buff[32];
1117:
1118: cp = cmda;
1119: p1 = makepass(LD, *cp++ = cmdb, AEXEC);
1120: *cp++ = "-X";
1121: #if _I386
1122: if (Qflag)
1123: *cp++ = "-Q";
1124: #endif
1125: if (outf == NULL && !aflag) {
1126: *cp++ = "-o";
1127: if (partial || doutf == NULL) {
1128: #if COHERENT
1129: *cp++ = "l.out";
1130: #endif
1131: #if GEMDOS
1132: *cp++ = "l.prg";
1133: #endif
1134: } else {
1135: basename(doutf, buff);
1136: #if GEMDOS
1137: strcat(buff, ".prg");
1138: #endif
1139: *cp++ = buff;
1140: }
1141: }
1142: for (i=1; i<argc; ++i) {
1143: if ((argf[i]&LDOPT)!=0) {
1144: *cp++ = argv[i];
1145: if ((argf[i]&~LDOPT)!=0) {
1146: cp[-1] += strlen(cp[-1])+1;
1147: cp[-1] += strlen(cp[-1])+1;
1148: }
1149: }
1150: }
1151: cp1 = cp;
1152: p1 = makepass(CRT, *cp++ = p1, AREAD);
1153: if (fflag) {
1154: *cp++ = "-u";
1155: *cp++ = DTEFG;
1156: }
1157: for (i=1; i<argc; ++i) {
1158: p2 = argv[i];
1159: if ((argf[i]&CCLIB)!=0) {
1160: while (*p2++ != 'l');
1161: p1 = makelib(LIB, *cp++ = p1, p2);
1162: } else if ((argf[i]&(CCARG|ASARG|MARG|LDARG))!=0) {
1163: for (cp2=cp1; cp2<cp; ++cp2)
1164: if (strcmp(*cp2, p2) == 0)
1165: break;
1166: if (cp2 == cp) {
1167: *cp++ = p2;
1168: ++nldob;
1169: }
1170: } else if ((argf[i]&LDLIB)!=0) {
1171: *cp++ = p2;
1172: }
1173: }
1174: if ( ! partial && (GEMAPPflag || GEMACCflag)) {
1175: p1 = makelib(LIB, *cp++ = p1, "aes");
1176: p1 = makelib(LIB, *cp++ = p1, "vdi");
1177: }
1178: p1 = makelib(LIB, *cp++ = p1, "c");
1179: #if _I386
1180: if (Kflag == 0 && nldob == 1 && newo[0] != 0) {
1181: *cp++ = "-Z";
1182: *cp++ = newo;
1183: }
1184: #endif
1185: *cp = 0;
1186: return run(0, 1);
1187: }
1188:
1189: basename(in, out)
1190: char *in, *out;
1191: {
1192: register char *s;
1193: register int n;
1194:
1195: if ((s = strrchr(in, PATHSEP)) != NULL)
1196: in = ++s; /* skip past last PATHSEP */
1197: if ((s = strrchr(in, '.')) != NULL)
1198: n = s - in; /* copy to last '.' */
1199: else
1200: n = strlen(in); /* copy all */
1201: strncpy(out, in, n); /* copy as appropriate */
1202: out[n] = '\0'; /* and NUL-terminate */
1203: }
1204:
1205: run(catch_errors, nofork) int catch_errors; int nofork;
1206: {
1207: int s;
1208: extern char **environ;
1209:
1210: if (Vflag) {
1211: char *cp, **cpp;
1212: cpp = cmda;
1213: while ((cp = *cpp) != NULL) {
1214: if (cpp != cmda)
1215: putchar(' ');
1216: printf("%s", cp);
1217: ++cpp;
1218: }
1219: putchar('\n');
1220: fflush(stdout);
1221: }
1222: if (catch_errors)
1223: err_open();
1224: #if COHERENT
1225: #if _I386
1226: if (nofork) {
1227: execve(cmda[0], cmda, environ);
1228: cquit("cannot execute %s", cmda[0]);
1229: }
1230: #endif
1231: {
1232: int nsleep;
1233: int status;
1234: int pid;
1235: nsleep = NSLEEP;
1236: while ((pid=fork())<0 && nsleep--)
1237: sleep(DELAY);
1238: if (pid < 0)
1239: cquit("can't fork");
1240: if (pid == 0) {
1241: execve(cmda[0], cmda, environ);
1242: exit(MAGIC);
1243: }
1244: while (wait(&status) != pid)
1245: ;
1246: if ((s = status&0177)!=0 && s!=SIGINT) {
1247: extern char *signame[];
1248:
1249: fprintf(stderr, "cc: %s ", cmda[0]);
1250: if (s==SIGSYS && (status&0200)==0)
1251: fprintf(stderr, "exec failed");
1252: else
1253: fprintf(stderr, signame[s]);
1254: if ((status&0200) != 0)
1255: fprintf(stderr, " -- core dumped");
1256: fprintf(stderr, "\n");
1257: } else if ((s = (status>>8)&0377) == MAGIC)
1258: cquit("cannot execute %s", cmda[0]);
1259: }
1260: #else
1261: if (s = execve(cmda[0], cmda, environ))
1262: if (s < 0)
1263: perror(cmda[0]);
1264: #endif
1265: if (catch_errors)
1266: err_close(s);
1267: if (s != 0)
1268: xstat = 1;
1269: return s;
1270: }
1271:
1272: /*
1273: * Routines to catch and release stdout for -A.
1274: */
1275: int new_fd;
1276: int saved_fd;
1277:
1278: err_open()
1279: {
1280: fflush(stdout);
1281: saved_fd = dup(1);
1282: if ((new_fd = creat(tmp[6], 0644)) < 0)
1283: cquit("%s: %s", tmp[6], sys_errlist[errno]);
1284: if (dup2(new_fd, 1) < 0)
1285: cquit("dup2 failed");
1286: }
1287:
1288: err_close(status) int status;
1289: {
1290: register int c;
1291: register FILE *fp;
1292:
1293: fflush(stdout);
1294: if (dup2(saved_fd, 1) < 0)
1295: cquit("dup2 failed");
1296: if (close(new_fd) < 0)
1297: /* cquit("error on close") */ ;
1298: if (status == 0 && (fp = fopen(tmp[6], "r")) != NULL) {
1299: /* Copy warnings, otherwise they go down the rathole. */
1300: while ((c = getc(fp)) != EOF)
1301: putchar(c);
1302: fclose(fp);
1303: }
1304: }
1305:
1306: /*
1307: ** Option processing.
1308: */
1309:
1310: /*
1311: * Compare option name to argument.
1312: */
1313: opeq(op, ap)
1314: register char *op, *ap;
1315: {
1316: while (*op!=0)
1317: if (*op++ != *ap++)
1318: return 0;
1319: return 1;
1320: }
1321:
1322:
1323: /*
1324: * Get short pass name.
1325: * translate single character code into pass index number.
1326: */
1327: getpsn(c)
1328: register int c;
1329: {
1330: register int pn;
1331:
1332: for (pn = CPP; pn < ALL; pn += 1)
1333: if (pass[pn].p_psn == c)
1334: return pn;
1335: return NONE;
1336: }
1337:
1338: /*
1339: * Process -t*, -B*, -M* options.
1340: * -t* sets take flag for specified passes.
1341: * -B* copies prefix string for flagged passes
1342: * or for all machine dependent passes if none flagged.
1343: * -M* copies machine string for machine dependent passes.
1344: * -N* renames a pass, such as crts0.o.
1345: */
1346: getpass(c, cp)
1347: register int c;
1348: register char *cp;
1349: {
1350: if (c == 't') { /* Take passes from backup */
1351: if (*cp != 0)
1352: while ((c = *cp++) != 0)
1353: if ((c = getpsn(c)) >= CPP) {
1354: pass[c].p_flag |= P_TAKE;
1355: pass[c].p_dir = dnul;
1356: if (Vflag)
1357: passrpt(c);
1358: } else {
1359: badpsn(cp[-1]);
1360: }
1361: else
1362: getpass('t', "01234");
1363: } else if (c == 'B') { /* Get backup string */
1364: for (c = CPP; c < ALL; c += 1) {
1365: if ((pass[c].p_flag&P_TAKE) != 0) {
1366: pass[c].p_flag ^= P_TAKE;
1367: pass[c].p_flag |= P_BACK;
1368: pass[c].p_dir = cp;
1369: if (Vflag)
1370: passrpt(c);
1371: }
1372: }
1373: } else if (c == 'M') { /* Machine prefix string */
1374: if (strlen(cp) > PTMP-1)
1375: toolong(cp);
1376: strcpy(dmch, cp);
1377: if (Vflag)
1378: printf("Prefix: %s\n", dmch);
1379: } else if (c == 'N') { /* New pass name */
1380: if ((c = getpsn(*cp++)) >= CPP) {
1381: if (strlen(cp) > PTMP-1)
1382: toolong(cp);
1383: if (Vflag)
1384: printf("Rename: %s to %s\n", pass[c].p_pln, cp);
1385: strcpy(pass[c].p_pln, cp);
1386: } else
1387: badpsn(cp[-1]);
1388: }
1389: }
1390:
1391: passrpt(c)
1392: register int c;
1393: {
1394: printf("Use: {%s}%s%s\n", pass[c].p_dir, pass[c].p_mch, pass[c].p_pln);
1395: }
1396:
1397: missingname()
1398: {
1399: fprintf(stderr, "cc: missing name in -o, -e or -u\n");
1400: exit(1);
1401: }
1402:
1403: badoutput()
1404: {
1405: fprintf(stderr, "cc: improbable name in -o: %s\n", outf);
1406: exit(1);
1407: }
1408:
1409: toomany()
1410: {
1411: fprintf(stderr, "cc: too many files for -o option\n");
1412: exit(1);
1413: }
1414:
1415: badpsn(c)
1416: {
1417: fprintf(stderr, "cc: unknown short path name: %c\n", c);
1418: exit(1);
1419: }
1420:
1421: toolong(cp)
1422: char *cp;
1423: {
1424: fprintf(stderr, "cc: name, prefix, or directory too long: %s\n", cp);
1425: exit(1);
1426: }
1427:
1428: /*
1429: * Check specified output file name,
1430: * or construct name from first file
1431: * name seen.
1432: */
1433: chkofile()
1434: {
1435: register char *fn;
1436: register char c;
1437:
1438: if ((fn = outf) == NULL)
1439: return;
1440: if (fn[0] == '-')
1441: badoutput();
1442: if (nname > 1 && qpass < LD)
1443: toomany();
1444: while (*fn != 0)
1445: ++fn;
1446: while (*fn != '.' && fn > outf)
1447: --fn;
1448: if (*fn++ == '.' && (c = *fn++) && *fn == '\0') {
1449: if (c == 'c'
1450: || c == 'h'
1451: || c == 'm'
1452: || (c != 'o' && cflag)
1453: || (c == 'o' && !cflag)
1454: || (c != 's' && Sflag)
1455: || (c == 's' && !Sflag))
1456: badoutput();
1457: } else {
1458: if (Sflag || cflag)
1459: badoutput();
1460: }
1461: }
1462:
1463: whatopt(s)
1464: char *s;
1465: {
1466: fprintf(stderr, "cc: unrecognized option: %s\n", s);
1467: exit(1);
1468: }
1469:
1470: cquit(s)
1471: char *s;
1472: {
1473: fprintf(stderr, "cc: fatal error: %r\n", &s);
1474: cleanup(0);
1475: exit(1);
1476: }
1477:
1478: /*
1479: ** Intermediate file processing.
1480: */
1481: /*
1482: * Given cp -> `name.[chms]' rewrite ultimate destination and intermediates
1483: * if necessary.
1484: */
1485: setfiles(c, cp)
1486: int c;
1487: register char *cp;
1488: {
1489: register char *ip;
1490:
1491: ip = cp;
1492: if (qpass < LD && outf != NULL)
1493: cp = outf;
1494: if (c == CCARG) {
1495: pass[CPP].p_ifn = ip;
1496: if (Eflag)
1497: return;
1498: if (Kflag) {
1499: makeft(pass[CPP].p_ofn, cp, "i");
1500: makeft(pass[CC0].p_ofn, cp, "0");
1501: makeft(pass[CC1].p_ofn, cp, "1");
1502: if ( ! Sflag)
1503: makeft(pass[CC2].p_sfn, cp, "2");
1504: else
1505: makeft(pass[CC2].p_ofn, cp, "2");
1506: }
1507: } else if (c == MARG) {
1508: pass[CPP].p_ifn = ip;
1509: if (Kflag)
1510: makeft(pass[CC0].p_ofn, cp, "s");
1511: pass[AS].p_ifn = pass[CC0].p_ofn;
1512: } else if (c == ASARG)
1513: pass[AS].p_ifn = ip;
1514: makeft(tmp[5], cp, Sflag ? "s" : "o");
1515: if (!Sflag && newo[0] == 0 && access(tmp[5], 0) < 0)
1516: strcpy(newo, tmp[5]);
1517: }
1518:
1519: #if MONOLITHIC
1520: /*
1521: * Open a file, die on failure.
1522: */
1523: FILE *
1524: ccopen(name, mode) char *name; char *mode;
1525: {
1526: register FILE *fp;
1527:
1528: if ((fp = fopen(name, mode)) != NULL)
1529: return fp;
1530: cquit("cannot open file \"%s\"", name);
1531: }
1532: #endif
1533:
1534: /*
1535: * Unlink a file.
1536: * If `-V' echo the rm.
1537: */
1538: rm(s)
1539: register char *s;
1540: {
1541: if (Vflag)
1542: printf("rm %s\n", s);
1543: unlink(s);
1544: }
1545:
1546: /*
1547: * Cleanup after yourself if
1548: * the user hits interrupt during a compile (sig == SIGINT),
1549: * or when all compiles have completed (sig == 0).
1550: */
1551: cleanup(sig)
1552: {
1553: register int i;
1554:
1555: #if COHERENT
1556: if (sig == SIGINT)
1557: signal(SIGINT, SIG_IGN);
1558: #endif
1559: for (i = 0; i < 7; i += 1)
1560: if (istmp[i])
1561: rm(tmp[i]);
1562: #if COHERENT
1563: if (sig == SIGINT && nldob==1 && newo[0]!=0)
1564: rm(newo);
1565: if (sig == SIGINT)
1566: exit(1);
1567: #endif
1568: }
1569:
1570: /*
1571: ** Name construction.
1572: */
1573: char *
1574: ccpath(cp, p, n, mode) register char *cp; char *p, *n; int mode;
1575: {
1576: register char *pn;
1577: if (VeryVflag && Vflag)
1578: printf("search %s for %s\n", p, n);
1579: while ((pn = path(p, n, mode)) == NULL) {
1580: if (Zflag) { /* Disk swap dialog flag */
1581: fprintf(stderr, "Insert %s's disk in a free drive and press <Return>\n", n);
1582: gets(cp);
1583: continue;
1584: }
1585: pn = n;
1586: break;
1587: }
1588: while (*cp++ = *pn++) ;
1589: return cp;
1590: }
1591:
1592: char *
1593: makepass(pn, cp, mode)
1594: int pn;
1595: register char *cp;
1596: int mode;
1597: {
1598: return ccpath(cp, pass[pn].p_dir, pass[pn].p_pln, mode);
1599: }
1600:
1601: char *
1602: makelib(pn, cp, lp)
1603: int pn;
1604: char *cp;
1605: char *lp;
1606: {
1607: strcpy(cp, pass[pn].p_pln);
1608: strcat(cp, lp);
1609: strcat(cp, ".a");
1610: return ccpath(cp, pass[pn].p_dir, cp, AREAD);
1611: }
1612:
1613: makeft(op, ip, ft)
1614: char *op, *ip, *ft;
1615: {
1616: register char *ep, *tp;
1617: register c;
1618: char *dp;
1619:
1620: ep = ip;
1621: tp = op;
1622: dp = NULL;
1623: while ((c = *ep++) != '\0') {
1624: if (c == PATHSEP && ip != outf) {
1625: tp = op;
1626: dp = NULL;
1627: } else {
1628: if (c == '.')
1629: dp = tp;
1630: *tp++ = c;
1631: }
1632: }
1633: if (ip == outf)
1634: return;
1635: if (dp != NULL)
1636: tp = dp;
1637: *tp++ = '.';
1638: ep = ft;
1639: while (*tp++ = *ep++)
1640: ;
1641: }
1642:
1643: /* end of coh/cc.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.