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