![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g++.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / cp|
Return to g++.c CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 root 1: /* G++ preliminary semantic processing for the compiler driver.
2: Copyright (C) 1993, 1994 Free Software Foundation, Inc.
3: Contributed by Brendan Kehoe ([email protected]).
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21: /* This program is a wrapper to the main `gcc' driver. For GNU C++,
22: we need to do two special things: a) append `-lg++' in situations
23: where it's appropriate, to link in libg++, and b) add `-xc++'..`-xnone'
24: around file arguments named `foo.c' or `foo.i'. So, we do all of
25: this semantic processing then just exec gcc with the new argument
26: list.
27:
28: We used to do all of this in a small shell script, but many users
29: found the performance of this as a shell script to be unacceptable.
30: In situations where your PATH has a lot of NFS-mounted directories,
31: using a script that runs sed and other things would be a nasty
32: performance hit. With this program, we never search the PATH at all. */
33:
34: #include "config.h"
35: #ifdef __STDC__
36: #include <stdarg.h>
37: #else
38: #include <varargs.h>
39: #endif
40: #include <stdio.h>
41: #include <sys/types.h>
42: #include <sys/file.h> /* May get R_OK, etc. on some systems. */
43: #include <errno.h>
44:
45: /* Defined to the name of the compiler; if using a cross compiler, the
46: Makefile should compile this file with the proper name
47: (e.g., "i386-aout-gcc"). */
48: #ifndef GCC_NAME
49: #define GCC_NAME "gcc"
50: #endif
51:
52: /* This bit is set if we saw a `-xfoo' language specification. */
53: #define LANGSPEC (1<<1)
54: /* This bit is set if they did `-lm' or `-lmath'. */
55: #define MATHLIB (1<<2)
56:
57: /* On MSDOS, write temp files in current dir
58: because there's no place else we can expect to use. */
59: #ifdef __MSDOS__
60: #ifndef P_tmpdir
61: #define P_tmpdir "."
62: #endif
63: #ifndef R_OK
64: #define R_OK 4
65: #define W_OK 2
66: #define X_OK 1
67: #endif
68: #endif
69:
70: #ifndef VPROTO
71: #ifdef __STDC__
72: #define PVPROTO(ARGS) ARGS
73: #define VPROTO(ARGS) ARGS
74: #define VA_START(va_list,var) va_start(va_list,var)
75: #else
76: #define PVPROTO(ARGS) ()
77: #define VPROTO(ARGS) (va_alist) va_dcl
78: #define VA_START(va_list,var) va_start(va_list)
79: #endif
80: #endif
81:
82: #ifndef errno
83: extern int errno;
84: #endif
85:
86: extern int sys_nerr;
87: #if defined(bsd4_4) || defined(__NetBSD__)
88: extern const char *const sys_errlist[];
89: #else
90: extern char *sys_errlist[];
91: #endif
92:
93: /* Name with which this program was invoked. */
94: static char *programname;
95:
96: #ifdef HAVE_VPRINTF
97: /* Output an error message and exit */
98:
99: static void
100: fatal VPROTO((char *format, ...))
101: {
102: #ifndef __STDC__
103: char *format;
104: #endif
105: va_list ap;
106:
107: VA_START (ap, format);
108:
109: #ifndef __STDC__
110: format = va_arg (ap, char*);
111: #endif
112:
113: fprintf (stderr, "%s: ", programname);
114: vfprintf (stderr, format, ap);
115: va_end (ap);
116: fprintf (stderr, "\n");
117: #if 0
118: /* XXX Not needed for g++ driver. */
119: delete_temp_files ();
120: #endif
121: exit (1);
122: }
123:
124: static void
125: error VPROTO((char *format, ...))
126: {
127: #ifndef __STDC__
128: char *format;
129: #endif
130: va_list ap;
131:
132: VA_START (ap, format);
133:
134: #ifndef __STDC__
135: format = va_arg (ap, char*);
136: #endif
137:
138: fprintf (stderr, "%s: ", programname);
139: vfprintf (stderr, format, ap);
140: va_end (ap);
141:
142: fprintf (stderr, "\n");
143: }
144:
145: #else /* not HAVE_VPRINTF */
146:
147: static void
148: error (msg, arg1, arg2)
149: char *msg, *arg1, *arg2;
150: {
151: fprintf (stderr, "%s: ", programname);
152: fprintf (stderr, msg, arg1, arg2);
153: fprintf (stderr, "\n");
154: }
155:
156: static void
157: fatal (msg, arg1, arg2)
158: char *msg, *arg1, *arg2;
159: {
160: error (msg, arg1, arg2);
161: #if 0
162: /* XXX Not needed for g++ driver. */
163: delete_temp_files ();
164: #endif
165: exit (1);
166: }
167:
168: #endif /* not HAVE_VPRINTF */
169:
170: /* More 'friendly' abort that prints the line and file.
171: config.h can #define abort fancy_abort if you like that sort of thing. */
172:
173: void
174: fancy_abort ()
175: {
176: fatal ("Internal g++ abort.");
177: }
178:
179: char *
180: xmalloc (size)
181: unsigned size;
182: {
183: register char *value = (char *) malloc (size);
184: if (value == 0)
185: fatal ("virtual memory exhausted");
186: return value;
187: }
188:
189: /* Return a newly-allocated string whose contents concatenate those
190: of s1, s2, s3. */
191: static char *
192: concat (s1, s2, s3)
193: char *s1, *s2, *s3;
194: {
195: int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
196: char *result = xmalloc (len1 + len2 + len3 + 1);
197:
198: strcpy (result, s1);
199: strcpy (result + len1, s2);
200: strcpy (result + len1 + len2, s3);
201: *(result + len1 + len2 + len3) = 0;
202:
203: return result;
204: }
205:
206: static void
207: pfatal_with_name (name)
208: char *name;
209: {
210: char *s;
211:
212: if (errno < sys_nerr)
213: s = concat ("%s: ", sys_errlist[errno], "");
214: else
215: s = "cannot open %s";
216: fatal (s, name);
217: }
218:
219: #ifdef __MSDOS__
220: /* This is the common prefix we use to make temp file names. */
221: char *temp_filename;
222:
223: /* Length of the prefix. */
224: int temp_filename_length;
225:
226: /* Compute a string to use as the base of all temporary file names. */
227: static char *
228: choose_temp_base_try (try, base)
229: char *try;
230: char *base;
231: {
232: char *rv;
233: if (base)
234: rv = base;
235: else if (try == (char *)0)
236: rv = 0;
237: else if (access (try, R_OK | W_OK) != 0)
238: rv = 0;
239: else
240: rv = try;
241: return rv;
242: }
243:
244: static void
245: choose_temp_base ()
246: {
247: char *base = 0;
248: int len;
249:
250: base = choose_temp_base_try (getenv ("TMPDIR"), base);
251: base = choose_temp_base_try (getenv ("TMP"), base);
252: base = choose_temp_base_try (getenv ("TEMP"), base);
253:
254: #ifdef P_tmpdir
255: base = choose_temp_base_try (P_tmpdir, base);
256: #endif
257:
258: base = choose_temp_base_try ("/usr/tmp", base);
259: base = choose_temp_base_try ("/tmp", base);
260:
261: /* If all else fails, use the current directory! */
262: if (base == (char *)0)
263: base = "./";
264:
265: len = strlen (base);
266: temp_filename = xmalloc (len + sizeof("/ccXXXXXX"));
267: strcpy (temp_filename, base);
268: if (len > 0 && temp_filename[len-1] != '/')
269: temp_filename[len++] = '/';
270: strcpy (temp_filename + len, "ccXXXXXX");
271:
272: mktemp (temp_filename);
273: temp_filename_length = strlen (temp_filename);
274: if (temp_filename_length == 0)
275: abort ();
276: }
277:
278: static void
279: perror_exec (name)
280: char *name;
281: {
282: char *s;
283:
284: if (errno < sys_nerr)
285: s = concat ("installation problem, cannot exec %s: ",
286: sys_errlist[errno], "");
287: else
288: s = "installation problem, cannot exec %s";
289: error (s, name);
290: }
291:
292: /* This is almost exactly what's in gcc.c:pexecute for MSDOS. */
293: void
294: run_dos (program, argv)
295: char *program;
296: char *argv[];
297: {
298: char *scmd, *rf;
299: FILE *argfile;
300: int i;
301:
302: choose_temp_base (); /* not in gcc.c */
303:
304: scmd = (char *) malloc (strlen (program) + strlen (temp_filename) + 10);
305: rf = scmd + strlen (program) + 6;
306: sprintf (scmd, "%s.exe @%s.gp", program, temp_filename);
307:
308: argfile = fopen (rf, "w");
309: if (argfile == 0)
310: pfatal_with_name (rf);
311:
312: for (i=1; argv[i]; i++)
313: {
314: char *cp;
315: for (cp = argv[i]; *cp; cp++)
316: {
317: if (*cp == '"' || *cp == '\'' || *cp == '\\' || isspace (*cp))
318: fputc ('\\', argfile);
319: fputc (*cp, argfile);
320: }
321: fputc ('\n', argfile);
322: }
323: fclose (argfile);
324:
325: i = system (scmd);
326:
327: remove (rf);
328:
329: if (i == -1)
330: perror_exec (program);
331: }
332: #endif /* __MSDOS__ */
333:
334: int
335: main (argc, argv)
336: int argc;
337: char **argv;
338: {
339: register int i, j = 0;
340: register char *p;
341: int verbose = 0;
342:
343: /* This will be NULL if we encounter a situation where we should not
344: link in libg++. */
345: char *library = "-lg++";
346:
347: /* Used to track options that take arguments, so we don't go wrapping
348: those with -xc++/-xnone. */
349: char *quote = NULL;
350:
351: /* The new argument list will be contained in this. */
352: char **arglist;
353:
354: /* The name of the compiler we will want to run---by default, it
355: will be the definition of `GCC_NAME', e.g., `gcc'. */
356: char *gcc = GCC_NAME;
357:
358: /* Non-zero if we saw a `-xfoo' language specification on the
359: command line. Used to avoid adding our own -xc++ if the user
360: already gave a language for the file. */
361: int saw_speclang = 0;
362:
363: /* Non-zero if we saw `-lm' or `-lmath' on the command line. */
364: int saw_math = 0;
365:
366: /* The number of arguments being added to what's in argv. By
367: default it's one new argument (adding `-lg++'). We use this
368: to track the number of times we've inserted -xc++/-xnone as well. */
369: int added = 1;
370:
371: /* An array used to flag each argument that needs a bit set for
372: LANGSPEC or MATHLIB. */
373: int *args;
374:
375: p = argv[0] + strlen (argv[0]);
376: while (p != argv[0] && p[-1] != '/')
377: --p;
378: programname = p;
379:
380: if (argc == 1)
381: fatal ("No input files specified.\n");
382:
383: #ifndef __MSDOS__
384: /* We do a little magic to find out where the main gcc executable
385: is. If they ran us as /usr/local/bin/g++, then we will look
386: for /usr/local/bin/gcc; similarly, if they just ran us as `g++',
387: we'll just look for `gcc'. */
388: if (p != argv[0])
389: {
390: *--p = '\0';
391: gcc = (char *) malloc ((strlen (argv[0]) + 1 + strlen (GCC_NAME) + 1)
392: * sizeof (char));
393: sprintf (gcc, "%s/%s", argv[0], GCC_NAME);
394: }
395: #endif
396:
397: args = (int *) malloc (argc * sizeof (int));
398: bzero ((char *) args, argc * sizeof (int));
399:
400: for (i = 1; i < argc; i++)
401: {
402: /* If the previous option took an argument, we swallow it here. */
403: if (quote)
404: {
405: quote = NULL;
406: continue;
407: }
408:
409: if (argv[i][0] == '\0' || argv[i][1] == '\0')
410: continue;
411:
412: if (argv[i][0] == '-')
413: {
414: if (strcmp (argv[i], "-nostdlib") == 0)
415: {
416: added--;
417: library = NULL;
418: }
419: else if (strcmp (argv[i], "-lm") == 0
420: || strcmp (argv[i], "-lmath") == 0)
421: args[i] |= MATHLIB;
422: else if (strcmp (argv[i], "-v") == 0)
423: {
424: verbose = 1;
425: if (argc == 2)
426: {
427: /* If they only gave us `-v', don't try to link
428: in libg++. */
429: added--;
430: library = NULL;
431: }
432: }
433: else if (strncmp (argv[i], "-x", 2) == 0)
434: saw_speclang = 1;
435: else if (((argv[i][2] == '\0'
436: && (char *)strchr ("bBVDUoeTuIYmLiA", argv[i][1]) != NULL)
437: || strcmp (argv[i], "-Tdata") == 0))
438: quote = argv[i];
439: else if (library != NULL && ((argv[i][2] == '\0'
440: && (char *) strchr ("cSEM", argv[i][1]) != NULL)
441: || strcmp (argv[i], "-MM") == 0))
442: {
443: /* Don't specify libraries if we won't link, since that would
444: cause a warning. */
445: added--;
446: library = NULL;
447: }
448: else
449: /* Pass other options through. */
450: continue;
451: }
452: else
453: {
454: int len;
455:
456: if (saw_speclang)
457: {
458: saw_speclang = 0;
459: continue;
460: }
461:
462: /* If the filename ends in .c or .i, put options around it.
463: But not if a specified -x option is currently active. */
464: len = strlen (argv[i]);
465: if (len > 2
466: && (argv[i][len - 1] == 'c' || argv[i][len - 1] == 'i')
467: && argv[i][len - 2] == '.')
468: {
469: args[i] |= LANGSPEC;
470: added += 2;
471: }
472: }
473: }
474:
475: if (quote)
476: fatal ("argument to `%s' missing\n", quote);
477:
478: if (added)
479: {
480: arglist = (char **) malloc ((argc + added + 1) * sizeof (char *));
481:
482: for (i = 1, j = 1; i < argc; i++, j++)
483: {
484: arglist[j] = argv[i];
485:
486: /* Make sure -lg++ is before the math library, since libg++
487: itself uses those math routines. */
488: if (!saw_math && (args[i] & MATHLIB) && library)
489: {
490: saw_math = 1;
491: arglist[j] = library;
492: arglist[++j] = argv[i];
493: }
494:
495: /* Wrap foo.c and foo.i files in a language specification to
496: force the gcc compiler driver to run cc1plus on them. */
497: if (args[i] & LANGSPEC)
498: {
499: int len = strlen (argv[i]);
500: if (argv[i][len - 1] == 'i')
501: arglist[j++] = "-xc++-cpp-output";
502: else
503: arglist[j++] = "-xc++";
504: arglist[j++] = argv[i];
505: arglist[j] = "-xnone";
506: }
507: }
508:
509: /* Add `-lg++' if we haven't already done so. */
510: if (library && !saw_math)
511: arglist[j++] = library;
512:
513: arglist[j] = NULL;
514: }
515: else
516: /* No need to copy 'em all. */
517: arglist = argv;
518:
519: arglist[0] = gcc;
520:
521: if (verbose)
522: {
523: if (j == 0)
524: j = argc;
525:
526: for (i = 0; i < j; i++)
527: fprintf (stderr, " %s", arglist[i]);
528: fprintf (stderr, "\n");
529: }
530: #ifndef OS2
531: #ifdef __MSDOS__
532: run_dos (gcc, arglist);
533: #else /* !__MSDOS__ */
534: if (execvp (gcc, arglist) < 0)
535: pfatal_with_name (gcc);
536: #endif /* __MSDOS__ */
537: #else /* OS2 */
538: if (spawnvp (gcc, arglist) < 0)
539: pfatal_with_name (gcc);
540: #endif
541:
542: return 0;
543: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.