![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to gcc.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* Compiler driver program that can handle many languages.
2: Copyright (C) 1987 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU CC General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU CC, but only under the conditions described in the
15: GNU CC General Public License. A copy of this license is
16: supposed to have been given to you along with GNU CC so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: /* This program is the user interface to the C compiler and possibly to
23: other compilers. It is used because compilation is a complicated procedure
24: which involves running several programs and passing temporary files between
25: them, forwarding the users switches to those programs selectively,
26: and deleting the temporary files at the end.
27:
28: CC recognizes how to compile each input file by suffixes in the file names.
29: Once it knows which kind of compilation to perform, the procedure for
30: compilation is specified by a string called a "spec".
31:
32: Specs are strings containing lines, each of which (if not blank)
33: is made up of a program name, and arguments separated by spaces.
34: The program name must be exact and start from root, since no path
35: is searched and it is unreliable to depend on the current working directory.
36: Redirection of input or output is not supported; the subprograms must
37: accept filenames saying what files to read and write.
38:
39: In addition, the specs can contain %-sequences to substitute variable text
40: or for conditional text. Here is a table of all defined %-sequences.
41: Note that spaces are not generated automatically around the results of
42: expanding these sequences; therefore, you can concatenate them together
43: or with constant text in a single argument.
44:
45: %% substitute one % into the program name or argument.
46: %i substitute the name of the input file being processed.
47: %b substitute the basename of the input file being processed.
48: This is the substring up to (and not including) the last period.
49: %g substitute the temporary-file-name-base. This is a string chosen
50: once per compilation. Different temporary file names are made by
51: concatenation of constant strings on the end, as in `%g.s'.
52: %g also has the same effect of %d.
53: %d marks the argument containing or following the %d as a
54: temporary file name, so that that file will be deleted if CC exits
55: successfully. Unlike %g, this contributes no text to the argument.
56: %w marks the argument containing or following the %w as the
57: "output file" of this compilation. This puts the argument
58: into the sequence of arguments that %o will substitute later.
59: %o substitutes the names of all the output files, with spaces
60: automatically placed around them. You should write spaces
61: around the %o as well or the results are undefined.
62: %o is for use in the specs for running the linker.
63: Input files whose names have no recognized suffix are not compiled
64: at all, but they are included among the output files, so they will
65: be linked.
66: %p substitutes the standard macro predefinitions for the
67: current target machine. Use this when running cpp.
68: %s current argument is the name of a library file of some sort.
69: Search for that file in a standard list of directories
70: and substitute the full pathname found.
71: %a process ASM_SPEC as a spec.
72: This allows config.h to specify part of the spec for running as.
73: %l process LINK_SPEC as a spec.
74: %L process LIB_SPEC as a spec.
75: %S process STARTFILE_SPEC as a spec. Here S is literal.
76: %c process SIGNED_CHAR_SPEC as a spec.
77: %{S} substitutes the -S switch, if that switch was given to CC.
78: If that switch was not specified, this substitutes nothing.
79: Here S is a metasyntactic variable.
80: %{S*} substitutes all the switches specified to CC whose names start
81: with -S. This is used for -o, -D, -I, etc; switches that take
82: arguments. CC considers `-o foo' as being one switch whose
83: name starts with `o'. %{o*} would substitute this text,
84: including the space; thus, two arguments would be generated.
85: %{S:X} substitutes X, but only if the -S switch was given to CC.
86: %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
87:
88: The conditional text X in a %{S:X} or %{!S:X} construct may contain
89: other nested % constructs or spaces, or even newlines.
90: They are processed as usual, as described above.
91:
92: Note that it is built into CC which switches take arguments and which
93: do not. You might think it would be useful to generalize this to
94: allow each compiler's spec to say which switches take arguments. But
95: this cannot be done in a consistent fashion. CC cannot even decide
96: which input files have been specified without knowing which switches
97: take arguments, and it must know which input files to compile in order
98: to tell which compilers to run.
99:
100: CC also knows implicitly that arguments starting in `-l' are to
101: be treated as output files, and passed to the linker in their proper
102: position among the other output files.
103:
104: */
105:
106: /* This defines which switches take arguments. */
107:
108: #define SWITCH_TAKES_ARG(CHAR) \
109: ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
110: || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
111: || (CHAR) == 'I' || (CHAR) == 'Y' || (CHAR) == 'm' \
112: || (CHAR) == 'L')
113:
114: #include <stdio.h>
115: #include <sys/types.h>
116: #include <signal.h>
117: #include <sys/file.h>
118: #include "obstack.h"
119: #include "config.h"
120:
121: #ifdef USG
122: #define R_OK 4
123: #define W_OK 2
124: #define X_OK 1
125: #define vfork fork
126: #endif
127:
128: #define obstack_chunk_alloc xmalloc
129: #define obstack_chunk_free free
130: extern int xmalloc ();
131: extern void free ();
132:
133: /* If a stage of compilation returns an exit status >= 1,
134: compilation of that file ceases. */
135:
136: #define MIN_FATAL_STATUS 1
137:
138: /* This is the obstack which we use to allocate many strings. */
139:
140: struct obstack obstack;
141:
142: char *handle_braces ();
143: char *save_string ();
144: char *concat ();
145: int do_spec ();
146: int do_spec_1 ();
147: int give_string ();
148: char *find_file ();
149:
150: /* config.h can define ASM_SPEC to provide extra args to the assembler
151: or extra switch-translations. */
152: #ifndef ASM_SPEC
153: #define ASM_SPEC ""
154: #endif
155:
156: /* config.h can define LINK_SPEC to provide extra args to the linker
157: or extra switch-translations. */
158: #ifndef LINK_SPEC
159: #define LINK_SPEC ""
160: #endif
161:
162: /* config.h can define LIB_SPEC to override the default libraries. */
163: #ifndef LIB_SPEC
164: #define LIB_SPEC "%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
165: #endif
166:
167: /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
168: #ifndef STARTFILE_SPEC
169: #define STARTFILE_SPEC \
170: "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
171: #endif
172:
173: /* This spec is used for telling cpp whether char is signed or not. */
174: #define SIGNED_CHAR_SPEC \
175: (DEFAULT_SIGNED_CHAR ? "%{funsigned-char:-D__CHAR_UNSIGNED__}" \
176: : "%{!fsigned-char:-D__CHAR_UNSIGNED__}")
177:
178: /* This structure says how to run one compiler, and when to do so. */
179:
180: struct compiler
181: {
182: char *suffix; /* Use this compiler for input files
183: whose names end in this suffix. */
184: char *spec; /* To use this compiler, pass this spec
185: to do_spec. */
186: };
187:
188: /* Here are the specs for compiling files with various known suffixes.
189: A file that does not end in any of these suffixes will be passed
190: unchanged to the loader and nothing else will be done to it. */
191:
192: struct compiler compilers[] =
193: {
194: {".c",
195: "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*} %{M*} %{T} \
196: -undef -D__GNU__ -D__GNUC__ %{ansi:-T -D__STRICT_ANSI__} %{!ansi:%p}\
197: %c %{O:-D__OPTIMIZE__} %{traditional} %{pedantic} %{Wcomment} %{Wall}\
198: %i %{!M*:%{!E:%g.cpp}}%{E:%{o*}}%{M*:%{o*}}\n\
199: %{!M*:%{!E:cc1 %g.cpp %{!Q:-quiet} -dumpbase %i %{Y*} %{d*} %{m*} %{f*}\
200: %{W*} %{w} %{pedantic} %{ansi}\
201: %{O:-opt}%{!O:-noreg}\
202: %{v:-version} %{g:-G}%{gg:-symout %g.sym} %{pg:-p} %{p}\
203: %{S:%{o*}%{!o*:-o %b.s}}%{!S:-o %g.s}\n\
204: %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %{gg:-G %g.sym}\
205: %g.s %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o}\n }}}"},
206: {".s",
207: "%{!S:as %{R} %{j} %{J} %{h} %{d2} %a \
208: %i %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o}\n }"},
209: /* Mark end of table */
210: {0, 0}
211: };
212:
213: /* Here is the spec for running the linker, after compiling all files. */
214: char *link_spec = "%{!c:%{!M*:%{!E:%{!S:ld %{o*} %l\
215: %{A} %{d} %{e*} %{N} %{n} %{r} %{s} %{S} %{T*} %{t} %{u*} %{X} %{x} %{z}\
216: %{y*} %{!nostdlib:%S} \
217: %{L*} %o %{!nostdlib:gnulib%s %L}\n }}}}";
218: /* %{L*} %o %{!nostdlib:gnulib%s %{g:-lg} %L}\n }}}}"; took out {g from above */
219:
220: /* Record the names of temporary files we tell compilers to write,
221: and delete them at the end of the run. */
222:
223: /* This is the common prefix we use to make temp file names.
224: It is chosen once for each run of this program.
225: It is substituted into a spec by %g.
226: Thus, all temp file names contain this prefix.
227: In practice, all temp file names start with this prefix.
228: The prefix starts with `/tmp'. */
229:
230: char *temp_filename;
231:
232: /* Length of the prefix. */
233:
234: int temp_filename_length;
235:
236: /* Define the list of temporary files to delete. */
237:
238: struct temp_file
239: {
240: char *name;
241: struct temp_file *next;
242: int success_only; /* Nonzero means delete this file
243: only if compilation succeeds fully. */
244: };
245:
246: struct temp_file *temp_file_queue;
247:
248: /* Record FILENAME as a file to be deleted automatically.
249: SUCCESS_ONLY nonzero means delete it only if all compilation succeeds;
250: otherwise delete it in any case. */
251:
252: void
253: record_temp_file (filename, success_only)
254: char *filename;
255: int success_only;
256: {
257: register struct temp_file *temp;
258: register char *name;
259: temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
260: name = (char *) xmalloc (strlen (filename) + 1);
261: strcpy (name, filename);
262: temp->next = temp_file_queue;
263: temp->name = name;
264: temp->success_only = success_only;
265: temp_file_queue = temp;
266: }
267:
268: /* Delete all the temporary files whose names we previously recorded.
269: SUCCESS nonzero means "delete on success only" files should be deleted. */
270:
271: void
272: delete_temp_files (success)
273: int success;
274: {
275: register struct temp_file *temp;
276: for (temp = temp_file_queue; temp; temp = temp->next)
277: if (success || ! temp->success_only)
278: {
279: #ifdef DEBUG
280: int i;
281: printf ("Delete %s? (y or n) ", temp->name);
282: fflush (stdout);
283: i = getchar ();
284: if (i != '\n')
285: while (getchar () != '\n') ;
286: if (i == 'y' || i == 'Y')
287: #endif /* DEBUG */
288: unlink (temp->name);
289: }
290: temp_file_queue = 0;
291: }
292:
293: /* Compute a string to use as the base of all temporary file names.
294: It is substituted for %g. */
295:
296: void
297: choose_temp_base ()
298: {
299: register char *foo = "/tmp/ccXXXXXX";
300: temp_filename = (char *) xmalloc (strlen (foo) + 1);
301: strcpy (temp_filename, foo);
302: mktemp (temp_filename);
303: temp_filename_length = strlen (temp_filename);
304: }
305:
306: /* Accumulate a command (program name and args), and run it. */
307:
308: /* Vector of pointers to arguments in the current line of specifications. */
309:
310: char **argbuf;
311:
312: /* Number of elements allocated in argbuf. */
313:
314: int argbuf_length;
315:
316: /* Number of elements in argbuf currently in use (containing args). */
317:
318: int argbuf_index;
319:
320: /* Flag indicating whether we should print the command and arguments */
321:
322: unsigned char vflag;
323:
324: /* User-specified prefix to attach to command names,
325: or 0 if none specified. */
326:
327: char *user_exec_prefix = 0;
328:
329: /* Default prefixes to attach to command names. */
330:
331: char *standard_exec_prefix = "/usr/lib/gcc-";
332: char *standard_exec_prefix_1 = "/usr/lib/gcc-";
333:
334: char *standard_startfile_prefix = "/lib/";
335: char *standard_startfile_prefix_1 = "/usr/lib/";
336:
337: /* Clear out the vector of arguments (after a command is executed). */
338:
339: void
340: clear_args ()
341: {
342: argbuf_index = 0;
343: }
344:
345: /* Add one argument to the vector at the end.
346: This is done when a space is seen or at the end of the line.
347: If TEMPNAMEP is nonzero, this arg is a file that should be deleted
348: at the end of compilation. (If TEMPNAMEP is 2, delete the file
349: only if compilation is fully successful.) */
350:
351: void
352: store_arg (arg, tempnamep)
353: char *arg;
354: int tempnamep;
355: {
356: if (argbuf_index + 1 == argbuf_length)
357: {
358: argbuf = (char **) realloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
359: }
360:
361: argbuf[argbuf_index++] = arg;
362: argbuf[argbuf_index] = 0;
363:
364: if (tempnamep)
365: record_temp_file (arg, tempnamep == 2);
366: }
367:
368: /* Execute the command specified by the arguments on the current line of spec.
369: Returns 0 if successful, -1 if failed. */
370:
371: int
372: execute ()
373: {
374: int pid;
375: int status;
376: int size;
377: char *temp;
378: int win = 0;
379:
380: size = strlen (standard_exec_prefix);
381: if (user_exec_prefix != 0 && strlen (user_exec_prefix) > size)
382: size = strlen (user_exec_prefix);
383: if (strlen (standard_exec_prefix_1) > size)
384: size = strlen (standard_exec_prefix_1);
385: size += strlen (argbuf[0]) + 1;
386: temp = (char *) alloca (size);
387:
388: /* Determine the filename to execute. */
389:
390: if (user_exec_prefix)
391: {
392: strcpy (temp, user_exec_prefix);
393: strcat (temp, argbuf[0]);
394: win = (access (temp, X_OK) == 0);
395: }
396:
397: if (!win)
398: {
399: strcpy (temp, standard_exec_prefix);
400: strcat (temp, argbuf[0]);
401: win = (access (temp, X_OK) == 0);
402: }
403:
404: if (!win)
405: {
406: strcpy (temp, standard_exec_prefix_1);
407: strcat (temp, argbuf[0]);
408: win = (access (temp, X_OK) == 0);
409: }
410:
411: if (vflag)
412: {
413: int i;
414: for (i = 0; argbuf[i]; i++)
415: {
416: if (i == 0 && win)
417: fprintf (stderr, " %s", temp);
418: else
419: fprintf (stderr, " %s", argbuf[i]);
420: }
421: fprintf (stderr, "\n");
422: fflush (stderr);
423: #ifdef DEBUG
424: fprintf (stderr, "\nGo ahead? (y or n) ");
425: fflush (stderr);
426: i = getchar ();
427: if (i != '\n')
428: while (getchar () != '\n') ;
429: if (i != 'y' && i != 'Y')
430: return 0;
431: #endif /* DEBUG */
432: }
433:
434: #ifdef USG
435: pid = fork ();
436: if (pid < 0)
437: pfatal_with_name ("fork");
438: #else
439: pid = vfork ();
440: if (pid < 0)
441: pfatal_with_name ("vfork");
442: #endif
443: if (pid == 0)
444: {
445: if (win)
446: execv (temp, argbuf);
447: else
448: execvp (argbuf[0], argbuf);
449: perror_with_name (argbuf[0]);
450: _exit (65);
451: }
452: wait (&status);
453: if ((status & 0x7F) != 0)
454: fatal ("Program %s got fatal signal %d.", argbuf[0], (status & 0x7F));
455: if (((status & 0xFF00) >> 8) >= MIN_FATAL_STATUS)
456: return -1;
457: return 0;
458: }
459:
460: /* Find all the switches given to us
461: and make a vector describing them.
462: The elements of the vector a strings, one per switch given.
463: If a switch uses the following argument, then the `part1' field
464: is the switch itself and the `part2' field is the following argument. */
465:
466: struct switchstr
467: {
468: char *part1;
469: char *part2;
470: };
471:
472: struct switchstr *switches;
473:
474: int n_switches;
475:
476: /* Also a vector of input files specified. */
477:
478: char **infiles;
479:
480: int n_infiles;
481:
482: /* And a vector of corresponding output files is made up later. */
483:
484: char **outfiles;
485:
486: char *
487: make_switch (p1, s1, p2, s2)
488: char *p1;
489: int s1;
490: char *p2;
491: int s2;
492: {
493: register char *new;
494: if (p2 && s2 == 0)
495: s2 = strlen (p2);
496: new = (char *) xmalloc (s1 + s2 + 2);
497: bcopy (p1, new, s1);
498: if (p2)
499: {
500: new[s1++] = ' ';
501: bcopy (p2, new + s1, s2);
502: }
503: new[s1 + s2] = 0;
504: return new;
505: }
506:
507: /* Create the vector `switches' and its contents.
508: Store its length in `n_switches'. */
509:
510: void
511: process_command (argc, argv)
512: int argc;
513: char **argv;
514: {
515: register int i;
516: n_switches = 0;
517: n_infiles = 0;
518:
519: /* Scan argv twice. Here, the first time, just count how many switches
520: there will be in their vector, and how many input files in theirs.
521: Here we also parse the switches that cc itself uses (e.g. -v). */
522:
523: for (i = 1; i < argc; i++)
524: {
525: if (argv[i][0] == '-' && argv[i][1] != 'l')
526: {
527: register char *p = &argv[i][1];
528: register int c = *p;
529:
530: switch (c)
531: {
532: case 'B':
533: user_exec_prefix = p + 1;
534: break;
535:
536: case 'v': /* Print our subcommands and print versions. */
537: vflag++;
538: n_switches++;
539: break;
540:
541: default:
542: n_switches++;
543:
544: if (SWITCH_TAKES_ARG (c) && p[1] == 0)
545: i++;
546: }
547: }
548: else
549: n_infiles++;
550: }
551:
552: /* Then create the space for the vectors and scan again. */
553:
554: switches = ((struct switchstr *)
555: xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
556: infiles = (char **) xmalloc ((n_infiles + 1) * sizeof (char *));
557: n_switches = 0;
558: n_infiles = 0;
559:
560: /* This, time, copy the text of each switch and store a pointer
561: to the copy in the vector of switches.
562: Store all the infiles in their vector. */
563:
564: for (i = 1; i < argc; i++)
565: {
566: if (argv[i][0] == '-' && argv[i][1] != 'l')
567: {
568: register char *p = &argv[i][1];
569: register int c = *p;
570:
571: if (c == 'B')
572: continue;
573: switches[n_switches].part1 = p;
574: if (SWITCH_TAKES_ARG (c) && p[1] == 0)
575: switches[n_switches].part2 = argv[++i];
576: else
577: switches[n_switches].part2 = 0;
578: n_switches++;
579: }
580: else
581: infiles[n_infiles++] = argv[i];
582: }
583:
584: switches[n_switches].part1 = 0;
585: infiles[n_infiles] = 0;
586: }
587:
588: /* Process a spec string, accumulating and running commands. */
589:
590: /* These variables describe the input file name.
591: input_file_number is the index on outfiles of this file,
592: so that the output file name can be stored for later use by %o.
593: input_basename is the start of the part of the input file
594: sans all directory names, and basename_length is the number
595: of characters starting there excluding the suffix .c or whatever. */
596:
597: char *input_filename;
598: int input_file_number;
599: int input_filename_length;
600: int basename_length;
601: char *input_basename;
602:
603: /* These are variables used within do_spec and do_spec_1. */
604:
605: /* Nonzero if an arg has been started and not yet terminated
606: (with space, tab or newline). */
607: int arg_going;
608:
609: /* Nonzero means %d or %g has been seen; the next arg to be terminated
610: is a temporary file name. */
611: int delete_this_arg;
612:
613: /* Nonzero means %w has been seen; the next arg to be terminated
614: is the output file name of this compilation. */
615: int this_is_output_file;
616:
617: /* Nonzero means %s has been seen; the next arg to be terminated
618: is the name of a library file and we should try the standard
619: search dirs for it. */
620: int this_is_library_file;
621:
622: /* Process the spec SPEC and run the commands specified therein.
623: Returns 0 if the spec is successfully processed; -1 if failed. */
624:
625: int
626: do_spec (spec)
627: char *spec;
628: {
629: int value;
630:
631: clear_args ();
632: arg_going = 0;
633: delete_this_arg = 0;
634: this_is_output_file = 0;
635: this_is_library_file = 0;
636:
637: value = do_spec_1 (spec, 0);
638: if (value == 0)
639: value = do_spec_1 ("\n", 0);
640: return value;
641: }
642:
643: /* Process the sub-spec SPEC as a portion of a larger spec.
644: This is like processing a whole spec except that we do
645: not initialize at the beginning and we do not supply a
646: newline by default at the end.
647: INSWITCH nonzero means don't process %-sequences in SPEC;
648: in this case, % is treated as an ordinary character.
649: This is used while substituting switches.
650: INSWITCH nonzero also causes SPC not to terminate an argument.
651:
652: Value is zero unless a line was finished
653: and the command on that line reported an error. */
654:
655: int
656: do_spec_1 (spec, inswitch)
657: char *spec;
658: int inswitch;
659: {
660: register char *p = spec;
661: register int c;
662: char *string;
663:
664: while (c = *p++)
665: /* If substituting a switch, treat all chars like letters.
666: Otherwise, NL, SPC, TAB and % are special. */
667: switch (inswitch ? 'a' : c)
668: {
669: case '\n':
670: /* End of line: finish any pending argument,
671: then run the pending command if one has been started. */
672: if (arg_going)
673: {
674: obstack_1grow (&obstack, 0);
675: string = obstack_finish (&obstack);
676: if (this_is_library_file)
677: string = find_file (string);
678: store_arg (string, delete_this_arg);
679: if (this_is_output_file)
680: outfiles[input_file_number] = string;
681: }
682: arg_going = 0;
683: if (argbuf_index)
684: {
685: int value = execute ();
686: if (value)
687: return value;
688: }
689: /* Reinitialize for a new command, and for a new argument. */
690: clear_args ();
691: arg_going = 0;
692: delete_this_arg = 0;
693: this_is_output_file = 0;
694: this_is_library_file = 0;
695: break;
696:
697: case '\t':
698: case ' ':
699: /* Space or tab ends an argument if one is pending. */
700: if (arg_going)
701: {
702: obstack_1grow (&obstack, 0);
703: string = obstack_finish (&obstack);
704: if (this_is_library_file)
705: string = find_file (string);
706: store_arg (string, delete_this_arg);
707: if (this_is_output_file)
708: outfiles[input_file_number] = string;
709: }
710: /* Reinitialize for a new argument. */
711: arg_going = 0;
712: delete_this_arg = 0;
713: this_is_output_file = 0;
714: this_is_library_file = 0;
715: break;
716:
717: case '%':
718: switch (c = *p++)
719: {
720: case 0:
721: fatal ("Invalid specification! Bug in cc.");
722:
723: case 'i':
724: obstack_grow (&obstack, input_filename, input_filename_length);
725: arg_going = 1;
726: break;
727:
728: case 'b':
729: obstack_grow (&obstack, input_basename, basename_length);
730: arg_going = 1;
731: break;
732:
733: case 'p':
734: do_spec_1 (CPP_PREDEFINES, 0);
735: break;
736:
737: case 'g':
738: obstack_grow (&obstack, temp_filename, temp_filename_length);
739: delete_this_arg = 1;
740: arg_going = 1;
741: break;
742:
743: case 'd':
744: delete_this_arg = 2;
745: break;
746:
747: case 'w':
748: this_is_output_file = 1;
749: break;
750:
751: case 's':
752: this_is_library_file = 1;
753: break;
754:
755: case 'o':
756: {
757: register int f;
758: for (f = 0; f < n_infiles; f++)
759: store_arg (outfiles[f], 0);
760: }
761: break;
762:
763: case 'a':
764: do_spec_1 (ASM_SPEC, 0);
765: break;
766:
767: case 'c':
768: do_spec_1 (SIGNED_CHAR_SPEC, 0);
769: break;
770:
771: case 'l':
772: do_spec_1 (LINK_SPEC, 0);
773: break;
774:
775: case 'L':
776: do_spec_1 (LIB_SPEC, 0);
777: break;
778:
779: case 'S':
780: do_spec_1 (STARTFILE_SPEC, 0);
781: break;
782:
783: case '{':
784: p = handle_braces (p);
785: if (p == 0)
786: return -1;
787: break;
788:
789: case '%':
790: obstack_1grow (&obstack, '%');
791: break;
792:
793: default:
794: abort ();
795: }
796: break;
797:
798: default:
799: /* Ordinary character: put it into the current argument. */
800: obstack_1grow (&obstack, c);
801: arg_going = 1;
802: }
803:
804: return 0; /* End of string */
805: }
806:
807: /* Return 0 if we call do_spec_1 and that returns -1. */
808:
809: char *
810: handle_braces (p)
811: register char *p;
812: {
813: register char *q;
814: int negate = *p == '!';
815: char *filter;
816:
817: if (negate) ++p;
818:
819: filter = p;
820: while (*p != ':' && *p != '}') p++;
821: if (*p != '}')
822: {
823: register int count = 1;
824: q = p + 1;
825: while (count > 0)
826: {
827: if (*q == '{')
828: count++;
829: else if (*q == '}')
830: count--;
831: else if (*q == 0)
832: abort ();
833: q++;
834: }
835: }
836: else
837: q = p + 1;
838:
839: if (p[-1] == '*' && p[0] == '}')
840: {
841: /* Substitute all matching switches as separate args. */
842: register int i;
843: --p;
844: for (i = 0; i < n_switches; i++)
845: if (!strncmp (switches[i].part1, filter, p - filter))
846: {
847: give_switch (i);
848: }
849: }
850: else
851: {
852: /* Test for presence of the specified switch. */
853: register int i;
854: int present = 0;
855:
856: /* If name specified ends in *, as in {x*:...},
857: check for presence of any switch name starting with x. */
858: if (p[-1] == '*')
859: {
860: for (i = 0; i < n_switches; i++)
861: {
862: if (!strncmp (switches[i].part1, filter, p - filter - 1))
863: {
864: present = 1;
865: break;
866: }
867: }
868: }
869: /* Otherwise, check for presence of exact name specified. */
870: else
871: {
872: for (i = 0; i < n_switches; i++)
873: {
874: if (!strncmp (switches[i].part1, filter, p - filter)
875: && switches[i].part1[p - filter] == 0)
876: {
877: present = 1;
878: break;
879: }
880: }
881: }
882:
883: /* If it is as desired (present for %{s...}, absent for %{-s...})
884: then substitute either the switch or the specified
885: conditional text. */
886: if (present != negate)
887: {
888: if (*p == '}')
889: {
890: give_switch (i);
891: }
892: else
893: {
894: if (do_spec_1 (save_string (p + 1, q - p - 2), 0) < 0)
895: return 0;
896: }
897: }
898: }
899:
900: return q;
901: }
902:
903: /* Pass a switch to the current accumulating command
904: in the same form that we received it.
905: SWITCHNUM identifies the switch; it is an index into
906: the vector of switches gcc received, which is `switches'.
907: This cannot fail since it never finishes a command line. */
908:
909: give_switch (switchnum)
910: int switchnum;
911: {
912: do_spec_1 ("-", 0);
913: do_spec_1 (switches[switchnum].part1, 1);
914: do_spec_1 (" ", 0);
915: if (switches[switchnum].part2 != 0)
916: {
917: do_spec_1 (switches[switchnum].part2, 1);
918: do_spec_1 (" ", 0);
919: }
920: }
921:
922: /* Search for a file named NAME trying various prefixes including the
923: user's -B prefix and some standard ones.
924: Return the absolute pathname found. If nothing is found, return NAME. */
925:
926: char *
927: find_file (name)
928: char *name;
929: {
930: int size;
931: char *temp;
932: int win = 0;
933:
934: /* Compute maximum size of NAME plus any prefix we will try. */
935:
936: size = strlen (standard_exec_prefix);
937: if (user_exec_prefix != 0 && strlen (user_exec_prefix) > size)
938: size = strlen (user_exec_prefix);
939: if (strlen (standard_exec_prefix_1) > size)
940: size = strlen (standard_exec_prefix_1);
941: if (strlen (standard_startfile_prefix) > size)
942: size = strlen (standard_startfile_prefix);
943: if (strlen (standard_startfile_prefix_1) > size)
944: size = strlen (standard_startfile_prefix_1);
945: size += strlen (name) + 1;
946:
947: temp = (char *) alloca (size);
948:
949: if (user_exec_prefix)
950: {
951: strcpy (temp, user_exec_prefix);
952: strcat (temp, name);
953: win = (access (temp, R_OK) == 0);
954: }
955:
956: if (!win)
957: {
958: strcpy (temp, standard_exec_prefix);
959: strcat (temp, name);
960: win = (access (temp, R_OK) == 0);
961: }
962:
963: if (!win)
964: {
965: strcpy (temp, standard_exec_prefix_1);
966: strcat (temp, name);
967: win = (access (temp, R_OK) == 0);
968: }
969:
970: if (!win)
971: {
972: strcpy (temp, standard_startfile_prefix);
973: strcat (temp, name);
974: win = (access (temp, R_OK) == 0);
975: }
976:
977: if (!win)
978: {
979: strcpy (temp, standard_startfile_prefix_1);
980: strcat (temp, name);
981: win = (access (temp, R_OK) == 0);
982: }
983:
984: if (!win)
985: {
986: strcpy (temp, "./");
987: strcat (temp, name);
988: win = (access (temp, R_OK) == 0);
989: }
990:
991: if (win)
992: return save_string (temp, strlen (temp));
993: return name;
994: }
995:
996: /* Name with which this program was invoked. */
997:
998: char *programname;
999:
1000: /* On fatal signals, delete all the temporary files. */
1001:
1002: void
1003: fatal_error (signum)
1004: int signum;
1005: {
1006: signal (signum, SIG_DFL);
1007: delete_temp_files (0);
1008: /* Get the same signal again, this time not handled,
1009: so its normal effect occurs. */
1010: kill (getpid (), signum);
1011: }
1012:
1013: int
1014: main (argc, argv)
1015: int argc;
1016: char **argv;
1017: {
1018: register int i;
1019: int value;
1020: int nolink = 0;
1021: int error = 0;
1022: programname = argv[0];
1023:
1024: if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1025: signal (SIGINT, fatal_error);
1026: signal (SIGHUP, fatal_error);
1027: signal (SIGTERM, fatal_error);
1028:
1029: argbuf_length = 10;
1030: argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
1031:
1032: obstack_init (&obstack);
1033:
1034: choose_temp_base ();
1035:
1036: /* Make a table of what switches there are (switches, n_switches).
1037: Make a table of specified input files (infiles, n_infiles). */
1038:
1039: process_command (argc, argv);
1040:
1041: if (vflag)
1042: {
1043: extern char version_string[];
1044: printf ("gcc version %s\n", version_string);
1045: if (n_infiles == 0)
1046: exit (0);
1047: }
1048:
1049: if (n_infiles == 0)
1050: fatal ("No source or object files specified.");
1051:
1052: /* Make a place to record the compiler output file names
1053: that correspond to the input files. */
1054:
1055: outfiles = (char **) xmalloc (n_infiles * sizeof (char *));
1056: bzero (outfiles, n_infiles * sizeof (char *));
1057:
1058: for (i = 0; i < n_infiles; i++)
1059: {
1060: /* First figure out which compiler from the file's suffix. */
1061:
1062: register struct compiler *cp;
1063:
1064: /* Tell do_spec what to substitute for %i. */
1065:
1066: input_filename = infiles[i];
1067: input_filename_length = strlen (input_filename);
1068: input_file_number = i;
1069:
1070: /* Use the same thing in %o, unless cp->spec says otherwise. */
1071:
1072: outfiles[i] = input_filename;
1073:
1074: for (cp = compilers; cp->spec; cp++)
1075: {
1076: if (strlen (cp->suffix) < input_filename_length
1077: && !strcmp (cp->suffix,
1078: infiles[i] + input_filename_length
1079: - strlen (cp->suffix)))
1080: {
1081: /* Ok, we found an applicable compiler. Run its spec. */
1082: /* First say how much of input_filename to substitute for %b */
1083: register char *p;
1084:
1085: input_basename = input_filename;
1086: for (p = input_filename; *p; p++)
1087: if (*p == '/')
1088: input_basename = p + 1;
1089: basename_length = (input_filename_length - strlen (cp->suffix)
1090: - (input_basename - input_filename));
1091: value = do_spec (cp->spec);
1092: if (value < 0)
1093: error = 1;
1094: break;
1095: }
1096: }
1097:
1098: /* If this file's name does not contain a recognized suffix,
1099: don't do anything to it, but do feed it to the link spec
1100: since its name is in outfiles. */
1101: }
1102:
1103: /* Run ld to link all the compiler output files. */
1104:
1105: if (! nolink && error == 0)
1106: {
1107: value = do_spec (link_spec);
1108: if (value < 0)
1109: error = 1;
1110: }
1111:
1112: /* Delete some or all of the temporary files we made. */
1113:
1114: delete_temp_files (error == 0);
1115:
1116: exit (error);
1117: }
1118:
1119: xmalloc (size)
1120: int size;
1121: {
1122: register int value = malloc (size);
1123: if (value == 0)
1124: fatal ("Virtual memory full.");
1125: return value;
1126: }
1127:
1128: xrealloc (ptr, size)
1129: int ptr, size;
1130: {
1131: register int value = realloc (ptr, size);
1132: if (value == 0)
1133: fatal ("Virtual memory full.");
1134: return value;
1135: }
1136:
1137: fatal (msg, arg1, arg2)
1138: char *msg, *arg1, *arg2;
1139: {
1140: error (msg, arg1, arg2);
1141: delete_temp_files ();
1142: exit (1);
1143: }
1144:
1145: error (msg, arg1, arg2)
1146: char *msg, *arg1, *arg2;
1147: {
1148: fprintf (stderr, "%s: ", programname);
1149: fprintf (stderr, msg, arg1, arg2);
1150: fprintf (stderr, "\n");
1151: }
1152:
1153: /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */
1154:
1155: char *
1156: concat (s1, s2, s3)
1157: char *s1, *s2, *s3;
1158: {
1159: int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
1160: char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
1161:
1162: strcpy (result, s1);
1163: strcpy (result + len1, s2);
1164: strcpy (result + len1 + len2, s3);
1165: *(result + len1 + len2 + len3) = 0;
1166:
1167: return result;
1168: }
1169:
1170: char *
1171: save_string (s, len)
1172: char *s;
1173: int len;
1174: {
1175: register char *result = (char *) xmalloc (len + 1);
1176:
1177: bcopy (s, result, len);
1178: result[len] = 0;
1179: return result;
1180: }
1181:
1182: pfatal_with_name (name)
1183: char *name;
1184: {
1185: extern int errno, sys_nerr;
1186: extern char *sys_errlist[];
1187: char *s;
1188:
1189: if (errno < sys_nerr)
1190: s = concat ("", sys_errlist[errno], " for %s");
1191: else
1192: s = "cannot open %s";
1193: fatal (s, name);
1194: }
1195:
1196: perror_with_name (name)
1197: char *name;
1198: {
1199: extern int errno, sys_nerr;
1200: extern char *sys_errlist[];
1201: char *s;
1202:
1203: if (errno < sys_nerr)
1204: s = concat ("", sys_errlist[errno], " for %s");
1205: else
1206: s = "cannot open %s";
1207: error (s, name);
1208: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.